@oneuptime/common 13.0.1 → 13.0.3

package/Server/Services/OnCallDutyPolicyLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class OnCallDutyPolicyLabelRuleEngineServiceClass {
@@ -29,6 +30,7 @@ class OnCallDutyPolicyLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             onCallDutyPolicyLabels: { _id: true },
             onCallDutyPolicyNamePattern: true,
             onCallDutyPolicyDescriptionPattern: true,
@@ -134,6 +136,24 @@ class OnCallDutyPolicyLabelRuleEngineServiceClass {
   private doesPolicyMatchRule(
     policy: OnCallDutyPolicy,
     rule: OnCallDutyPolicyLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "onCallDutyPolicyLabels",
+        "onCallDutyPolicyNamePattern",
+        "onCallDutyPolicyDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (policyRule: OnCallDutyPolicyLabelRule): boolean => {
+        return this.doesPolicyMatchRuleLegacy(policy, policyRule);
+      },
+    });
+  }
+
+  private doesPolicyMatchRuleLegacy(
+    policy: OnCallDutyPolicy,
+    rule: OnCallDutyPolicyLabelRule,
   ): boolean {
     if (rule.onCallDutyPolicyLabels && rule.onCallDutyPolicyLabels.length > 0) {
       if (!policy.labels || policy.labels.length === 0) {

package/Server/Services/OnCallDutyPolicyOwnerRuleEngineService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class OnCallDutyPolicyOwnerRuleEngineServiceClass {
@@ -33,6 +34,7 @@ class OnCallDutyPolicyOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             onCallDutyPolicyLabels: { _id: true },
             onCallDutyPolicyNamePattern: true,
@@ -157,6 +159,24 @@ class OnCallDutyPolicyOwnerRuleEngineServiceClass {
   private doesPolicyMatchRule(
     policy: OnCallDutyPolicy,
     rule: OnCallDutyPolicyOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "onCallDutyPolicyLabels",
+        "onCallDutyPolicyNamePattern",
+        "onCallDutyPolicyDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (policyRule: OnCallDutyPolicyOwnerRule): boolean => {
+        return this.doesPolicyMatchRuleLegacy(policy, policyRule);
+      },
+    });
+  }
+
+  private doesPolicyMatchRuleLegacy(
+    policy: OnCallDutyPolicy,
+    rule: OnCallDutyPolicyOwnerRule,
   ): boolean {
     if (rule.onCallDutyPolicyLabels && rule.onCallDutyPolicyLabels.length > 0) {
       if (!policy.labels || policy.labels.length === 0) {

package/Server/Services/OnCallDutyPolicyScheduleLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class OnCallDutyPolicyScheduleLabelRuleEngineServiceClass {
@@ -29,6 +30,7 @@ class OnCallDutyPolicyScheduleLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             onCallDutyPolicyScheduleLabels: { _id: true },
             onCallDutyPolicyScheduleNamePattern: true,
             onCallDutyPolicyScheduleDescriptionPattern: true,
@@ -137,6 +139,26 @@ class OnCallDutyPolicyScheduleLabelRuleEngineServiceClass {
   private doesScheduleMatchRule(
     schedule: OnCallDutyPolicySchedule,
     rule: OnCallDutyPolicyScheduleLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "onCallDutyPolicyScheduleLabels",
+        "onCallDutyPolicyScheduleNamePattern",
+        "onCallDutyPolicyScheduleDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        scheduleRule: OnCallDutyPolicyScheduleLabelRule,
+      ): boolean => {
+        return this.doesScheduleMatchRuleLegacy(schedule, scheduleRule);
+      },
+    });
+  }
+
+  private doesScheduleMatchRuleLegacy(
+    schedule: OnCallDutyPolicySchedule,
+    rule: OnCallDutyPolicyScheduleLabelRule,
   ): boolean {
     if (
       rule.onCallDutyPolicyScheduleLabels &&

package/Server/Services/OnCallDutyPolicyScheduleOwnerRuleEngineService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class OnCallDutyPolicyScheduleOwnerRuleEngineServiceClass {
@@ -33,6 +34,7 @@ class OnCallDutyPolicyScheduleOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             onCallDutyPolicyScheduleLabels: { _id: true },
             onCallDutyPolicyScheduleNamePattern: true,
@@ -160,6 +162,26 @@ class OnCallDutyPolicyScheduleOwnerRuleEngineServiceClass {
   private doesScheduleMatchRule(
     schedule: OnCallDutyPolicySchedule,
     rule: OnCallDutyPolicyScheduleOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "onCallDutyPolicyScheduleLabels",
+        "onCallDutyPolicyScheduleNamePattern",
+        "onCallDutyPolicyScheduleDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        scheduleRule: OnCallDutyPolicyScheduleOwnerRule,
+      ): boolean => {
+        return this.doesScheduleMatchRuleLegacy(schedule, scheduleRule);
+      },
+    });
+  }
+
+  private doesScheduleMatchRuleLegacy(
+    schedule: OnCallDutyPolicySchedule,
+    rule: OnCallDutyPolicyScheduleOwnerRule,
   ): boolean {
     if (
       rule.onCallDutyPolicyScheduleLabels &&

package/Server/Services/PodmanHostLabelRuleEngineService.ts

@@ -10,6 +10,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class PodmanHostLabelRuleEngineServiceClass {
@@ -35,6 +36,7 @@ class PodmanHostLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             podmanHostLabels: { _id: true },
             podmanHostNamePattern: true,
             podmanHostDescriptionPattern: true,
@@ -170,6 +172,24 @@ class PodmanHostLabelRuleEngineServiceClass {
   private doesPodmanHostMatchRule(
     podmanHost: PodmanHost,
     rule: PodmanHostLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "podmanHostLabels",
+        "podmanHostNamePattern",
+        "podmanHostDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (podmanHostRule: PodmanHostLabelRule): boolean => {
+        return this.doesPodmanHostMatchRuleLegacy(podmanHost, podmanHostRule);
+      },
+    });
+  }
+
+  private doesPodmanHostMatchRuleLegacy(
+    podmanHost: PodmanHost,
+    rule: PodmanHostLabelRule,
   ): boolean {
     if (rule.podmanHostLabels && rule.podmanHostLabels.length > 0) {
       if (!podmanHost.labels || podmanHost.labels.length === 0) {

package/Server/Services/PodmanHostOwnerRuleEngineService.ts

@@ -14,6 +14,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class PodmanHostOwnerRuleEngineServiceClass {
@@ -40,6 +41,7 @@ class PodmanHostOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             podmanHostLabels: { _id: true },
             podmanHostNamePattern: true,
@@ -182,6 +184,24 @@ class PodmanHostOwnerRuleEngineServiceClass {
   private doesPodmanHostMatchRule(
     podmanHost: PodmanHost,
     rule: PodmanHostOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "podmanHostLabels",
+        "podmanHostNamePattern",
+        "podmanHostDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (podmanHostRule: PodmanHostOwnerRule): boolean => {
+        return this.doesPodmanHostMatchRuleLegacy(podmanHost, podmanHostRule);
+      },
+    });
+  }
+
+  private doesPodmanHostMatchRuleLegacy(
+    podmanHost: PodmanHost,
+    rule: PodmanHostOwnerRule,
   ): boolean {
     if (rule.podmanHostLabels && rule.podmanHostLabels.length > 0) {
       if (!podmanHost.labels || podmanHost.labels.length === 0) {

package/Server/Services/ProjectCallSMSConfigService.ts

@@ -14,6 +14,9 @@ import IncomingCallPolicyService from "./IncomingCallPolicyService";
 import IncomingCallPolicy from "../../Models/DatabaseModels/IncomingCallPolicy";
 import releaseIncomingCallPhoneNumber from "../Utils/IncomingCallPhoneNumber";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import IncomingCallPolicyPhoneNumberService from "./IncomingCallPolicyPhoneNumberService";
+import IncomingCallPolicyPhoneNumber from "../../Models/DatabaseModels/IncomingCallPolicyPhoneNumber";
+import ModelPermission from "../Types/Database/Permissions/Index";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -100,6 +103,17 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,
   ): Promise<OnDelete<Model>> {
+    /*
+     * This hook releases provider resources before DatabaseService reaches its
+     * usual delete permission check. Scope the query first so a denied config
+     * delete cannot release or clear another tenant's phone numbers.
+     */
+    deleteBy.query = await ModelPermission.checkDeleteQueryPermission(
+      Model,
+      deleteBy.query,
+      deleteBy.props,
+    );
+
     /*
      * When a Call/SMS config is deleted, release any incoming-call numbers
      * provisioned through it (so they don't keep billing on the provider) and
@@ -111,20 +125,59 @@ export class Service extends DatabaseService<Model> {
       select: {
         _id: true,
       },
-      limit: LIMIT_MAX,
-      skip: 0,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
       props: {
         isRoot: true,
       },
     });
 
+    const configIds: Array<ObjectID> = configs
+      .map((config: Model): ObjectID | null => {
+        return config.id;
+      })
+      .filter((configId: ObjectID | null): configId is ObjectID => {
+        return Boolean(configId);
+      });
+
+    /*
+     * Freeze the caller's offset/limit window before provider side effects.
+     * The original window could otherwise select different rows when
+     * DatabaseService evaluates it again after the releases complete.
+     */
+    deleteBy.query = {
+      _id: QueryHelper.any(configIds),
+    };
+    deleteBy.skip = 0;
+    deleteBy.limit = configIds.length;
+
     for (const config of configs) {
       if (!config.id) {
         continue;
       }
 
+      const phoneNumbers: Array<IncomingCallPolicyPhoneNumber> =
+        await IncomingCallPolicyPhoneNumberService.findAllBy({
+          query: {
+            projectCallSMSConfigId: config.id,
+          },
+          select: {
+            _id: true,
+            callProviderPhoneNumberId: true,
+            projectCallSMSConfigId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      /*
+       * Snapshot scalar-only attachments before deleting child rows. The child
+       * delete hook updates the compatibility mirror and can otherwise erase
+       * an unmatched legacy SID before it is released from the provider.
+       */
       const policies: Array<IncomingCallPolicy> =
-        await IncomingCallPolicyService.findBy({
+        await IncomingCallPolicyService.findAllBy({
           query: {
             projectCallSMSConfigId: config.id,
           },
@@ -133,17 +186,44 @@ export class Service extends DatabaseService<Model> {
             callProviderPhoneNumberId: true,
             projectCallSMSConfigId: true,
           },
-          limit: LIMIT_MAX,
-          skip: 0,
           props: {
             isRoot: true,
           },
         });
 
+      const releasedProviderPhoneNumberIds: Set<string> = new Set();
+
+      for (const phoneNumber of phoneNumbers) {
+        if (
+          !phoneNumber.callProviderPhoneNumberId ||
+          !phoneNumber.projectCallSMSConfigId
+        ) {
+          continue;
+        }
+
+        if (
+          releasedProviderPhoneNumberIds.has(
+            phoneNumber.callProviderPhoneNumberId,
+          )
+        ) {
+          continue;
+        }
+
+        await releaseIncomingCallPhoneNumber({
+          projectCallSMSConfigId: phoneNumber.projectCallSMSConfigId,
+          callProviderPhoneNumberId: phoneNumber.callProviderPhoneNumberId,
+        });
+
+        releasedProviderPhoneNumberIds.add(
+          phoneNumber.callProviderPhoneNumberId,
+        );
+      }
+
       for (const policy of policies) {
         if (
           !policy.callProviderPhoneNumberId ||
-          !policy.projectCallSMSConfigId
+          !policy.projectCallSMSConfigId ||
+          releasedProviderPhoneNumberIds.has(policy.callProviderPhoneNumberId)
         ) {
           continue;
         }
@@ -153,8 +233,77 @@ export class Service extends DatabaseService<Model> {
           callProviderPhoneNumberId: policy.callProviderPhoneNumberId,
         });
 
+        releasedProviderPhoneNumberIds.add(policy.callProviderPhoneNumberId);
+      }
+
+      /*
+       * Delete through the child service before the config itself is removed.
+       * Its hooks re-select the oldest remaining number for each affected
+       * policy and update the legacy compatibility fields accordingly.
+       */
+      const phoneNumberIds: Array<ObjectID> = phoneNumbers
+        .map((phoneNumber: IncomingCallPolicyPhoneNumber): ObjectID | null => {
+          return phoneNumber.id;
+        })
+        .filter((phoneNumberId: ObjectID | null): phoneNumberId is ObjectID => {
+          return Boolean(phoneNumberId);
+        });
+
+      /*
+       * deleteBy is intentionally bounded, so delete the exact snapshotted
+       * child ids in batches. This covers configs with more than LIMIT_MAX
+       * attached numbers and keeps the explicit cleanup bound to the rows
+       * whose provider resources were released above.
+       */
+      for (
+        let offset: number = 0;
+        offset < phoneNumberIds.length;
+        offset += LIMIT_MAX
+      ) {
+        const phoneNumberIdBatch: Array<ObjectID> = phoneNumberIds.slice(
+          offset,
+          offset + LIMIT_MAX,
+        );
+
+        await IncomingCallPolicyPhoneNumberService.deleteBy({
+          query: {
+            _id: QueryHelper.any(phoneNumberIdBatch),
+          },
+          limit: phoneNumberIdBatch.length,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+
+      for (const policy of policies) {
+        if (!policy.id) {
+          continue;
+        }
+
+        const remainingPhoneNumber: IncomingCallPolicyPhoneNumber | null =
+          await IncomingCallPolicyPhoneNumberService.findOneBy({
+            query: {
+              incomingCallPolicyId: policy.id,
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (remainingPhoneNumber) {
+          await IncomingCallPolicyPhoneNumberService.syncPrimaryPhoneNumberToPolicy(
+            policy.id,
+          );
+          continue;
+        }
+
         await IncomingCallPolicyService.updateOneById({
-          id: policy.id!,
+          id: policy.id,
           data: {
             routingPhoneNumber: null,
             callProviderPhoneNumberId: null,

package/Server/Services/ProxmoxClusterLabelRuleEngineService.ts

@@ -10,6 +10,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class ProxmoxClusterLabelRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class ProxmoxClusterLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             proxmoxClusterLabels: { _id: true },
             proxmoxClusterNamePattern: true,
             proxmoxClusterDescriptionPattern: true,
@@ -173,6 +175,29 @@ class ProxmoxClusterLabelRuleEngineServiceClass {
   private doesProxmoxClusterMatchRule(
     proxmoxCluster: ProxmoxCluster,
     rule: ProxmoxClusterLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "proxmoxClusterLabels",
+        "proxmoxClusterNamePattern",
+        "proxmoxClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        proxmoxClusterRule: ProxmoxClusterLabelRule,
+      ): boolean => {
+        return this.doesProxmoxClusterMatchRuleLegacy(
+          proxmoxCluster,
+          proxmoxClusterRule,
+        );
+      },
+    });
+  }
+
+  private doesProxmoxClusterMatchRuleLegacy(
+    proxmoxCluster: ProxmoxCluster,
+    rule: ProxmoxClusterLabelRule,
   ): boolean {
     if (rule.proxmoxClusterLabels && rule.proxmoxClusterLabels.length > 0) {
       if (!proxmoxCluster.labels || proxmoxCluster.labels.length === 0) {

package/Server/Services/ProxmoxClusterOwnerRuleEngineService.ts

@@ -14,6 +14,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class ProxmoxClusterOwnerRuleEngineServiceClass {
@@ -42,6 +43,7 @@ class ProxmoxClusterOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             proxmoxClusterLabels: { _id: true },
             proxmoxClusterNamePattern: true,
@@ -185,6 +187,29 @@ class ProxmoxClusterOwnerRuleEngineServiceClass {
   private doesProxmoxClusterMatchRule(
     proxmoxCluster: ProxmoxCluster,
     rule: ProxmoxClusterOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "proxmoxClusterLabels",
+        "proxmoxClusterNamePattern",
+        "proxmoxClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        proxmoxClusterRule: ProxmoxClusterOwnerRule,
+      ): boolean => {
+        return this.doesProxmoxClusterMatchRuleLegacy(
+          proxmoxCluster,
+          proxmoxClusterRule,
+        );
+      },
+    });
+  }
+
+  private doesProxmoxClusterMatchRuleLegacy(
+    proxmoxCluster: ProxmoxCluster,
+    rule: ProxmoxClusterOwnerRule,
   ): boolean {
     if (rule.proxmoxClusterLabels && rule.proxmoxClusterLabels.length > 0) {
       if (!proxmoxCluster.labels || proxmoxCluster.labels.length === 0) {

package/Server/Services/RumApplicationLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RumApplicationLabelRuleEngineServiceClass {
@@ -34,6 +35,7 @@ class RumApplicationLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
             descriptionRegexPattern: true,
@@ -130,6 +132,26 @@ class RumApplicationLabelRuleEngineServiceClass {
   private doesMatchRule(
     rumApplication: RumApplication,
     rule: RumApplicationLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        rumApplicationRule: RumApplicationLabelRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(rumApplication, rumApplicationRule);
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    rumApplication: RumApplication,
+    rule: RumApplicationLabelRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!rumApplication.labels || rumApplication.labels.length === 0) {

package/Server/Services/RumApplicationOwnerRuleEngineService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RumApplicationOwnerRuleEngineServiceClass {
@@ -38,6 +39,7 @@ class RumApplicationOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
@@ -147,6 +149,26 @@ class RumApplicationOwnerRuleEngineServiceClass {
   private doesMatchRule(
     rumApplication: RumApplication,
     rule: RumApplicationOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        rumApplicationRule: RumApplicationOwnerRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(rumApplication, rumApplicationRule);
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    rumApplication: RumApplication,
+    rule: RumApplicationOwnerRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!rumApplication.labels || rumApplication.labels.length === 0) {

package/Server/Services/RunbookLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RunbookLabelRuleEngineServiceClass {
@@ -32,6 +33,7 @@ class RunbookLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             runbookLabels: { _id: true },
             runbookNamePattern: true,
             runbookDescriptionPattern: true,
@@ -141,6 +143,24 @@ class RunbookLabelRuleEngineServiceClass {
   private doesRunbookMatchRule(
     runbook: Runbook,
     rule: RunbookLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "runbookLabels",
+        "runbookNamePattern",
+        "runbookDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (runbookRule: RunbookLabelRule): boolean => {
+        return this.doesRunbookMatchRuleLegacy(runbook, runbookRule);
+      },
+    });
+  }
+
+  private doesRunbookMatchRuleLegacy(
+    runbook: Runbook,
+    rule: RunbookLabelRule,
   ): boolean {
     if (rule.runbookLabels && rule.runbookLabels.length > 0) {
       if (!runbook.labels || runbook.labels.length === 0) {