@oneuptime/common 13.0.1 → 13.0.4

package/Server/Services/IncidentOwnerRuleEngineService.ts

@@ -33,7 +33,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 ServiceOwnerTeamService from "./ServiceOwnerTeamService";
@@ -49,6 +48,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 IncidentOwnerRuleEngineServiceClass {
   /**
@@ -73,6 +74,7 @@ class IncidentOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             monitors: { _id: true },
             incidentSeverities: { _id: true },
@@ -706,6 +708,64 @@ class IncidentOwnerRuleEngineServiceClass {
   private async doesIncidentMatchRule(
     incident: Incident,
     rule: IncidentOwnerRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "incidentSeverities",
+        "incidentLabels",
+        "monitorLabels",
+        "incidentTitlePattern",
+        "incidentDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: IncidentOwnerRule,
+      ): Promise<boolean> => {
+        return await this.doesIncidentMatchLegacyRule(
+          incident,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: [
+          "monitorLabels",
+          "monitorNamePattern",
+          "monitorDescriptionPattern",
+        ],
+        getCandidates: (): Array<Monitor> => {
+          return incident.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: IncidentOwnerRule,
+          incidentMonitor: Monitor,
+        ): Promise<boolean> => {
+          const correlatedIncident: Incident = Object.assign(
+            new Incident(),
+            incident,
+          );
+          correlatedIncident.monitors = [incidentMonitor];
+          return await this.doesIncidentMatchLegacyRule(
+            correlatedIncident,
+            legacyRule,
+            monitorCache,
+          );
+        },
+      },
+    });
+  }
+
+  private async doesIncidentMatchLegacyRule(
+    incident: Incident,
+    rule: IncidentOwnerRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (!incident.monitors || incident.monitors.length === 0) {
@@ -781,15 +841,9 @@ class IncidentOwnerRuleEngineServiceClass {
         if (!incidentMonitor.id) {
           continue;
         }
-        const monitor: Monitor | null = await MonitorService.findOneById({
-          id: incidentMonitor.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+        const monitor: Monitor | null = await monitorCache.getMonitor(
+          incidentMonitor.id,
+        );
         if (!monitor) {
           continue;
         }

package/Server/Services/IncidentPrivacyRuleEngineService.ts

@@ -6,13 +6,14 @@ import Monitor from "../../Models/DatabaseModels/Monitor";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentPrivacyRuleService from "./IncidentPrivacyRuleService";
 import IncidentService from "./IncidentService";
-import MonitorService from "./MonitorService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import { Red500 } from "../../Types/BrandColors";
 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 IncidentPrivacyRuleEngineServiceClass {
   /**
@@ -45,6 +46,7 @@ class IncidentPrivacyRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             monitors: { _id: true },
             incidentSeverities: { _id: true },
             incidentLabels: { _id: true },
@@ -165,6 +167,64 @@ class IncidentPrivacyRuleEngineServiceClass {
   private async doesIncidentMatchRule(
     incident: Incident,
     rule: IncidentPrivacyRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule,
+      legacyFields: [
+        "monitors",
+        "incidentSeverities",
+        "incidentLabels",
+        "monitorLabels",
+        "incidentTitlePattern",
+        "incidentDescriptionPattern",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: IncidentPrivacyRule,
+      ): Promise<boolean> => {
+        return await this.doesIncidentMatchLegacyRule(
+          incident,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: [
+          "monitorLabels",
+          "monitorNamePattern",
+          "monitorDescriptionPattern",
+        ],
+        getCandidates: (): Array<Monitor> => {
+          return incident.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: IncidentPrivacyRule,
+          incidentMonitor: Monitor,
+        ): Promise<boolean> => {
+          const correlatedIncident: Incident = Object.assign(
+            new Incident(),
+            incident,
+          );
+          correlatedIncident.monitors = [incidentMonitor];
+          return await this.doesIncidentMatchLegacyRule(
+            correlatedIncident,
+            legacyRule,
+            monitorCache,
+          );
+        },
+      },
+    });
+  }
+
+  private async doesIncidentMatchLegacyRule(
+    incident: Incident,
+    rule: IncidentPrivacyRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     if (rule.monitors && rule.monitors.length > 0) {
       if (!incident.monitors || incident.monitors.length === 0) {
@@ -240,15 +300,9 @@ class IncidentPrivacyRuleEngineServiceClass {
         if (!incidentMonitor.id) {
           continue;
         }
-        const monitor: Monitor | null = await MonitorService.findOneById({
-          id: incidentMonitor.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+        const monitor: Monitor | null = await monitorCache.getMonitor(
+          incidentMonitor.id,
+        );
         if (!monitor) {
           continue;
         }

package/Server/Services/IncidentReminderRuleService.ts

@@ -17,6 +17,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() {
@@ -188,6 +189,7 @@ export class Service extends DatabaseService<Model> {
         order: true,
         reminderIntervalInMinutes: true,
         stopRemindersOnState: true,
+        criteria: true,
         incidentSeverities: {
           _id: true,
         },
@@ -209,40 +211,8 @@ export class Service extends DatabaseService<Model> {
     });
 
     for (const rule of rules) {
-      if (rule.incidentSeverities && rule.incidentSeverities.length > 0) {
-        if (!data.incidentSeverityId) {
-          continue;
-        }
-
-        const severityIds: Array<string> = rule.incidentSeverities.map(
-          (severity: IncidentSeverity) => {
-            return severity.id?.toString() || "";
-          },
-        );
-
-        if (!severityIds.includes(data.incidentSeverityId.toString())) {
-          continue;
-        }
-      }
-
-      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.doesIncidentMatchRule({ rule: rule, ...data })) {
+        continue;
       }
 
       /*
@@ -259,6 +229,68 @@ export class Service extends DatabaseService<Model> {
 
     return null;
   }
+
+  public doesIncidentMatchRule(data: {
+    rule: Model;
+    incidentSeverityId?: ObjectID | undefined;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: data.rule,
+      legacyFields: ["incidentSeverities", "labels"],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: Model): boolean => {
+        return this.doesIncidentMatchLegacyRule({
+          ...data,
+          rule: legacyRule,
+        });
+      },
+    });
+  }
+
+  private doesIncidentMatchLegacyRule(data: {
+    rule: Model;
+    incidentSeverityId?: ObjectID | undefined;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    const rule: Model = data.rule;
+
+    if (rule.incidentSeverities && rule.incidentSeverities.length > 0) {
+      if (!data.incidentSeverityId) {
+        return false;
+      }
+
+      const severityIds: Array<string> = rule.incidentSeverities.map(
+        (severity: IncidentSeverity) => {
+          return severity.id?.toString() || "";
+        },
+      );
+
+      if (!severityIds.includes(data.incidentSeverityId.toString())) {
+        return false;
+      }
+    }
+
+    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/IncidentSlaRuleService.ts

@@ -11,10 +11,11 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { IsBillingEnabled } from "../EnvironmentConfig";
-import MonitorService from "./MonitorService";
 import IncidentService from "./IncidentService";
 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";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -119,6 +120,7 @@ export class Service extends DatabaseService<Model> {
         publicNoteReminderIntervalInMinutes: true,
         internalNoteReminderTemplate: true,
         publicNoteReminderTemplate: true,
+        criteria: true,
         monitors: {
           _id: true,
         },
@@ -177,6 +179,56 @@ export class Service extends DatabaseService<Model> {
   public async doesIncidentMatchRule(
     incident: Incident,
     rule: Model,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule: rule,
+      legacyFields: [
+        "monitors",
+        "incidentSeverities",
+        "incidentLabels",
+        "monitorLabels",
+        "incidentTitlePattern",
+        "incidentDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (legacyRule: Model): Promise<boolean> => {
+        return await this.doesIncidentMatchLegacyRule(
+          incident,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: ["monitorLabels"],
+        getCandidates: (): Array<Monitor> => {
+          return incident.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: Model,
+          incidentMonitor: Monitor,
+        ): Promise<boolean> => {
+          const correlatedIncident: Incident = Object.assign(
+            new Incident(),
+            incident,
+          );
+          correlatedIncident.monitors = [incidentMonitor];
+          return await this.doesIncidentMatchLegacyRule(
+            correlatedIncident,
+            legacyRule,
+            monitorCache,
+          );
+        },
+      },
+    });
+  }
+
+  private async doesIncidentMatchLegacyRule(
+    incident: Incident,
+    rule: Model,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     logger.debug(
       `Checking if incident ${incident.id} matches SLA rule ${rule.name || rule.id}`,
@@ -284,17 +336,8 @@ export class Service extends DatabaseService<Model> {
               : undefined;
 
           if (monitorId) {
-            const monitor: Monitor | null = await MonitorService.findOneById({
-              id: monitorId,
-              select: {
-                labels: {
-                  _id: true,
-                },
-              },
-              props: {
-                isRoot: true,
-              },
-            });
+            const monitor: Monitor | null =
+              await monitorCache.getMonitor(monitorId);
 
             monitorLabels = monitor?.labels;
           }

package/Server/Services/IncomingCallPolicyLabelRuleEngineService.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 IncomingCallPolicyLabelRuleEngineServiceClass {
@@ -29,6 +30,7 @@ class IncomingCallPolicyLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             incomingCallPolicyLabels: { _id: true },
             incomingCallPolicyNamePattern: true,
             incomingCallPolicyDescriptionPattern: true,
@@ -137,6 +139,24 @@ class IncomingCallPolicyLabelRuleEngineServiceClass {
   private doesPolicyMatchRule(
     policy: IncomingCallPolicy,
     rule: IncomingCallPolicyLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "incomingCallPolicyLabels",
+        "incomingCallPolicyNamePattern",
+        "incomingCallPolicyDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: IncomingCallPolicyLabelRule): boolean => {
+        return this.doesPolicyMatchLegacyRule(policy, legacyRule);
+      },
+    });
+  }
+
+  private doesPolicyMatchLegacyRule(
+    policy: IncomingCallPolicy,
+    rule: IncomingCallPolicyLabelRule,
   ): boolean {
     if (
       rule.incomingCallPolicyLabels &&

package/Server/Services/IncomingCallPolicyOwnerRuleEngineService.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 IncomingCallPolicyOwnerRuleEngineServiceClass {
@@ -33,6 +34,7 @@ class IncomingCallPolicyOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             incomingCallPolicyLabels: { _id: true },
             incomingCallPolicyNamePattern: true,
@@ -160,6 +162,24 @@ class IncomingCallPolicyOwnerRuleEngineServiceClass {
   private doesPolicyMatchRule(
     policy: IncomingCallPolicy,
     rule: IncomingCallPolicyOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "incomingCallPolicyLabels",
+        "incomingCallPolicyNamePattern",
+        "incomingCallPolicyDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: IncomingCallPolicyOwnerRule): boolean => {
+        return this.doesPolicyMatchLegacyRule(policy, legacyRule);
+      },
+    });
+  }
+
+  private doesPolicyMatchLegacyRule(
+    policy: IncomingCallPolicy,
+    rule: IncomingCallPolicyOwnerRule,
   ): boolean {
     if (
       rule.incomingCallPolicyLabels &&