@oneuptime/common 13.0.1 → 13.0.4

package/Server/Services/AlertReminderRuleService.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,
         alertSeverities: {
           _id: true,
         },
@@ -209,52 +211,82 @@ export class Service extends DatabaseService<Model> {
     });
 
     for (const rule of rules) {
-      if (rule.alertSeverities && rule.alertSeverities.length > 0) {
-        if (!data.alertSeverityId) {
-          continue;
-        }
+      if (!this.doesAlertMatchRule({ rule: rule, ...data })) {
+        continue;
+      }
 
-        const severityIds: Array<string> = rule.alertSeverities.map(
-          (severity: AlertSeverity) => {
-            return severity.id?.toString() || "";
-          },
-        );
+      // Rule with no severities and no labels matches all alerts.
+      logger.debug(
+        `Alert reminder rule ${rule.name || rule.id} matched for project ${data.projectId}`,
+        { projectId: data.projectId?.toString() } as LogAttributes,
+      );
 
-        if (!severityIds.includes(data.alertSeverityId.toString())) {
-          continue;
-        }
-      }
+      return rule;
+    }
 
-      if (rule.labels && rule.labels.length > 0) {
-        if (!data.labelIds || data.labelIds.length === 0) {
-          continue;
-        }
+    return null;
+  }
 
-        const ruleLabelIds: Array<string> = rule.labels.map((label: Label) => {
-          return label.id?.toString() || "";
+  public doesAlertMatchRule(data: {
+    rule: Model;
+    alertSeverityId?: ObjectID | undefined;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: data.rule,
+      legacyFields: ["alertSeverities", "labels"],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: Model): boolean => {
+        return this.doesAlertMatchLegacyRule({
+          ...data,
+          rule: legacyRule,
         });
+      },
+    });
+  }
 
-        const hasMatchingLabel: boolean = data.labelIds.some(
-          (labelId: ObjectID) => {
-            return ruleLabelIds.includes(labelId.toString());
-          },
-        );
+  private doesAlertMatchLegacyRule(data: {
+    rule: Model;
+    alertSeverityId?: ObjectID | undefined;
+    labelIds?: Array<ObjectID> | undefined;
+  }): boolean {
+    const rule: Model = data.rule;
 
-        if (!hasMatchingLabel) {
-          continue;
-        }
+    if (rule.alertSeverities && rule.alertSeverities.length > 0) {
+      if (!data.alertSeverityId) {
+        return false;
       }
 
-      // Rule with no severities and no labels matches all alerts.
-      logger.debug(
-        `Alert reminder rule ${rule.name || rule.id} matched for project ${data.projectId}`,
-        { projectId: data.projectId?.toString() } as LogAttributes,
+      const severityIds: Array<string> = rule.alertSeverities.map(
+        (severity: AlertSeverity) => {
+          return severity.id?.toString() || "";
+        },
       );
 
-      return rule;
+      if (!severityIds.includes(data.alertSeverityId.toString())) {
+        return false;
+      }
     }
 
-    return null;
+    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;
   }
 }
 

package/Server/Services/AutoRemediationRuleEngineService.ts

@@ -28,7 +28,6 @@ import AutoRemediationRuleService from "./AutoRemediationRuleService";
 import AutoRemediationSuggestionService from "./AutoRemediationSuggestionService";
 import IncidentFeedService from "./IncidentFeedService";
 import LlmProviderService from "./LlmProviderService";
-import MonitorService from "./MonitorService";
 import ProjectService from "./ProjectService";
 import RunbookRuleEngineService from "./RunbookRuleEngineService";
 import AIInvestigationQueue from "../Utils/AI/SRE/InvestigationQueue";
@@ -37,6 +36,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";
 
 /*
  * Guardrails (minimal G1 for auto-remediation Phase 1):
@@ -209,6 +210,7 @@ class AutoRemediationRuleEngineServiceClass {
           aiComposesCommands: true,
           verificationWindowMinutes: true,
           autoResolveOnVerifiedRecovery: true,
+          criteria: true,
           titlePattern: true,
           descriptionPattern: true,
           monitors: { _id: true },
@@ -863,6 +865,58 @@ class AutoRemediationRuleEngineServiceClass {
   public async doesIncidentMatchRule(
     incident: Incident,
     rule: AutoRemediationRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule: rule,
+      legacyFields: [
+        "monitors",
+        "incidentSeverities",
+        "labels",
+        "monitorLabels",
+        "titlePattern",
+        "descriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AutoRemediationRule,
+      ): Promise<boolean> => {
+        return await this.doesIncidentMatchLegacyRule(
+          incident,
+          legacyRule,
+          monitorCache,
+        );
+      },
+      correlation: {
+        fields: ["monitorLabels"],
+        getCandidates: (): Array<Monitor> => {
+          return incident.monitors || [];
+        },
+        matchesLegacyRuleForCandidate: async (
+          legacyRule: AutoRemediationRule,
+          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: AutoRemediationRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     // Monitors: incident must come from at least one of the rule's monitors.
     if (rule.monitors && rule.monitors.length > 0) {
@@ -938,6 +992,7 @@ class AutoRemediationRuleEngineServiceClass {
           await this.doesMonitorCarryAnyLabel(
             incidentMonitor.id,
             rule.monitorLabels,
+            monitorCache,
           )
         ) {
           anyMonitorMatches = true;
@@ -974,6 +1029,37 @@ class AutoRemediationRuleEngineServiceClass {
   public async doesAlertMatchRule(
     alert: Alert,
     rule: AutoRemediationRule,
+  ): Promise<boolean> {
+    const monitorCache: MonitorRuleCriteriaCache =
+      new MonitorRuleCriteriaCache();
+
+    return await RuleCriteriaMatcher.matchesWithLegacy({
+      rule: rule,
+      legacyFields: [
+        "monitors",
+        "alertSeverities",
+        "labels",
+        "monitorLabels",
+        "titlePattern",
+        "descriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: async (
+        legacyRule: AutoRemediationRule,
+      ): Promise<boolean> => {
+        return await this.doesAlertMatchLegacyRule(
+          alert,
+          legacyRule,
+          monitorCache,
+        );
+      },
+    });
+  }
+
+  private async doesAlertMatchLegacyRule(
+    alert: Alert,
+    rule: AutoRemediationRule,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
     // Monitors: alerts carry a single scalar monitorId.
     if (rule.monitors && rule.monitors.length > 0) {
@@ -1031,6 +1117,7 @@ class AutoRemediationRuleEngineServiceClass {
         !(await this.doesMonitorCarryAnyLabel(
           alert.monitorId,
           rule.monitorLabels,
+          monitorCache,
         ))
       ) {
         return false;
@@ -1061,14 +1148,9 @@ class AutoRemediationRuleEngineServiceClass {
   private async doesMonitorCarryAnyLabel(
     monitorId: ObjectID,
     ruleMonitorLabels: Array<Label>,
+    monitorCache: MonitorRuleCriteriaCache,
   ): Promise<boolean> {
-    const monitor: Monitor | null = await MonitorService.findOneById({
-      id: monitorId,
-      select: {
-        labels: { _id: true },
-      },
-      props: { isRoot: true },
-    });
+    const monitor: Monitor | null = await monitorCache.getMonitor(monitorId);
 
     if (!monitor || !monitor.labels || monitor.labels.length === 0) {
       return false;

package/Server/Services/CephClusterLabelRuleEngineService.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 CephClusterLabelRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class CephClusterLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             cephClusterLabels: { _id: true },
             cephClusterNamePattern: true,
             cephClusterDescriptionPattern: true,
@@ -172,6 +174,24 @@ class CephClusterLabelRuleEngineServiceClass {
   private doesCephClusterMatchRule(
     cephCluster: CephCluster,
     rule: CephClusterLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "cephClusterLabels",
+        "cephClusterNamePattern",
+        "cephClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: CephClusterLabelRule): boolean => {
+        return this.doesCephClusterMatchLegacyRule(cephCluster, legacyRule);
+      },
+    });
+  }
+
+  private doesCephClusterMatchLegacyRule(
+    cephCluster: CephCluster,
+    rule: CephClusterLabelRule,
   ): boolean {
     if (rule.cephClusterLabels && rule.cephClusterLabels.length > 0) {
       if (!cephCluster.labels || cephCluster.labels.length === 0) {

package/Server/Services/CephClusterOwnerRuleEngineService.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 CephClusterOwnerRuleEngineServiceClass {
@@ -42,6 +43,7 @@ class CephClusterOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             cephClusterLabels: { _id: true },
             cephClusterNamePattern: true,
@@ -184,6 +186,24 @@ class CephClusterOwnerRuleEngineServiceClass {
   private doesCephClusterMatchRule(
     cephCluster: CephCluster,
     rule: CephClusterOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "cephClusterLabels",
+        "cephClusterNamePattern",
+        "cephClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: CephClusterOwnerRule): boolean => {
+        return this.doesCephClusterMatchLegacyRule(cephCluster, legacyRule);
+      },
+    });
+  }
+
+  private doesCephClusterMatchLegacyRule(
+    cephCluster: CephCluster,
+    rule: CephClusterOwnerRule,
   ): boolean {
     if (rule.cephClusterLabels && rule.cephClusterLabels.length > 0) {
       if (!cephCluster.labels || cephCluster.labels.length === 0) {

package/Server/Services/CloudResourceLabelRuleEngineService.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 CloudResourceLabelRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class CloudResourceLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
             descriptionRegexPattern: true,
@@ -160,6 +162,24 @@ class CloudResourceLabelRuleEngineServiceClass {
   private doesMatchRule(
     cloudResource: CloudResource,
     rule: CloudResourceLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: CloudResourceLabelRule): boolean => {
+        return this.doesMatchLegacyRule(cloudResource, legacyRule);
+      },
+    });
+  }
+
+  private doesMatchLegacyRule(
+    cloudResource: CloudResource,
+    rule: CloudResourceLabelRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!cloudResource.labels || cloudResource.labels.length === 0) {

package/Server/Services/CloudResourceOwnerRuleEngineService.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 CloudResourceOwnerRuleEngineServiceClass {
@@ -41,6 +42,7 @@ class CloudResourceOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
@@ -180,6 +182,24 @@ class CloudResourceOwnerRuleEngineServiceClass {
   private doesMatchRule(
     cloudResource: CloudResource,
     rule: CloudResourceOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: CloudResourceOwnerRule): boolean => {
+        return this.doesMatchLegacyRule(cloudResource, legacyRule);
+      },
+    });
+  }
+
+  private doesMatchLegacyRule(
+    cloudResource: CloudResource,
+    rule: CloudResourceOwnerRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!cloudResource.labels || cloudResource.labels.length === 0) {

package/Server/Services/DashboardLabelRuleEngineService.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 DashboardLabelRuleEngineServiceClass {
@@ -32,6 +33,7 @@ class DashboardLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             dashboardLabels: { _id: true },
             dashboardNamePattern: true,
             dashboardDescriptionPattern: true,
@@ -141,6 +143,24 @@ class DashboardLabelRuleEngineServiceClass {
   private doesDashboardMatchRule(
     dashboard: Dashboard,
     rule: DashboardLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "dashboardLabels",
+        "dashboardNamePattern",
+        "dashboardDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: DashboardLabelRule): boolean => {
+        return this.doesDashboardMatchLegacyRule(dashboard, legacyRule);
+      },
+    });
+  }
+
+  private doesDashboardMatchLegacyRule(
+    dashboard: Dashboard,
+    rule: DashboardLabelRule,
   ): boolean {
     if (rule.dashboardLabels && rule.dashboardLabels.length > 0) {
       if (!dashboard.labels || dashboard.labels.length === 0) {

package/Server/Services/DashboardOwnerRuleEngineService.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 DashboardOwnerRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class DashboardOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             dashboardLabels: { _id: true },
             dashboardNamePattern: true,
@@ -159,6 +161,24 @@ class DashboardOwnerRuleEngineServiceClass {
   private doesDashboardMatchRule(
     dashboard: Dashboard,
     rule: DashboardOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule,
+      legacyFields: [
+        "dashboardLabels",
+        "dashboardNamePattern",
+        "dashboardDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: DashboardOwnerRule): boolean => {
+        return this.doesDashboardMatchLegacyRule(dashboard, legacyRule);
+      },
+    });
+  }
+
+  private doesDashboardMatchLegacyRule(
+    dashboard: Dashboard,
+    rule: DashboardOwnerRule,
   ): boolean {
     if (rule.dashboardLabels && rule.dashboardLabels.length > 0) {
       if (!dashboard.labels || dashboard.labels.length === 0) {