@oneuptime/common 13.0.1 → 13.0.3

package/Server/Infrastructure/Postgres/SchemaMigrations/1792600000000-AddIncomingCallPolicyPhoneNumbers.ts

@@ -0,0 +1,72 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddIncomingCallPolicyPhoneNumbers1792600000000
+  implements MigrationInterface
+{
+  public readonly name: string =
+    "AddIncomingCallPolicyPhoneNumbers1792600000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "IncomingCallPolicyPhoneNumber" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "incomingCallPolicyId" uuid NOT NULL, "projectCallSMSConfigId" uuid NOT NULL, "phoneNumber" character varying(30) NOT NULL, "callProviderPhoneNumberId" character varying(100) NOT NULL, "countryCode" character varying(100), "areaCode" character varying(100), "phoneNumberPurchasedAt" TIMESTAMP WITH TIME ZONE, CONSTRAINT "PK_46893187d82b3d39788b04be920" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_1e34c7280fa570f4fc9082ecd6" ON "IncomingCallPolicyPhoneNumber" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d8c4476e7f18b58ae724bc43c7" ON "IncomingCallPolicyPhoneNumber" ("incomingCallPolicyId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_908415bd52e7502b68e1dc2aa7" ON "IncomingCallPolicyPhoneNumber" ("projectCallSMSConfigId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b3c04dcef639a36641dd3a3ed4" ON "IncomingCallPolicyPhoneNumber" ("incomingCallPolicyId", "projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_INCOMING_CALL_POLICY_PROVIDER_PHONE_NUMBER_UNIQUE" ON "IncomingCallPolicyPhoneNumber" ("projectCallSMSConfigId", "callProviderPhoneNumberId") WHERE "deletedAt" IS NULL`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_INCOMING_CALL_POLICY_PHONE_NUMBER_UNIQUE" ON "IncomingCallPolicyPhoneNumber" ("phoneNumber") WHERE "deletedAt" IS NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" ADD CONSTRAINT "FK_1e34c7280fa570f4fc9082ecd6f" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" ADD CONSTRAINT "FK_d8c4476e7f18b58ae724bc43c74" FOREIGN KEY ("incomingCallPolicyId") REFERENCES "IncomingCallPolicy"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" ADD CONSTRAINT "FK_908415bd52e7502b68e1dc2aa7d" FOREIGN KEY ("projectCallSMSConfigId") REFERENCES "ProjectCallSMSConfig"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" DROP CONSTRAINT "FK_908415bd52e7502b68e1dc2aa7d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" DROP CONSTRAINT "FK_d8c4476e7f18b58ae724bc43c74"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncomingCallPolicyPhoneNumber" DROP CONSTRAINT "FK_1e34c7280fa570f4fc9082ecd6f"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_INCOMING_CALL_POLICY_PHONE_NUMBER_UNIQUE"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_INCOMING_CALL_POLICY_PROVIDER_PHONE_NUMBER_UNIQUE"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b3c04dcef639a36641dd3a3ed4"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_908415bd52e7502b68e1dc2aa7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d8c4476e7f18b58ae724bc43c7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_1e34c7280fa570f4fc9082ecd6"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncomingCallPolicyPhoneNumber"`);
+  }
+}

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

@@ -1,4 +1,7 @@
+import { AddConfigurableRuleCriteria1792500000000 } from "./1792500000000-AddConfigurableRuleCriteria";
 import { AddGoogleSecOpsDiagnostics1792300000000 } from "./1792300000000-AddGoogleSecOpsDiagnostics";
+import { AddIncomingCallPolicyPhoneNumbers1792600000000 } from "./1792600000000-AddIncomingCallPolicyPhoneNumbers";
+import { AddSloBurnRateRuleIncidents1792400000000 } from "./1792400000000-AddSloBurnRateRuleIncidents";
 import { AddUserWebAuthnPurpose1792200000000 } from "./1792200000000-AddUserWebAuthnPurpose";
 import InitialMigration from "./1717605043663-InitialMigration";
 import { MigrationName1717678334852 } from "./1717678334852-MigrationName";
@@ -1172,4 +1175,7 @@ export default [
   AddGitHubCommandSettingsToCodeRepository1792100000000,
   AddUserWebAuthnPurpose1792200000000,
   AddGoogleSecOpsDiagnostics1792300000000,
+  AddSloBurnRateRuleIncidents1792400000000,
+  AddConfigurableRuleCriteria1792500000000,
+  AddIncomingCallPolicyPhoneNumbers1792600000000,
 ];

package/Server/Middleware/MultipartFormData.ts

@@ -31,29 +31,48 @@ export const MAX_MULTIPART_FIELD_BYTES: number = 25 * 1024 * 1024;
 export const MAX_MULTIPART_FILES: number = 50;
 export const MAX_MULTIPART_FIELDS: number = 200;
 
+/*
+ * Every multipart protocol that uses this shared pre-auth parser has flat
+ * field names. Multer 2.3 provides these opt-in guards for append-field:
+ * without them, one deeply nested name or a maximum-length numeric array
+ * index can consume CPU and memory before authentication. Zero is the minimum
+ * each protocol needs and rejects bracket notation before append-field expands it.
+ * The array-index limit is defense in depth if a future protocol deliberately
+ * raises the nesting depth to accept one bracket group.
+ */
+export const MAX_MULTIPART_FIELD_NESTING_DEPTH: number = 0;
+export const MAX_MULTIPART_FIELD_ARRAY_INDEX: number = 0;
+
 /*
  * busboy's SIZE limits and its `parts` counter are EXCLUSIVE: each fires
  * the moment the counter REACHES the limit, so handing it N admits only
  * N-1. Its `files` and `fields` counters are INCLUSIVE -- N admits N.
  *
- * That asymmetry is undocumented and easy to lose, so the constants above
- * stay the INCLUSIVE maxima this app documents and that callers
- * range-check against (`file.buffer.length > MAX_SOURCE_MAP_SIZE_IN_BYTES`
- * and friends), and only the three exclusive limits are converted here.
+ * Multer 2.3 normalizes its documented `fileSize` option to an inclusive
+ * application limit before it calls busboy. It forwards `fieldSize` and
+ * `parts` unchanged, so only those two raw busboy limits are converted here.
+ * The constants above stay the INCLUSIVE maxima this app documents and that
+ * callers range-check against (`file.buffer.length >
+ * MAX_SOURCE_MAP_SIZE_IN_BYTES` and friends).
  *
- * Both halves of this were live bugs. A file of exactly 50 MiB -- a size
- * the source map endpoint means to accept, and whose 400 message says it
- * accepts -- was truncated by the parser into a 413 the endpoint never
- * saw. And `parts`, whose whole job is to allow the file and field
- * allowances in full, rejected a body carrying exactly both with
+ * Both conversions have caused live boundary bugs. A file of exactly 50 MiB
+ * must remain accepted, but adding one here as well as in Multer would admit
+ * 50 MiB + 1. And `parts`, whose whole job is to allow the file and field
+ * allowances in full, once rejected a body carrying exactly both with
  * LIMIT_PART_COUNT.
  */
-const exclusive: (inclusiveMax: number) => number = (
+const toExclusiveBusboyLimit: (inclusiveMax: number) => number = (
   inclusiveMax: number,
 ): number => {
   return inclusiveMax + 1;
 };
 
+/* Installed DefinitelyTyped definitions do not declare these options yet. */
+type HardenedMulterLimits = NonNullable<multer.Options["limits"]> & {
+  fieldNestingDepth: number;
+  fieldArrayIndexLimit: number;
+};
+
 /*
  * Configure multer for handling multipart/form-data
  * Uses memory storage to store files in memory as Buffer objects
@@ -61,19 +80,23 @@ const exclusive: (inclusiveMax: number) => number = (
 const buildUploadAny: (maxFiles: number) => RequestHandler = (
   maxFiles: number,
 ): RequestHandler => {
+  const limits: HardenedMulterLimits = {
+    fileSize: MAX_MULTIPART_FILE_BYTES,
+    fieldSize: toExclusiveBusboyLimit(MAX_MULTIPART_FIELD_BYTES),
+    files: maxFiles,
+    fields: MAX_MULTIPART_FIELDS,
+    fieldNestingDepth: MAX_MULTIPART_FIELD_NESTING_DEPTH,
+    fieldArrayIndexLimit: MAX_MULTIPART_FIELD_ARRAY_INDEX,
+    /*
+     * Parts are files + fields, so this has to allow both in full or it
+     * would be the effective limit and the two above would never fire.
+     */
+    parts: toExclusiveBusboyLimit(maxFiles + MAX_MULTIPART_FIELDS),
+  };
+
   const upload: multer.Multer = multer({
     storage: multer.memoryStorage(),
-    limits: {
-      fileSize: exclusive(MAX_MULTIPART_FILE_BYTES),
-      fieldSize: exclusive(MAX_MULTIPART_FIELD_BYTES),
-      files: maxFiles,
-      fields: MAX_MULTIPART_FIELDS,
-      /*
-       * Parts are files + fields, so this has to allow both in full or it
-       * would be the effective limit and the two above would never fire.
-       */
-      parts: exclusive(maxFiles + MAX_MULTIPART_FIELDS),
-    },
+    limits: limits,
   });
 
   return upload.any() as unknown as RequestHandler;
@@ -95,6 +118,8 @@ const TOO_LARGE_CODES: Set<string> = new Set<string>([
   "LIMIT_FIELD_KEY",
   "LIMIT_FIELD_VALUE",
   "LIMIT_FIELD_COUNT",
+  "LIMIT_FIELD_NESTING",
+  "LIMIT_FIELD_ARRAY_INDEX",
 ]);
 
 /*

package/Server/Services/AlertEpisodeLabelRuleEngineService.ts

@@ -15,6 +15,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertEpisodeLabelRuleEngineServiceClass {
   /**
@@ -40,6 +41,7 @@ class AlertEpisodeLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             alertSeverities: { _id: true },
             episodeLabels: { _id: true },
             episodeTitlePattern: true,
@@ -224,6 +226,25 @@ class AlertEpisodeLabelRuleEngineServiceClass {
   private doesEpisodeMatchRule(
     episode: AlertEpisode,
     rule: AlertEpisodeLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "alertSeverities",
+        "episodeLabels",
+        "episodeTitlePattern",
+        "episodeDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: AlertEpisodeLabelRule): boolean => {
+        return this.doesEpisodeMatchLegacyRule(episode, legacyRule);
+      },
+    });
+  }
+
+  private doesEpisodeMatchLegacyRule(
+    episode: AlertEpisode,
+    rule: AlertEpisodeLabelRule,
   ): boolean {
     if (rule.alertSeverities && rule.alertSeverities.length > 0) {
       if (!episode.alertSeverityId) {

package/Server/Services/AlertEpisodeOnCallRuleEngineService.ts

@@ -16,6 +16,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertEpisodeOnCallRuleEngineServiceClass {
   /**
@@ -40,6 +41,7 @@ class AlertEpisodeOnCallRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             alertSeverities: { _id: true },
             episodeLabels: { _id: true },
             episodeTitlePattern: true,
@@ -241,6 +243,25 @@ class AlertEpisodeOnCallRuleEngineServiceClass {
   private doesEpisodeMatchRule(
     episode: AlertEpisode,
     rule: AlertEpisodeOnCallRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "alertSeverities",
+        "episodeLabels",
+        "episodeTitlePattern",
+        "episodeDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: AlertEpisodeOnCallRule): boolean => {
+        return this.doesEpisodeMatchLegacyRule(episode, legacyRule);
+      },
+    });
+  }
+
+  private doesEpisodeMatchLegacyRule(
+    episode: AlertEpisode,
+    rule: AlertEpisodeOnCallRule,
   ): boolean {
     if (rule.alertSeverities && rule.alertSeverities.length > 0) {
       if (!episode.alertSeverityId) {

package/Server/Services/AlertEpisodeOwnerRuleEngineService.ts

@@ -18,6 +18,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertEpisodeOwnerRuleEngineServiceClass {
   /**
@@ -42,6 +43,7 @@ class AlertEpisodeOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             alertSeverities: { _id: true },
             episodeLabels: { _id: true },
@@ -256,6 +258,25 @@ class AlertEpisodeOwnerRuleEngineServiceClass {
   private doesEpisodeMatchRule(
     episode: AlertEpisode,
     rule: AlertEpisodeOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "alertSeverities",
+        "episodeLabels",
+        "episodeTitlePattern",
+        "episodeDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: AlertEpisodeOwnerRule): boolean => {
+        return this.doesEpisodeMatchLegacyRule(episode, legacyRule);
+      },
+    });
+  }
+
+  private doesEpisodeMatchLegacyRule(
+    episode: AlertEpisode,
+    rule: AlertEpisodeOwnerRule,
   ): boolean {
     if (rule.alertSeverities && rule.alertSeverities.length > 0) {
       if (!episode.alertSeverityId) {

package/Server/Services/AlertEpisodePrivacyRuleEngineService.ts

@@ -11,6 +11,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertEpisodePrivacyRuleEngineServiceClass {
   /**
@@ -38,6 +39,7 @@ class AlertEpisodePrivacyRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             alertSeverities: { _id: true },
             episodeLabels: { _id: true },
             episodeTitlePattern: true,
@@ -149,6 +151,25 @@ class AlertEpisodePrivacyRuleEngineServiceClass {
   private doesEpisodeMatchRule(
     episode: AlertEpisode,
     rule: AlertEpisodePrivacyRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "alertSeverities",
+        "episodeLabels",
+        "episodeTitlePattern",
+        "episodeDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: AlertEpisodePrivacyRule): boolean => {
+        return this.doesEpisodeMatchLegacyRule(episode, legacyRule);
+      },
+    });
+  }
+
+  private doesEpisodeMatchLegacyRule(
+    episode: AlertEpisode,
+    rule: AlertEpisodePrivacyRule,
   ): boolean {
     if (rule.alertSeverities && rule.alertSeverities.length > 0) {
       if (!episode.alertSeverityId) {

package/Server/Services/AlertGroupingEngineService.ts

@@ -28,6 +28,7 @@ import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpis
 import { Green500 } from "../../Types/BrandColors";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 export interface GroupingResult {
   grouped: boolean;
@@ -73,6 +74,7 @@ class AlertGroupingEngineServiceClass {
             _id: true,
             name: true,
             priority: true,
+            criteria: true,
             // Match criteria fields
             monitors: {
               _id: true,
@@ -181,6 +183,31 @@ class AlertGroupingEngineServiceClass {
   private async doesAlertMatchRule(
     alert: Alert,
     rule: AlertGroupingRule,
+  ): Promise<boolean> {
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "alertLabels",
+        "monitorLabels",
+        "alertTitlePattern",
+        "alertDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AlertGroupingRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(alert, legacyRule);
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AlertGroupingRule,
   ): Promise<boolean> {
     logger.debug(
       `Checking if alert ${alert.id} matches rule ${rule.name || rule.id}`,

package/Server/Services/AlertLabelRuleEngineService.ts

@@ -27,6 +27,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertLabelRuleEngineServiceClass {
   /**
@@ -58,6 +59,7 @@ class AlertLabelRuleEngineServiceClass {
         select: {
           _id: true,
           name: true,
+          criteria: true,
           monitors: { _id: true },
           alertSeverities: { _id: true },
           alertLabels: { _id: true },
@@ -424,6 +426,31 @@ class AlertLabelRuleEngineServiceClass {
   private async doesAlertMatchRule(
     alert: Alert,
     rule: AlertLabelRule,
+  ): Promise<boolean> {
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "alertLabels",
+        "monitorLabels",
+        "alertTitlePattern",
+        "alertDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AlertLabelRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(alert, legacyRule);
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AlertLabelRule,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (!alert.monitorId) {

package/Server/Services/AlertOnCallRuleEngineService.ts

@@ -18,6 +18,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertOnCallRuleEngineServiceClass {
   /**
@@ -43,6 +44,7 @@ class AlertOnCallRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             monitors: { _id: true },
             alertSeverities: { _id: true },
             alertLabels: { _id: true },
@@ -262,6 +264,31 @@ class AlertOnCallRuleEngineServiceClass {
   private async doesAlertMatchRule(
     alert: Alert,
     rule: AlertOnCallRule,
+  ): Promise<boolean> {
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "alertLabels",
+        "monitorLabels",
+        "alertTitlePattern",
+        "alertDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AlertOnCallRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(alert, legacyRule);
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AlertOnCallRule,
   ): Promise<boolean> {
     // Monitors: alert must come from one of the rule's monitors
     if (rule.monitors && rule.monitors.length > 0) {

package/Server/Services/AlertOwnerRuleEngineService.ts

@@ -49,6 +49,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertOwnerRuleEngineServiceClass {
   /**
@@ -71,6 +72,7 @@ class AlertOwnerRuleEngineServiceClass {
         select: {
           _id: true,
           name: true,
+          criteria: true,
           notifyOwners: true,
           monitors: { _id: true },
           alertSeverities: { _id: true },
@@ -688,6 +690,31 @@ class AlertOwnerRuleEngineServiceClass {
   private async doesAlertMatchRule(
     alert: Alert,
     rule: AlertOwnerRule,
+  ): Promise<boolean> {
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "alertLabels",
+        "monitorLabels",
+        "alertTitlePattern",
+        "alertDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AlertOwnerRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(alert, legacyRule);
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AlertOwnerRule,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (!alert.monitorId) {

package/Server/Services/AlertPrivacyRuleEngineService.ts

@@ -13,6 +13,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 
 class AlertPrivacyRuleEngineServiceClass {
   /**
@@ -44,6 +45,7 @@ class AlertPrivacyRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             monitors: { _id: true },
             alertSeverities: { _id: true },
             alertLabels: { _id: true },
@@ -160,6 +162,31 @@ class AlertPrivacyRuleEngineServiceClass {
   private async doesAlertMatchRule(
     alert: Alert,
     rule: AlertPrivacyRule,
+  ): Promise<boolean> {
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "alertLabels",
+        "monitorLabels",
+        "alertTitlePattern",
+        "alertDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AlertPrivacyRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(alert, legacyRule);
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AlertPrivacyRule,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (!alert.monitorId) {