@oneuptime/common 10.5.3 → 10.5.6

package/Models/DatabaseModels/AlertEpisodeMember.ts

@@ -626,6 +626,35 @@ export default class AlertEpisodeMember extends BaseModel {
   })
   public createdByUserId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.AlertAdmin,
+      Permission.AlertMember,
+      Permission.AlertViewer,
+      Permission.ReadAlertEpisodeMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Owner Notified of Alert Added to Episode",
+    description:
+      "Has the owner been notified that this alert was added to the episode?",
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isOwnerNotifiedOfAlertAdded?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

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/GlobalConfig.ts

@@ -10,6 +10,7 @@ import TableColumn from "../../Types/Database/TableColumn";
 import TableColumnType from "../../Types/Database/TableColumnType";
 import TableMetadata from "../../Types/Database/TableMetadata";
 import Email from "../../Types/Email";
+import MailTransportType from "../../Types/Email/MailTransportType";
 import OAuthProviderType from "../../Types/Email/OAuthProviderType";
 import SMTPAuthenticationType from "../../Types/Email/SMTPAuthenticationType";
 import IconProp from "../../Types/Icon/IconProp";
@@ -208,6 +209,33 @@ export default class GlobalConfig extends GlobalConfigModel {
   })
   public smtpFromName?: string = undefined;
 
+  /*
+   * Transport selection for the global SMTP. Defaults to SMTP for backwards
+   * compatibility. 'Microsoft Graph' bypasses SMTP entirely and posts to
+   * https://graph.microsoft.com/v1.0/users/{from}/sendMail — useful for tenants
+   * that have SMTP AUTH disabled.
+   */
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    title: "SMTP Transport",
+    description:
+      "How OneUptime delivers mail using the global SMTP config. 'SMTP' uses the host/port. 'Microsoft Graph' sends via the Microsoft Graph REST API.",
+    defaultValue: MailTransportType.SMTP,
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+    default: MailTransportType.SMTP,
+  })
+  public smtpTransportType?: MailTransportType = undefined;
+
   // SMTP OAuth 2.0 Settings.
 
   @ColumnAccessControl({

package/Models/DatabaseModels/IncidentEpisodeMember.ts

@@ -627,6 +627,35 @@ export default class IncidentEpisodeMember extends BaseModel {
   })
   public createdByUserId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.IncidentViewer,
+      Permission.ReadIncidentEpisodeMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Owner Notified of Incident Added to Episode",
+    description:
+      "Has the owner been notified that this incident was added to the episode?",
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isOwnerNotifiedOfIncidentAdded?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

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/Models/DatabaseModels/ProjectSmtpConfig.ts

@@ -17,6 +17,7 @@ import TableMetadata from "../../Types/Database/TableMetadata";
 import TenantColumn from "../../Types/Database/TenantColumn";
 import UniqueColumnBy from "../../Types/Database/UniqueColumnBy";
 import Email from "../../Types/Email";
+import MailTransportType from "../../Types/Email/MailTransportType";
 import OAuthProviderType from "../../Types/Email/OAuthProviderType";
 import SMTPAuthenticationType from "../../Types/Email/SMTPAuthenticationType";
 import IconProp from "../../Types/Icon/IconProp";
@@ -478,12 +479,15 @@ export default class ProjectSmtpConfig extends BaseModel {
     ],
   })
   @TableColumn({
-    required: true,
+    required: false,
     type: TableColumnType.ShortText,
+    title: "Hostname",
+    description:
+      "SMTP server hostname. Required when Transport is SMTP. Not used by HTTP-API transports like Microsoft Graph.",
     example: "smtp.gmail.com",
   })
   @Column({
-    nullable: false,
+    nullable: true,
     type: ColumnType.ShortText,
     length: ColumnLength.ShortText,
     transformer: Hostname.getDatabaseTransformer(),
@@ -513,12 +517,15 @@ export default class ProjectSmtpConfig extends BaseModel {
     ],
   })
   @TableColumn({
-    required: true,
+    required: false,
     type: TableColumnType.Number,
+    title: "Port",
+    description:
+      "SMTP server port. Required when Transport is SMTP. Not used by HTTP-API transports.",
     example: 587,
   })
   @Column({
-    nullable: false,
+    nullable: true,
     type: ColumnType.Number,
     transformer: Port.getDatabaseTransformer(),
   })
@@ -616,18 +623,67 @@ export default class ProjectSmtpConfig extends BaseModel {
     ],
   })
   @TableColumn({
-    required: true,
+    required: false,
     type: TableColumnType.Boolean,
+    title: "Use SSL / TLS",
+    description:
+      "Enable secure SMTP connection. Used only for SMTP transport — HTTP-API transports always use HTTPS.",
     defaultValue: true,
     example: true,
   })
   @Column({
-    nullable: false,
+    nullable: true,
     type: ColumnType.Boolean,
     default: true,
   })
   public secure?: boolean = undefined;
 
+  /*
+   * Transport type selects how mail is actually delivered.
+   * SMTP (default) uses the host/port above. HTTP-API transports (e.g. Microsoft
+   * Graph) ignore host/port and call the provider's REST API directly using the
+   * OAuth credentials below.
+   */
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateProjectSMTPConfig,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadProjectSMTPConfig,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditProjectSMTPConfig,
+    ],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Transport",
+    description:
+      "How OneUptime delivers mail for this config. 'SMTP' uses the hostname/port. 'Microsoft Graph' sends via the Microsoft Graph REST API — use this when your Microsoft 365 tenant has SMTP AUTH disabled.",
+    defaultValue: MailTransportType.SMTP,
+    example: "SMTP",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    default: MailTransportType.SMTP,
+  })
+  public transportType?: MailTransportType = undefined;
+
   // OAuth 2.0 Configuration Fields
 
   @ColumnAccessControl({

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/1779975064262-AddTransportTypeToProjectSmtpConfig.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddTransportTypeToProjectSmtpConfig1779975064262
+  implements MigrationInterface
+{
+  name = "AddTransportTypeToProjectSmtpConfig1779975064262";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ADD "transportType" character varying(100) NOT NULL DEFAULT 'SMTP'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "hostname" DROP NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "port" DROP NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "secure" DROP NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "secure" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "port" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" ALTER COLUMN "hostname" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectSMTPConfig" DROP COLUMN "transportType"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779976190561-AddSmtpTransportTypeToGlobalConfig.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddSmtpTransportTypeToGlobalConfig1779976190561
+  implements MigrationInterface
+{
+  name = "AddSmtpTransportTypeToGlobalConfig1779976190561";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "smtpTransportType" character varying(100) DEFAULT 'SMTP'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "smtpTransportType"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779980428744-MigrationName.ts

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1779980428744 implements MigrationInterface {
+  public name = "MigrationName1779980428744";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertEpisodeMember" ADD "isOwnerNotifiedOfAlertAdded" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeMember" ADD "isOwnerNotifiedOfIncidentAdded" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisodeMember" DROP COLUMN "isOwnerNotifiedOfIncidentAdded"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertEpisodeMember" DROP COLUMN "isOwnerNotifiedOfAlertAdded"`,
+    );
+  }
+}

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

@@ -356,6 +356,10 @@ 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";
+import { AddTransportTypeToProjectSmtpConfig1779975064262 } from "./1779975064262-AddTransportTypeToProjectSmtpConfig";
+import { AddSmtpTransportTypeToGlobalConfig1779976190561 } from "./1779976190561-AddSmtpTransportTypeToGlobalConfig";
+import { MigrationName1779980428744 } from "./1779980428744-MigrationName";
 
 export default [
   InitialMigration,
@@ -716,4 +720,8 @@ export default [
   RenameStatusPageZhToZhCN1779827700000,
   MigrationName1779879993421,
   MigrationName1779882573463,
+  AddLabelGroupByToGroupingRules1779971548393,
+  AddTransportTypeToProjectSmtpConfig1779975064262,
+  AddSmtpTransportTypeToGlobalConfig1779976190561,
+  MigrationName1779980428744,
 ];

package/Server/Services/AlertEpisodeMemberService.ts

@@ -4,6 +4,7 @@ import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/AlertEpisodeMember";
 import Alert from "../../Models/DatabaseModels/Alert";
 import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
@@ -62,6 +63,28 @@ export class Service extends DatabaseService<Model> {
       createBy.data.addedAt = OneUptimeDate.getCurrentDate();
     }
 
+    /*
+     * If this is the very first alert in the episode (the founder), the
+     * "episode created" notification already covers it. Mark the member as
+     * "already notified" so the AlertAdded-to-episode cron skips it. This
+     * avoids double-notifying owners when an episode is born with its first
+     * alert.
+     */
+    if (createBy.data.isOwnerNotifiedOfAlertAdded === undefined) {
+      const existingMemberCount: PositiveNumber = await this.countBy({
+        query: {
+          alertEpisodeId: createBy.data.alertEpisodeId,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (existingMemberCount.toNumber() === 0) {
+        createBy.data.isOwnerNotifiedOfAlertAdded = true;
+      }
+    }
+
     return { createBy, carryForward: null };
   }
 

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