@oneuptime/common 13.0.4 → 13.0.6

package/Server/Services/ServiceOwnerRuleEngineService.ts

@@ -11,13 +11,43 @@ import ServiceFeedService from "./ServiceFeedService";
 import { ServiceFeedEventType } from "../../Models/DatabaseModels/ServiceFeed";
 import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
+import Select from "../Types/Database/Select";
 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";
+import OwnerRuleAssignment, {
+  OwnersToAssign,
+} from "../Utils/Rules/OwnerRuleAssignment";
+import {
+  ApplyRulesToExistingResourceData,
+  RuleApplicationResult,
+  RuleApplicationResultUtil,
+  RuleRunEngine,
+} from "../Utils/Rules/RuleRun/RuleApplication";
+
+class ServiceOwnerRuleEngineServiceClass
+  implements RuleRunEngine<Service, ServiceOwnerRule>
+{
+  public readonly ruleSelect: Select<ServiceOwnerRule> = {
+    _id: true,
+    name: true,
+    criteria: true,
+    notifyOwners: true,
+    serviceLabels: { _id: true },
+    serviceNamePattern: true,
+    serviceDescriptionPattern: true,
+    ownerUsers: { _id: true },
+    ownerTeams: { _id: true },
+  };
+
+  // Evaluation re-reads the service, so a run only has to name it.
+  public readonly resourceSelectForRuleRun: Select<Service> = {
+    _id: true,
+    projectId: true,
+  };
 
-class ServiceOwnerRuleEngineServiceClass {
   /**
    * Evaluates ServiceOwnerRule rows for the given service and adds matched
    * owner users / teams via ServiceOwnerUserService / ServiceOwnerTeamService. Rules
@@ -38,17 +68,7 @@ class ServiceOwnerRuleEngineServiceClass {
             isEnabled: true,
           },
           props: { isRoot: true },
-          select: {
-            _id: true,
-            name: true,
-            criteria: true,
-            notifyOwners: true,
-            serviceLabels: { _id: true },
-            serviceNamePattern: true,
-            serviceDescriptionPattern: true,
-            ownerUsers: { _id: true },
-            ownerTeams: { _id: true },
-          },
+          select: this.ruleSelect,
           limit: MAX_RULES_EVALUATED_PER_PROJECT,
           skip: 0,
         });
@@ -63,123 +83,225 @@ class ServiceOwnerRuleEngineServiceClass {
         return;
       }
 
-      const serviceWithDetails: Service | null =
-        await ServiceService.findOneById({
-          id: service.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+      await this.applyRules({
+        service: service,
+        rules: rules,
+        allowOwnerNotification: true,
+      });
+    } catch (error) {
+      logger.error(`Error applying service owner rules: ${error}`, {
+        projectId: service.projectId?.toString(),
+        serviceId: service.id?.toString(),
+      } as LogAttributes);
+    }
+  }
 
-      if (!serviceWithDetails) {
-        return;
-      }
+  /*
+   * "Run now": the same evaluation, for a service that already exists and
+   * only the rules being run.
+   */
+  @CaptureSpan()
+  public async applyRulesToExistingResource(
+    data: ApplyRulesToExistingResourceData<Service, ServiceOwnerRule>,
+  ): Promise<RuleApplicationResult> {
+    try {
+      return await this.applyRules({
+        service: data.resource,
+        rules: data.rules,
+        allowOwnerNotification: data.allowOwnerNotification,
+      });
+    } catch (error) {
+      logger.error(`Error running service owner rules: ${error}`, {
+        projectId: data.resource.projectId?.toString(),
+        serviceId: data.resource.id?.toString(),
+      } as LogAttributes);
+
+      return RuleApplicationResultUtil.failed();
+    }
+  }
 
-      const usersByNotify: Map<boolean, Set<string>> = new Map([
-        [true, new Set()],
-        [false, new Set()],
-      ]);
-      const teamsByNotify: Map<boolean, Set<string>> = new Map([
-        [true, new Set()],
-        [false, new Set()],
-      ]);
+  private async applyRules(data: {
+    service: Service;
+    rules: Array<ServiceOwnerRule>;
+    allowOwnerNotification: boolean;
+  }): Promise<RuleApplicationResult> {
+    const { service, rules } = data;
 
-      const matchedRules: Array<ServiceOwnerRule> = [];
+    if (!service.id || !service.projectId || rules.length === 0) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-      for (const rule of rules) {
-        const matches: boolean = this.doesServiceMatchRule(
-          serviceWithDetails,
-          rule,
-        );
-        if (!matches) {
-          continue;
-        }
-        let ruleAddedAny: boolean = false;
-        const notify: boolean = rule.notifyOwners !== false;
-        for (const user of rule.ownerUsers || []) {
-          if (user.id) {
-            usersByNotify.get(notify)!.add(user.id.toString());
-            ruleAddedAny = true;
-          }
-        }
-        for (const team of rule.ownerTeams || []) {
-          if (team.id) {
-            teamsByNotify.get(notify)!.add(team.id.toString());
-            ruleAddedAny = true;
-          }
+    const serviceWithDetails: Service | null = await ServiceService.findOneById(
+      {
+        id: service.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        props: { isRoot: true },
+      },
+    );
+
+    if (!serviceWithDetails) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    /*
+     * Service owner rows carry no notification flag and nothing notifies a
+     * service owner on add, so the notify split below only decides which
+     * rule an owner is attributed to - it changes nothing that is written.
+     */
+    const usersByNotify: Map<boolean, Set<string>> = new Map([
+      [true, new Set()],
+      [false, new Set()],
+    ]);
+    const teamsByNotify: Map<boolean, Set<string>> = new Map([
+      [true, new Set()],
+      [false, new Set()],
+    ]);
+
+    const matchedRules: Array<ServiceOwnerRule> = [];
+    const allUserIds: Set<string> = new Set();
+    const allTeamIds: Set<string> = new Set();
+    let anyRuleMatched: boolean = false;
+
+    for (const rule of rules) {
+      const matches: boolean = this.doesServiceMatchRule(
+        serviceWithDetails,
+        rule,
+      );
+      if (!matches) {
+        continue;
+      }
+      anyRuleMatched = true;
+      let ruleAddedAny: boolean = false;
+      const notify: boolean =
+        rule.notifyOwners !== false && data.allowOwnerNotification;
+      for (const user of rule.ownerUsers || []) {
+        if (user.id) {
+          usersByNotify.get(notify)!.add(user.id.toString());
+          allUserIds.add(user.id.toString());
+          ruleAddedAny = true;
         }
-        if (ruleAddedAny) {
-          matchedRules.push(rule);
+      }
+      for (const team of rule.ownerTeams || []) {
+        if (team.id) {
+          teamsByNotify.get(notify)!.add(team.id.toString());
+          allTeamIds.add(team.id.toString());
+          ruleAddedAny = true;
         }
       }
-
-      if (matchedRules.length === 0) {
-        return;
+      if (ruleAddedAny) {
+        matchedRules.push(rule);
       }
+    }
 
-      for (const notify of [true, false]) {
-        const userIds: Set<string> = usersByNotify.get(notify)!;
-        const teamIds: Set<string> = teamsByNotify.get(notify)!;
-
-        for (const userId of userIds) {
-          const owner: ServiceOwnerUser = new ServiceOwnerUser();
-          owner.serviceId = service.id;
-          owner.projectId = service.projectId;
-          owner.userId = new ObjectID(userId);
-          await ServiceOwnerUserService.create({
-            data: owner,
-            props: { isRoot: true },
-          });
-        }
+    if (!anyRuleMatched) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-        for (const teamId of teamIds) {
-          const owner: ServiceOwnerTeam = new ServiceOwnerTeam();
-          owner.serviceId = service.id;
-          owner.projectId = service.projectId;
-          owner.teamId = new ObjectID(teamId);
-          await ServiceOwnerTeamService.create({
-            data: owner,
-            props: { isRoot: true },
-          });
-        }
-      }
+    if (
+      matchedRules.length === 0 ||
+      (allUserIds.size === 0 && allTeamIds.size === 0)
+    ) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
 
-      logger.debug(
-        `ServiceOwnerRuleEngine added owners to service ${service.id}`,
-        { projectId: service.projectId.toString() } as LogAttributes,
-      );
-      /*
-       * The individual OwnerUserAdded / OwnerTeamAdded items say who was added;
-       * this one says which rule is responsible, which is what somebody asking
-       * "why am I on the hook for this?" actually needs.
-       */
-      await ServiceFeedService.createServiceFeedItem({
-        serviceId: service.id,
-        projectId: service.projectId,
-        serviceFeedEventType: ServiceFeedEventType.OwnerRuleExecuted,
-        displayColor: Purple500,
-        feedInfoInMarkdown: `👥 Owners were added to ${await ServiceService.getServiceMarkdownLink(
-          service.projectId,
-          service.id,
-        )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
-        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
-          .map((rule: ServiceOwnerRule) => {
-            return rule.name || rule.id?.toString() || "Unnamed rule";
-          })
-          .map((name: string) => {
-            return `\`${name}\``;
-          })
-          .join(", ")}`,
+    // Owners already on the service are skipped rather than duplicated.
+    const notYetAssigned: OwnersToAssign =
+      await OwnerRuleAssignment.getOwnersNotYetAssigned({
+        ownerUserService: ServiceOwnerUserService,
+        ownerTeamService: ServiceOwnerTeamService,
+        resourceIdColumn: "serviceId",
+        resourceId: service.id,
+        userIds: Array.from(allUserIds),
+        teamIds: Array.from(allTeamIds),
       });
-    } catch (error) {
-      logger.error(`Error applying service owner rules: ${error}`, {
-        projectId: service.projectId?.toString(),
-        serviceId: service.id?.toString(),
-      } as LogAttributes);
+
+    const userIdsToAdd: Set<string> = new Set(
+      notYetAssigned.userIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+    const teamIdsToAdd: Set<string> = new Set(
+      notYetAssigned.teamIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    let ownersAdded: number = 0;
+
+    for (const notify of [true, false]) {
+      const userIds: Array<string> = Array.from(
+        usersByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return userIdsToAdd.delete(id);
+      });
+      const teamIds: Array<string> = Array.from(
+        teamsByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return teamIdsToAdd.delete(id);
+      });
+
+      for (const userId of userIds) {
+        const owner: ServiceOwnerUser = new ServiceOwnerUser();
+        owner.serviceId = service.id;
+        owner.projectId = service.projectId;
+        owner.userId = new ObjectID(userId);
+        await ServiceOwnerUserService.create({
+          data: owner,
+          props: { isRoot: true },
+        });
+        ownersAdded++;
+      }
+
+      for (const teamId of teamIds) {
+        const owner: ServiceOwnerTeam = new ServiceOwnerTeam();
+        owner.serviceId = service.id;
+        owner.projectId = service.projectId;
+        owner.teamId = new ObjectID(teamId);
+        await ServiceOwnerTeamService.create({
+          data: owner,
+          props: { isRoot: true },
+        });
+        ownersAdded++;
+      }
     }
+
+    if (ownersAdded === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
+
+    logger.debug(
+      `ServiceOwnerRuleEngine added owners to service ${service.id}`,
+      { projectId: service.projectId.toString() } as LogAttributes,
+    );
+    /*
+     * The individual OwnerUserAdded / OwnerTeamAdded items say who was added;
+     * this one says which rule is responsible, which is what somebody asking
+     * "why am I on the hook for this?" actually needs.
+     */
+    await ServiceFeedService.createServiceFeedItem({
+      serviceId: service.id,
+      projectId: service.projectId,
+      serviceFeedEventType: ServiceFeedEventType.OwnerRuleExecuted,
+      displayColor: Purple500,
+      feedInfoInMarkdown: `👥 Owners were added to ${await ServiceService.getServiceMarkdownLink(
+        service.projectId,
+        service.id,
+      )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
+      moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
+        .map((rule: ServiceOwnerRule) => {
+          return rule.name || rule.id?.toString() || "Unnamed rule";
+        })
+        .map((name: string) => {
+          return `\`${name}\``;
+        })
+        .join(", ")}`,
+    });
+
+    return RuleApplicationResultUtil.updated(ownersAdded);
   }
 
   private doesServiceMatchRule(

package/Server/Services/StatusPageAnnouncementService.ts

@@ -4,6 +4,7 @@ import CreateBy from "../Types/Database/CreateBy";
 import UpdateBy from "../Types/Database/UpdateBy";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import SubscriberUpdateNotification from "../../Types/StatusPage/SubscriberUpdateNotification";
 import ObjectID from "../../Types/ObjectID";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -50,6 +51,18 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    /*
+     * An edit tells subscribers nothing unless the editor asked for it on this
+     * edit (see SubscriberUpdateNotification). When they did, queue the update
+     * notification; the Announcement worker job sends it.
+     */
+    if (SubscriberUpdateNotification.isRequested(updateBy.miscDataProps)) {
+      updateBy.data.subscriberNotificationStatusOnAnnouncementUpdated =
+        StatusPageSubscriberNotificationStatus.Pending;
+      updateBy.data.subscriberNotificationStatusMessageOnAnnouncementUpdated =
+        SubscriberUpdateNotification.queuedMessage;
+    }
+
     return {
       updateBy,
       carryForward: null,

package/Server/Services/StatusPageLabelRuleEngineService.ts

@@ -4,13 +4,38 @@ import StatusPageLabelRule from "../../Models/DatabaseModels/StatusPageLabelRule
 import StatusPageLabelRuleService from "./StatusPageLabelRuleService";
 import StatusPageService from "./StatusPageService";
 import ObjectID from "../../Types/ObjectID";
+import Select from "../Types/Database/Select";
 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";
+import {
+  ApplyRulesToExistingResourceData,
+  RuleApplicationResult,
+  RuleApplicationResultUtil,
+  RuleRunEngine,
+} from "../Utils/Rules/RuleRun/RuleApplication";
+
+class StatusPageLabelRuleEngineServiceClass
+  implements RuleRunEngine<StatusPage, StatusPageLabelRule>
+{
+  public readonly ruleSelect: Select<StatusPageLabelRule> = {
+    _id: true,
+    name: true,
+    criteria: true,
+    statusPageLabels: { _id: true },
+    statusPageNamePattern: true,
+    statusPageDescriptionPattern: true,
+    labelsToAdd: { _id: true },
+  };
+
+  // Evaluation re-reads the status page, so a run only has to name it.
+  public readonly resourceSelectForRuleRun: Select<StatusPage> = {
+    _id: true,
+    projectId: true,
+  };
 
-class StatusPageLabelRuleEngineServiceClass {
   /**
    * Evaluates StatusPageLabelRule rows for the given status page and attaches
    * matched labels to it. The union is deduped against labels already on the
@@ -31,15 +56,7 @@ class StatusPageLabelRuleEngineServiceClass {
             isEnabled: true,
           },
           props: { isRoot: true },
-          select: {
-            _id: true,
-            name: true,
-            criteria: true,
-            statusPageLabels: { _id: true },
-            statusPageNamePattern: true,
-            statusPageDescriptionPattern: true,
-            labelsToAdd: { _id: true },
-          },
+          select: this.ruleSelect,
           limit: MAX_RULES_EVALUATED_PER_PROJECT,
           skip: 0,
         });
@@ -54,92 +71,136 @@ class StatusPageLabelRuleEngineServiceClass {
         return;
       }
 
-      const statusPageWithDetails: StatusPage | null =
-        await StatusPageService.findOneById({
-          id: statusPage.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
-
-      if (!statusPageWithDetails) {
-        return;
-      }
+      await this.applyRules({ statusPage: statusPage, rules: rules });
+    } catch (error) {
+      logger.error(`Error applying status page label rules: ${error}`, {
+        projectId: statusPage.projectId?.toString(),
+        statusPageId: statusPage.id?.toString(),
+      } as LogAttributes);
+    }
+  }
 
-      const labelIdsToAdd: Set<string> = new Set();
+  /*
+   * "Run now": the same evaluation, for a status page that already exists and
+   * only the rules being run.
+   */
+  @CaptureSpan()
+  public async applyRulesToExistingResource(
+    data: ApplyRulesToExistingResourceData<StatusPage, StatusPageLabelRule>,
+  ): Promise<RuleApplicationResult> {
+    try {
+      return await this.applyRules({
+        statusPage: data.resource,
+        rules: data.rules,
+      });
+    } catch (error) {
+      logger.error(`Error running status page label rules: ${error}`, {
+        projectId: data.resource.projectId?.toString(),
+        statusPageId: data.resource.id?.toString(),
+      } as LogAttributes);
 
-      for (const rule of rules) {
-        const matches: boolean = this.doesStatusPageMatchRule(
-          statusPageWithDetails,
-          rule,
-        );
-        if (!matches) {
-          continue;
-        }
-        for (const label of rule.labelsToAdd || []) {
-          if (label.id) {
-            labelIdsToAdd.add(label.id.toString());
-          }
-        }
-      }
+      return RuleApplicationResultUtil.failed();
+    }
+  }
 
-      if (labelIdsToAdd.size === 0) {
-        return;
-      }
+  private async applyRules(data: {
+    statusPage: StatusPage;
+    rules: Array<StatusPageLabelRule>;
+  }): Promise<RuleApplicationResult> {
+    const { statusPage, rules } = data;
 
-      const existingLabelIds: Set<string> = new Set(
-        (statusPageWithDetails.labels || [])
-          .map((l: Label) => {
-            return l.id?.toString() || "";
-          })
-          .filter((id: string) => {
-            return id !== "";
-          }),
-      );
+    if (!statusPage.id || !statusPage.projectId || rules.length === 0) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-      const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
-        (id: string) => {
-          return !existingLabelIds.has(id);
+    const statusPageWithDetails: StatusPage | null =
+      await StatusPageService.findOneById({
+        id: statusPage.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
         },
+        props: { isRoot: true },
+      });
+
+    if (!statusPageWithDetails) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    const labelIdsToAdd: Set<string> = new Set();
+    let anyRuleMatched: boolean = false;
+
+    for (const rule of rules) {
+      const matches: boolean = this.doesStatusPageMatchRule(
+        statusPageWithDetails,
+        rule,
       );
-      if (newLabelIds.length === 0) {
-        return;
+      if (!matches) {
+        continue;
       }
+      anyRuleMatched = true;
+      for (const label of rule.labelsToAdd || []) {
+        if (label.id) {
+          labelIdsToAdd.add(label.id.toString());
+        }
+      }
+    }
 
-      await StatusPageService.getRepository()
-        .createQueryBuilder()
-        .relation(StatusPage, "labels")
-        .of(statusPage.id.toString())
-        .add(newLabelIds);
-
-      /*
-       * Sync in-memory statusPage.labels with the now-persisted set so a
-       * downstream owner-rule engine in the same onCreateSuccess chain can
-       * match on rule-added labels.
-       */
-      const mergedLabelIds: Set<string> = new Set([
-        ...existingLabelIds,
-        ...newLabelIds,
-      ]);
-      statusPage.labels = Array.from(mergedLabelIds).map((id: string) => {
-        const label: Label = new Label();
-        label.id = new ObjectID(id);
-        return label;
-      });
+    if (!anyRuleMatched) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-      logger.debug(
-        `StatusPageLabelRuleEngine attached ${newLabelIds.length} labels to status page ${statusPage.id}`,
-        { projectId: statusPage.projectId.toString() } as LogAttributes,
-      );
-    } catch (error) {
-      logger.error(`Error applying status page label rules: ${error}`, {
-        projectId: statusPage.projectId?.toString(),
-        statusPageId: statusPage.id?.toString(),
-      } as LogAttributes);
+    if (labelIdsToAdd.size === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
     }
+
+    const existingLabelIds: Set<string> = new Set(
+      (statusPageWithDetails.labels || [])
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id !== "";
+        }),
+    );
+
+    const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
+      (id: string) => {
+        return !existingLabelIds.has(id);
+      },
+    );
+    if (newLabelIds.length === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
+
+    await StatusPageService.getRepository()
+      .createQueryBuilder()
+      .relation(StatusPage, "labels")
+      .of(statusPage.id.toString())
+      .add(newLabelIds);
+
+    /*
+     * Sync in-memory statusPage.labels with the now-persisted set so a
+     * downstream owner-rule engine in the same onCreateSuccess chain can
+     * match on rule-added labels.
+     */
+    const mergedLabelIds: Set<string> = new Set([
+      ...existingLabelIds,
+      ...newLabelIds,
+    ]);
+    statusPage.labels = Array.from(mergedLabelIds).map((id: string) => {
+      const label: Label = new Label();
+      label.id = new ObjectID(id);
+      return label;
+    });
+
+    logger.debug(
+      `StatusPageLabelRuleEngine attached ${newLabelIds.length} labels to status page ${statusPage.id}`,
+      { projectId: statusPage.projectId.toString() } as LogAttributes,
+    );
+
+    return RuleApplicationResultUtil.updated(newLabelIds.length);
   }
 
   private doesStatusPageMatchRule(