@oneuptime/common 10.5.3 → 10.5.4

package/Models/DatabaseModels/AlertGroupingRule.ts

@@ -811,6 +811,82 @@ export default class AlertGroupingRule extends BaseModel {
   })
   public groupByAlertTitle?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateAlertGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.AlertAdmin,
+      Permission.AlertMember,
+      Permission.AlertViewer,
+      Permission.ReadAlertGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditAlertGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Alert Labels",
+    description:
+      "When enabled, alerts with different sets of labels will be grouped into separate episodes (exact set match). When disabled, alert labels are ignored for grouping.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByAlertLabels?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateAlertGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.AlertAdmin,
+      Permission.AlertMember,
+      Permission.AlertViewer,
+      Permission.ReadAlertGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditAlertGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Monitor Labels",
+    description:
+      "When enabled, alerts whose monitors have different sets of labels will be grouped into separate episodes (exact set match). When disabled, monitor labels are ignored for grouping.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByMonitorLabels?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/IncidentGroupingRule.ts

@@ -815,6 +815,82 @@ export default class IncidentGroupingRule extends BaseModel {
   })
   public groupByIncidentTitle?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Incident Labels",
+    description:
+      "When enabled, incidents with different sets of labels will be grouped into separate episodes (exact set match). When disabled, incident labels are ignored for grouping.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByIncidentLabels?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Monitor Labels",
+    description:
+      "When enabled, incidents whose monitors have different sets of labels will be grouped into separate episodes (exact set match). When disabled, monitor labels are ignored for grouping.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByMonitorLabels?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Server/Infrastructure/Postgres/SchemaMigrations/1779971548393-AddLabelGroupByToGroupingRules.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddLabelGroupByToGroupingRules1779971548393
+  implements MigrationInterface
+{
+  public name: string = "AddLabelGroupByToGroupingRules1779971548393";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ADD "groupByIncidentLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ADD "groupByMonitorLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ADD "groupByAlertLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ADD "groupByMonitorLabels" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" DROP COLUMN "groupByMonitorLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" DROP COLUMN "groupByAlertLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" DROP COLUMN "groupByMonitorLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" DROP COLUMN "groupByIncidentLabels"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -356,6 +356,7 @@ import { ExpandOwnerRuleInheritFlags1779823516881 } from "./1779823516881-Expand
 import { RenameStatusPageZhToZhCN1779827700000 } from "./1779827700000-RenameStatusPageZhToZhCN";
 import { MigrationName1779879993421 } from "./1779879993421-MigrationName";
 import { MigrationName1779882573463 } from "./1779882573463-MigrationName";
+import { AddLabelGroupByToGroupingRules1779971548393 } from "./1779971548393-AddLabelGroupByToGroupingRules";
 
 export default [
   InitialMigration,
@@ -716,4 +717,5 @@ export default [
   RenameStatusPageZhToZhCN1779827700000,
   MigrationName1779879993421,
   MigrationName1779882573463,
+  AddLabelGroupByToGroupingRules1779971548393,
 ];

package/Server/Services/AlertGroupingEngineService.ts

@@ -16,6 +16,7 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import QueryHelper from "../Types/Database/QueryHelper";
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
+import AlertService from "./AlertService";
 import AlertEpisodeService from "./AlertEpisodeService";
 import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
 import AlertEpisodeOwnerUserService from "./AlertEpisodeOwnerUserService";
@@ -91,6 +92,8 @@ class AlertGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByAlertTitle: true,
+            groupByAlertLabels: true,
+            groupByMonitorLabels: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -555,10 +558,84 @@ class AlertGroupingEngineServiceClass {
       parts.push(`title:${normalizedTitle}`);
     }
 
+    // Group by alert labels (exact set match) - only if explicitly enabled
+    if (rule.groupByAlertLabels && alert.id) {
+      const alertLabels: Array<Label> = await this.getAlertLabels(alert);
+      const sortedLabelIds: Array<string> = alertLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`alertLabels:${sortedLabelIds.join(",")}`);
+    }
+
+    // Group by monitor labels (exact set match) - only if explicitly enabled
+    if (rule.groupByMonitorLabels && alert.monitorId) {
+      const monitorLabels: Array<Label> = await this.getMonitorLabels(
+        alert.monitorId,
+      );
+      const sortedLabelIds: Array<string> = monitorLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`monitorLabels:${sortedLabelIds.join(",")}`);
+    }
+
     // If no group by options are enabled, all matching alerts go into a single episode
     return parts.join("|") || "default";
   }
 
+  @CaptureSpan()
+  private async getAlertLabels(alert: Alert): Promise<Array<Label>> {
+    // If labels are already loaded on the alert, use them
+    if (alert.labels && Array.isArray(alert.labels)) {
+      return alert.labels;
+    }
+
+    if (!alert.id) {
+      return [];
+    }
+
+    // Re-load alert with labels
+    const reloadedAlert: Alert | null = await AlertService.findOneById({
+      id: alert.id,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return reloadedAlert?.labels || [];
+  }
+
+  @CaptureSpan()
+  private async getMonitorLabels(monitorId: ObjectID): Promise<Array<Label>> {
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: monitorId,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return monitor?.labels || [];
+  }
+
   @CaptureSpan()
   private async findMatchingActiveEpisode(
     projectId: ObjectID,
@@ -793,6 +870,12 @@ class AlertGroupingEngineServiceClass {
         if (rule.groupByAlertTitle) {
           groupByParts.push("Alert Title");
         }
+        if (rule.groupByAlertLabels) {
+          groupByParts.push("Alert Labels");
+        }
+        if (rule.groupByMonitorLabels) {
+          groupByParts.push("Monitor Labels");
+        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Server/Services/IncidentGroupingEngineService.ts

@@ -17,6 +17,7 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import QueryHelper from "../Types/Database/QueryHelper";
 import IncidentGroupingRuleService from "./IncidentGroupingRuleService";
+import IncidentService from "./IncidentService";
 import IncidentEpisodeService from "./IncidentEpisodeService";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
 import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
@@ -93,6 +94,8 @@ class IncidentGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByIncidentTitle: true,
+            groupByIncidentLabels: true,
+            groupByMonitorLabels: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -613,10 +616,100 @@ class IncidentGroupingEngineServiceClass {
       parts.push(`title:${normalizedTitle}`);
     }
 
+    // Group by incident labels (exact set match) - only if explicitly enabled
+    if (rule.groupByIncidentLabels && incident.id) {
+      const incidentLabels: Array<Label> =
+        await this.getIncidentLabels(incident);
+      const sortedLabelIds: Array<string> = incidentLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`incidentLabels:${sortedLabelIds.join(",")}`);
+    }
+
+    /*
+     * Group by monitor labels (exact set match) - only if explicitly enabled
+     * Incidents can be associated with multiple monitors; we union and dedupe labels across all of them.
+     */
+    if (
+      rule.groupByMonitorLabels &&
+      incident.monitors &&
+      incident.monitors.length > 0
+    ) {
+      const monitorLabelIdSet: Set<string> = new Set<string>();
+      for (const incidentMonitor of incident.monitors) {
+        if (!incidentMonitor || !incidentMonitor.id) {
+          continue;
+        }
+        const monitorLabels: Array<Label> = await this.getMonitorLabels(
+          incidentMonitor.id,
+        );
+        for (const label of monitorLabels) {
+          const labelIdStr: string = label.id?.toString() || "";
+          if (labelIdStr.length > 0) {
+            monitorLabelIdSet.add(labelIdStr);
+          }
+        }
+      }
+      const sortedLabelIds: Array<string> =
+        Array.from(monitorLabelIdSet).sort();
+      parts.push(`monitorLabels:${sortedLabelIds.join(",")}`);
+    }
+
     // If no group by options are enabled, all matching incidents go into a single episode
     return parts.join("|") || "default";
   }
 
+  @CaptureSpan()
+  private async getIncidentLabels(incident: Incident): Promise<Array<Label>> {
+    // If labels are already loaded on the incident, use them
+    if (incident.labels && Array.isArray(incident.labels)) {
+      return incident.labels;
+    }
+
+    if (!incident.id) {
+      return [];
+    }
+
+    // Re-load incident with labels
+    const reloadedIncident: Incident | null = await IncidentService.findOneById(
+      {
+        id: incident.id,
+        select: {
+          labels: {
+            _id: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      },
+    );
+
+    return reloadedIncident?.labels || [];
+  }
+
+  @CaptureSpan()
+  private async getMonitorLabels(monitorId: ObjectID): Promise<Array<Label>> {
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: monitorId,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return monitor?.labels || [];
+  }
+
   @CaptureSpan()
   private async findMatchingActiveEpisode(
     projectId: ObjectID,
@@ -887,6 +980,12 @@ class IncidentGroupingEngineServiceClass {
         if (rule.groupByIncidentTitle) {
           groupByParts.push("Incident Title");
         }
+        if (rule.groupByIncidentLabels) {
+          groupByParts.push("Incident Labels");
+        }
+        if (rule.groupByMonitorLabels) {
+          groupByParts.push("Monitor Labels");
+        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Tests/Server/Services/AlertGroupingEngineService.test.ts

@@ -232,6 +232,34 @@ describe("AlertGroupingEngineService Models", () => {
       );
       expect(groupingKey).toContain(`title:${mockAlert.title}`);
     });
+
+    test("should produce identical label key regardless of label order (exact set match)", () => {
+      // Simulates buildGroupingKey's label-sorting logic.
+      const labelIdsA: string[] = ["lbl-c", "lbl-a", "lbl-b"];
+      const labelIdsB: string[] = ["lbl-b", "lbl-c", "lbl-a"];
+
+      const keyA: string = `alertLabels:${[...labelIdsA].sort().join(",")}`;
+      const keyB: string = `alertLabels:${[...labelIdsB].sort().join(",")}`;
+
+      expect(keyA).toBe(keyB);
+      expect(keyA).toBe("alertLabels:lbl-a,lbl-b,lbl-c");
+    });
+
+    test("should produce different label keys for different label sets (exact set match)", () => {
+      // Alerts with [A,B] and [A,C] must NOT group together under exact set match.
+      const keyAB: string = `alertLabels:${["lbl-a", "lbl-b"].sort().join(",")}`;
+      const keyAC: string = `alertLabels:${["lbl-a", "lbl-c"].sort().join(",")}`;
+
+      expect(keyAB).not.toBe(keyAC);
+    });
+
+    test("should emit empty label key when alert has no labels", () => {
+      // Alerts with no labels should produce the same (empty) label key.
+      const labelIds: string[] = [];
+      const key: string = `alertLabels:${[...labelIds].sort().join(",")}`;
+
+      expect(key).toBe("alertLabels:");
+    });
   });
 
   describe("Time Window Configuration", () => {

package/Tests/Server/Services/AlertGroupingRuleService.test.ts

@@ -143,14 +143,28 @@ describe("AlertGroupingRule Model", () => {
       expect(rule.groupByAlertTitle).toBe(true);
     });
 
+    test("should set and get groupByAlertLabels correctly", () => {
+      rule.groupByAlertLabels = true;
+      expect(rule.groupByAlertLabels).toBe(true);
+    });
+
+    test("should set and get groupByMonitorLabels correctly", () => {
+      rule.groupByMonitorLabels = true;
+      expect(rule.groupByMonitorLabels).toBe(true);
+    });
+
     test("should handle all groupBy options as false", () => {
       rule.groupByMonitor = false;
       rule.groupBySeverity = false;
       rule.groupByAlertTitle = false;
+      rule.groupByAlertLabels = false;
+      rule.groupByMonitorLabels = false;
 
       expect(rule.groupByMonitor).toBe(false);
       expect(rule.groupBySeverity).toBe(false);
       expect(rule.groupByAlertTitle).toBe(false);
+      expect(rule.groupByAlertLabels).toBe(false);
+      expect(rule.groupByMonitorLabels).toBe(false);
     });
 
     test("should handle combination of groupBy options", () => {

package/UI/Components/Accordion/Accordion.tsx

@@ -75,7 +75,9 @@ const Accordion: FunctionComponent<ComponentProps> = (
     <div className={className}>
       <div>
         <div
-          className={`flex justify-between items-start gap-3 cursor-pointer group/accordion-header rounded-lg -mx-2 px-2 py-2 transition-colors ${
+          className={`flex justify-between ${
+            props.description ? "items-start" : "items-center"
+          } gap-3 cursor-pointer group/accordion-header rounded-lg -mx-2 px-2 py-2 transition-colors ${
             isOpen ? "" : "hover:bg-gray-50/80"
           }`}
           role="button"
@@ -87,10 +89,16 @@ const Accordion: FunctionComponent<ComponentProps> = (
           }}
           onKeyDown={handleKeyDown}
         >
-          <div className="flex items-start min-w-0 flex-1">
+          <div
+            className={`flex ${
+              props.description ? "items-start" : "items-center"
+            } min-w-0 flex-1`}
+          >
             {props.title && (
               <div
-                className={`flex-shrink-0 mt-0.5 flex items-center justify-center w-6 h-6 rounded-md transition-all duration-200 ${
+                className={`flex-shrink-0 ${
+                  props.description ? "mt-0.5" : ""
+                } flex items-center justify-center w-6 h-6 rounded-md transition-all duration-200 ${
                   isOpen
                     ? "bg-gray-900/5 text-gray-700"
                     : "text-gray-400 group-hover/accordion-header:bg-gray-900/5 group-hover/accordion-header:text-gray-700"
@@ -126,7 +134,7 @@ const Accordion: FunctionComponent<ComponentProps> = (
             )}
           </div>
           {!isOpen && props.rightElement && (
-            <div className="flex-shrink-0 mt-0.5">{props.rightElement}</div>
+            <div className="flex-shrink-0">{props.rightElement}</div>
           )}
         </div>
         {isOpen && (

package/build/dist/Models/DatabaseModels/AlertGroupingRule.js

@@ -54,6 +54,8 @@ let AlertGroupingRule = class AlertGroupingRule extends BaseModel {
         this.groupByMonitor = undefined;
         this.groupBySeverity = undefined;
         this.groupByAlertTitle = undefined;
+        this.groupByAlertLabels = undefined;
+        this.groupByMonitorLabels = undefined;
         this.enableTimeWindow = undefined;
         this.timeWindowMinutes = undefined;
         this.groupByFields = undefined;
@@ -780,6 +782,82 @@ __decorate([
     }),
     __metadata("design:type", Boolean)
 ], AlertGroupingRule.prototype, "groupByAlertTitle", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.CreateAlertGroupingRule,
+        ],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+            Permission.AlertAdmin,
+            Permission.AlertMember,
+            Permission.AlertViewer,
+            Permission.ReadAlertGroupingRule,
+        ],
+        update: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.EditAlertGroupingRule,
+        ],
+    }),
+    TableColumn({
+        required: false,
+        type: TableColumnType.Boolean,
+        title: "Group By Alert Labels",
+        description: "When enabled, alerts with different sets of labels will be grouped into separate episodes (exact set match). When disabled, alert labels are ignored for grouping.",
+        defaultValue: false,
+        isDefaultValueColumn: true,
+    }),
+    Column({
+        type: ColumnType.Boolean,
+        nullable: false,
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], AlertGroupingRule.prototype, "groupByAlertLabels", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.CreateAlertGroupingRule,
+        ],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+            Permission.AlertAdmin,
+            Permission.AlertMember,
+            Permission.AlertViewer,
+            Permission.ReadAlertGroupingRule,
+        ],
+        update: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.EditAlertGroupingRule,
+        ],
+    }),
+    TableColumn({
+        required: false,
+        type: TableColumnType.Boolean,
+        title: "Group By Monitor Labels",
+        description: "When enabled, alerts whose monitors have different sets of labels will be grouped into separate episodes (exact set match). When disabled, monitor labels are ignored for grouping.",
+        defaultValue: false,
+        isDefaultValueColumn: true,
+    }),
+    Column({
+        type: ColumnType.Boolean,
+        nullable: false,
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], AlertGroupingRule.prototype, "groupByMonitorLabels", void 0);
 __decorate([
     ColumnAccessControl({
         create: [