@oneuptime/common 13.0.1 → 13.0.4

package/Server/Services/RunbookOwnerRuleEngineService.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 RunbookOwnerRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class RunbookOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             runbookLabels: { _id: true },
             runbookNamePattern: true,
@@ -159,6 +161,24 @@ class RunbookOwnerRuleEngineServiceClass {
   private doesRunbookMatchRule(
     runbook: Runbook,
     rule: RunbookOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "runbookLabels",
+        "runbookNamePattern",
+        "runbookDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (runbookRule: RunbookOwnerRule): boolean => {
+        return this.doesRunbookMatchRuleLegacy(runbook, runbookRule);
+      },
+    });
+  }
+
+  private doesRunbookMatchRuleLegacy(
+    runbook: Runbook,
+    rule: RunbookOwnerRule,
   ): boolean {
     if (rule.runbookLabels && rule.runbookLabels.length > 0) {
       if (!runbook.labels || runbook.labels.length === 0) {

package/Server/Services/RunbookRuleEngineService.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";
 
 type EnqueueExecutionFn = (data: {
   runbookExecutionId: ObjectID;
@@ -98,6 +99,7 @@ class RunbookRuleEngineServiceClass {
         select: {
           _id: true,
           name: true,
+          criteria: true,
           titlePattern: true,
           descriptionPattern: true,
           runbooks: { _id: true },
@@ -168,7 +170,22 @@ class RunbookRuleEngineServiceClass {
     }
   }
 
-  private matches(
+  public matches(
+    rule: RunbookRule,
+    title: string | undefined,
+    description: string | undefined,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: ["titlePattern", "descriptionPattern"],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: RunbookRule): boolean => {
+        return this.matchesLegacy(legacyRule, title, description);
+      },
+    });
+  }
+
+  private matchesLegacy(
     rule: RunbookRule,
     title: string | undefined,
     description: string | undefined,

package/Server/Services/ScheduledMaintenanceLabelRuleEngineService.ts

@@ -26,6 +26,8 @@ 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";
+import MonitorRuleCriteriaCache from "../Utils/Rules/MonitorRuleCriteriaCache";
 
 class ScheduledMaintenanceLabelRuleEngineServiceClass {
   /**
@@ -60,6 +62,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             monitors: { _id: true },
             scheduledMaintenanceLabels: { _id: true },
             monitorLabels: { _id: true },
@@ -438,9 +441,64 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
   }
 
   @CaptureSpan()
-  private async doesScheduledMaintenanceMatchRule(
+  public async doesScheduledMaintenanceMatchRule(
     scheduledMaintenance: ScheduledMaintenance,
     rule: ScheduledMaintenanceLabelRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule: rule,
+      legacyFields: [
+        "monitors",
+        "scheduledMaintenanceLabels",
+        "monitorLabels",
+        "titlePattern",
+        "descriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: ScheduledMaintenanceLabelRule,
+      ): Promise<boolean> => {
+        return await this.doesScheduledMaintenanceMatchLegacyRule(
+          scheduledMaintenance,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: [
+          "monitorLabels",
+          "monitorNamePattern",
+          "monitorDescriptionPattern",
+        ],
+        getCandidates: (): Array<Monitor> => {
+          return scheduledMaintenance.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: ScheduledMaintenanceLabelRule,
+          eventMonitor: Monitor,
+        ): Promise<boolean> => {
+          const correlatedScheduledMaintenance: ScheduledMaintenance =
+            Object.assign(new ScheduledMaintenance(), scheduledMaintenance);
+          correlatedScheduledMaintenance.monitors = [eventMonitor];
+          return await this.doesScheduledMaintenanceMatchLegacyRule(
+            correlatedScheduledMaintenance,
+            legacyRule,
+            monitorCache,
+          );
+        },
+      },
+    });
+  }
+
+  private async doesScheduledMaintenanceMatchLegacyRule(
+    scheduledMaintenance: ScheduledMaintenance,
+    rule: ScheduledMaintenanceLabelRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (
@@ -514,15 +572,9 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         if (!eventMonitor.id) {
           continue;
         }
-        const monitor: Monitor | null = await MonitorService.findOneById({
-          id: eventMonitor.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+        const monitor: Monitor | null = await monitorCache.getMonitor(
+          eventMonitor.id,
+        );
         if (!monitor) {
           continue;
         }

package/Server/Services/ScheduledMaintenanceOwnerRuleEngineService.ts

@@ -29,7 +29,6 @@ import KubernetesClusterOwnerTeamService from "./KubernetesClusterOwnerTeamServi
 import KubernetesClusterOwnerUserService from "./KubernetesClusterOwnerUserService";
 import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
 import MonitorOwnerUserService from "./MonitorOwnerUserService";
-import MonitorService from "./MonitorService";
 import PodmanHostOwnerTeamService from "./PodmanHostOwnerTeamService";
 import PodmanHostOwnerUserService from "./PodmanHostOwnerUserService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
@@ -48,6 +47,8 @@ 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";
+import MonitorRuleCriteriaCache from "../Utils/Rules/MonitorRuleCriteriaCache";
 
 class ScheduledMaintenanceOwnerRuleEngineServiceClass {
   /**
@@ -75,6 +76,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             monitors: { _id: true },
             scheduledMaintenanceLabels: { _id: true },
@@ -711,9 +713,64 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
   }
 
   @CaptureSpan()
-  private async doesScheduledMaintenanceMatchRule(
+  public async doesScheduledMaintenanceMatchRule(
     scheduledMaintenance: ScheduledMaintenance,
     rule: ScheduledMaintenanceOwnerRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule: rule,
+      legacyFields: [
+        "monitors",
+        "scheduledMaintenanceLabels",
+        "monitorLabels",
+        "titlePattern",
+        "descriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: ScheduledMaintenanceOwnerRule,
+      ): Promise<boolean> => {
+        return await this.doesScheduledMaintenanceMatchLegacyRule(
+          scheduledMaintenance,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: [
+          "monitorLabels",
+          "monitorNamePattern",
+          "monitorDescriptionPattern",
+        ],
+        getCandidates: (): Array<Monitor> => {
+          return scheduledMaintenance.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: ScheduledMaintenanceOwnerRule,
+          eventMonitor: Monitor,
+        ): Promise<boolean> => {
+          const correlatedScheduledMaintenance: ScheduledMaintenance =
+            Object.assign(new ScheduledMaintenance(), scheduledMaintenance);
+          correlatedScheduledMaintenance.monitors = [eventMonitor];
+          return await this.doesScheduledMaintenanceMatchLegacyRule(
+            correlatedScheduledMaintenance,
+            legacyRule,
+            monitorCache,
+          );
+        },
+      },
+    });
+  }
+
+  private async doesScheduledMaintenanceMatchLegacyRule(
+    scheduledMaintenance: ScheduledMaintenance,
+    rule: ScheduledMaintenanceOwnerRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (
@@ -787,15 +844,9 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
         if (!eventMonitor.id) {
           continue;
         }
-        const monitor: Monitor | null = await MonitorService.findOneById({
-          id: eventMonitor.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+        const monitor: Monitor | null = await monitorCache.getMonitor(
+          eventMonitor.id,
+        );
         if (!monitor) {
           continue;
         }

package/Server/Services/ScheduledMaintenanceReminderRuleService.ts

@@ -16,6 +16,7 @@ import logger, { LogAttributes } from "../Utils/Logger";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import RuleCriteriaMatcher from "../../Utils/Rules/RuleCriteriaMatcher";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -190,6 +191,7 @@ export class Service extends DatabaseService<Model> {
         reminderIntervalInMinutes: true,
         stopRemindersOnState: true,
         remindWhileScheduled: true,
+        criteria: true,
         labels: {
           _id: true,
         },
@@ -208,24 +210,8 @@ export class Service extends DatabaseService<Model> {
     });
 
     for (const rule of rules) {
-      if (rule.labels && rule.labels.length > 0) {
-        if (!data.labelIds || data.labelIds.length === 0) {
-          continue;
-        }
-
-        const ruleLabelIds: Array<string> = rule.labels.map((label: Label) => {
-          return label.id?.toString() || "";
-        });
-
-        const hasMatchingLabel: boolean = data.labelIds.some(
-          (labelId: ObjectID) => {
-            return ruleLabelIds.includes(labelId.toString());
-          },
-        );
-
-        if (!hasMatchingLabel) {
-          continue;
-        }
+      if (!this.doesScheduledMaintenanceMatchRule({ rule: rule, ...data })) {
+        continue;
       }
 
       // Rule with no labels matches all scheduled maintenances.
@@ -239,6 +225,50 @@ export class Service extends DatabaseService<Model> {
 
     return null;
   }
+
+  public doesScheduledMaintenanceMatchRule(data: {
+    rule: Model;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: data.rule,
+      legacyFields: ["labels"],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: Model): boolean => {
+        return this.doesScheduledMaintenanceMatchLegacyRule({
+          ...data,
+          rule: legacyRule,
+        });
+      },
+    });
+  }
+
+  private doesScheduledMaintenanceMatchLegacyRule(data: {
+    rule: Model;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    const rule: Model = data.rule;
+
+    if (rule.labels && rule.labels.length > 0) {
+      if (!data.labelIds || data.labelIds.length === 0) {
+        return false;
+      }
+
+      const ruleLabelIds: Array<string> = rule.labels.map((label: Label) => {
+        return label.id?.toString() || "";
+      });
+
+      if (
+        !data.labelIds.some((labelId: ObjectID): boolean => {
+          return ruleLabelIds.includes(labelId.toString());
+        })
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
 }
 
 export default new Service();

package/Server/Services/ServerlessFunctionLabelRuleEngineService.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 ServerlessFunctionLabelRuleEngineServiceClass {
@@ -34,6 +35,7 @@ class ServerlessFunctionLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
             descriptionRegexPattern: true,
@@ -132,6 +134,29 @@ class ServerlessFunctionLabelRuleEngineServiceClass {
   private doesMatchRule(
     serverlessFunction: ServerlessFunction,
     rule: ServerlessFunctionLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        serverlessFunctionRule: ServerlessFunctionLabelRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(
+          serverlessFunction,
+          serverlessFunctionRule,
+        );
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    serverlessFunction: ServerlessFunction,
+    rule: ServerlessFunctionLabelRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (

package/Server/Services/ServerlessFunctionOwnerRuleEngineService.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 ServerlessFunctionOwnerRuleEngineServiceClass {
@@ -38,6 +39,7 @@ class ServerlessFunctionOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
@@ -149,6 +151,29 @@ class ServerlessFunctionOwnerRuleEngineServiceClass {
   private doesMatchRule(
     serverlessFunction: ServerlessFunction,
     rule: ServerlessFunctionOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        serverlessFunctionRule: ServerlessFunctionOwnerRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(
+          serverlessFunction,
+          serverlessFunctionRule,
+        );
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    serverlessFunction: ServerlessFunction,
+    rule: ServerlessFunctionOwnerRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (

package/Server/Services/ServiceLabelRuleEngineService.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 ServiceLabelRuleEngineServiceClass {
@@ -35,6 +36,7 @@ class ServiceLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             serviceLabels: { _id: true },
             serviceNamePattern: true,
             serviceDescriptionPattern: true,
@@ -170,6 +172,24 @@ class ServiceLabelRuleEngineServiceClass {
   private doesServiceMatchRule(
     service: Service,
     rule: ServiceLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "serviceLabels",
+        "serviceNamePattern",
+        "serviceDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (serviceRule: ServiceLabelRule): boolean => {
+        return this.doesServiceMatchRuleLegacy(service, serviceRule);
+      },
+    });
+  }
+
+  private doesServiceMatchRuleLegacy(
+    service: Service,
+    rule: ServiceLabelRule,
   ): boolean {
     if (rule.serviceLabels && rule.serviceLabels.length > 0) {
       if (!service.labels || service.labels.length === 0) {