@oneuptime/common 10.3.0 → 10.4.1

package/Server/Services/OnCallDutyPolicyLabelRuleEngineService.ts

@@ -0,0 +1,191 @@
+import Label from "../../Models/DatabaseModels/Label";
+import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
+import OnCallDutyPolicyLabelRule from "../../Models/DatabaseModels/OnCallDutyPolicyLabelRule";
+import OnCallDutyPolicyLabelRuleService from "./OnCallDutyPolicyLabelRuleService";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class OnCallDutyPolicyLabelRuleEngineServiceClass {
+  @CaptureSpan()
+  public async applyRulesToOnCallDutyPolicy(
+    onCallDutyPolicy: OnCallDutyPolicy,
+  ): Promise<void> {
+    if (!onCallDutyPolicy.id || !onCallDutyPolicy.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<OnCallDutyPolicyLabelRule> =
+        await OnCallDutyPolicyLabelRuleService.findBy({
+          query: {
+            projectId: onCallDutyPolicy.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            onCallDutyPolicyLabels: { _id: true },
+            onCallDutyPolicyNamePattern: true,
+            onCallDutyPolicyDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const policyWithDetails: OnCallDutyPolicy | null =
+        await OnCallDutyPolicyService.findOneById({
+          id: onCallDutyPolicy.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!policyWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesPolicyMatchRule(
+          policyWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        for (const label of rule.labelsToAdd || []) {
+          if (label.id) {
+            labelIdsToAdd.add(label.id.toString());
+          }
+        }
+      }
+
+      if (labelIdsToAdd.size === 0) {
+        return;
+      }
+
+      const existingLabelIds: Set<string> = new Set(
+        (policyWithDetails.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;
+      }
+
+      await OnCallDutyPolicyService.getRepository()
+        .createQueryBuilder()
+        .relation(OnCallDutyPolicy, "labels")
+        .of(onCallDutyPolicy.id.toString())
+        .add(newLabelIds);
+
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      onCallDutyPolicy.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
+      logger.debug(
+        `OnCallDutyPolicyLabelRuleEngine attached ${newLabelIds.length} labels to policy ${onCallDutyPolicy.id}`,
+        { projectId: onCallDutyPolicy.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying on-call duty policy label rules: ${error}`, {
+        projectId: onCallDutyPolicy.projectId?.toString(),
+        onCallDutyPolicyId: onCallDutyPolicy.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesPolicyMatchRule(
+    policy: OnCallDutyPolicy,
+    rule: OnCallDutyPolicyLabelRule,
+  ): boolean {
+    if (rule.onCallDutyPolicyLabels && rule.onCallDutyPolicyLabels.length > 0) {
+      if (!policy.labels || policy.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.onCallDutyPolicyLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = policy.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.onCallDutyPolicyNamePattern &&
+      (!policy.name ||
+        !this.testRegex(rule.onCallDutyPolicyNamePattern, policy.name, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.onCallDutyPolicyDescriptionPattern &&
+      (!policy.description ||
+        !this.testRegex(
+          rule.onCallDutyPolicyDescriptionPattern,
+          policy.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: OnCallDutyPolicyLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in on-call duty policy label rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new OnCallDutyPolicyLabelRuleEngineServiceClass();

package/Server/Services/OnCallDutyPolicyLabelRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/OnCallDutyPolicyLabelRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/OnCallDutyPolicyOwnerRuleEngineService.ts

@@ -0,0 +1,214 @@
+import Label from "../../Models/DatabaseModels/Label";
+import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
+import OnCallDutyPolicyOwnerRule from "../../Models/DatabaseModels/OnCallDutyPolicyOwnerRule";
+import OnCallDutyPolicyOwnerUser from "../../Models/DatabaseModels/OnCallDutyPolicyOwnerUser";
+import OnCallDutyPolicyOwnerTeam from "../../Models/DatabaseModels/OnCallDutyPolicyOwnerTeam";
+import OnCallDutyPolicyOwnerRuleService from "./OnCallDutyPolicyOwnerRuleService";
+import OnCallDutyPolicyOwnerUserService from "./OnCallDutyPolicyOwnerUserService";
+import OnCallDutyPolicyOwnerTeamService from "./OnCallDutyPolicyOwnerTeamService";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class OnCallDutyPolicyOwnerRuleEngineServiceClass {
+  @CaptureSpan()
+  public async applyRulesToOnCallDutyPolicy(
+    onCallDutyPolicy: OnCallDutyPolicy,
+  ): Promise<void> {
+    if (!onCallDutyPolicy.id || !onCallDutyPolicy.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<OnCallDutyPolicyOwnerRule> =
+        await OnCallDutyPolicyOwnerRuleService.findBy({
+          query: {
+            projectId: onCallDutyPolicy.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            onCallDutyPolicyLabels: { _id: true },
+            onCallDutyPolicyNamePattern: true,
+            onCallDutyPolicyDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const policyWithDetails: OnCallDutyPolicy | null =
+        await OnCallDutyPolicyService.findOneById({
+          id: onCallDutyPolicy.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!policyWithDetails) {
+        return;
+      }
+
+      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<OnCallDutyPolicyOwnerRule> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesPolicyMatchRule(
+          policyWithDetails,
+          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;
+          }
+        }
+        if (ruleAddedAny) {
+          matchedRules.push(rule);
+        }
+      }
+
+      if (matchedRules.length === 0) {
+        return;
+      }
+
+      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: OnCallDutyPolicyOwnerUser =
+            new OnCallDutyPolicyOwnerUser();
+          owner.onCallDutyPolicyId = onCallDutyPolicy.id;
+          owner.projectId = onCallDutyPolicy.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await OnCallDutyPolicyOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: OnCallDutyPolicyOwnerTeam =
+            new OnCallDutyPolicyOwnerTeam();
+          owner.onCallDutyPolicyId = onCallDutyPolicy.id;
+          owner.projectId = onCallDutyPolicy.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await OnCallDutyPolicyOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+
+      logger.debug(
+        `OnCallDutyPolicyOwnerRuleEngine added owners to policy ${onCallDutyPolicy.id}`,
+        { projectId: onCallDutyPolicy.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying on-call duty policy owner rules: ${error}`, {
+        projectId: onCallDutyPolicy.projectId?.toString(),
+        onCallDutyPolicyId: onCallDutyPolicy.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesPolicyMatchRule(
+    policy: OnCallDutyPolicy,
+    rule: OnCallDutyPolicyOwnerRule,
+  ): boolean {
+    if (rule.onCallDutyPolicyLabels && rule.onCallDutyPolicyLabels.length > 0) {
+      if (!policy.labels || policy.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.onCallDutyPolicyLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = policy.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.onCallDutyPolicyNamePattern &&
+      (!policy.name ||
+        !this.testRegex(rule.onCallDutyPolicyNamePattern, policy.name, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.onCallDutyPolicyDescriptionPattern &&
+      (!policy.description ||
+        !this.testRegex(
+          rule.onCallDutyPolicyDescriptionPattern,
+          policy.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: OnCallDutyPolicyOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in on-call duty policy owner rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new OnCallDutyPolicyOwnerRuleEngineServiceClass();

package/Server/Services/OnCallDutyPolicyOwnerRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/OnCallDutyPolicyOwnerRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/OnCallDutyPolicyScheduleLabelRuleEngineService.ts

@@ -0,0 +1,200 @@
+import Label from "../../Models/DatabaseModels/Label";
+import OnCallDutyPolicySchedule from "../../Models/DatabaseModels/OnCallDutyPolicySchedule";
+import OnCallDutyPolicyScheduleLabelRule from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLabelRule";
+import OnCallDutyPolicyScheduleLabelRuleService from "./OnCallDutyPolicyScheduleLabelRuleService";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class OnCallDutyPolicyScheduleLabelRuleEngineServiceClass {
+  @CaptureSpan()
+  public async applyRulesToSchedule(
+    schedule: OnCallDutyPolicySchedule,
+  ): Promise<void> {
+    if (!schedule.id || !schedule.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<OnCallDutyPolicyScheduleLabelRule> =
+        await OnCallDutyPolicyScheduleLabelRuleService.findBy({
+          query: {
+            projectId: schedule.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            onCallDutyPolicyScheduleLabels: { _id: true },
+            onCallDutyPolicyScheduleNamePattern: true,
+            onCallDutyPolicyScheduleDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const scheduleWithDetails: OnCallDutyPolicySchedule | null =
+        await OnCallDutyPolicyScheduleService.findOneById({
+          id: schedule.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!scheduleWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesScheduleMatchRule(
+          scheduleWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        for (const label of rule.labelsToAdd || []) {
+          if (label.id) {
+            labelIdsToAdd.add(label.id.toString());
+          }
+        }
+      }
+
+      if (labelIdsToAdd.size === 0) {
+        return;
+      }
+
+      const existingLabelIds: Set<string> = new Set(
+        (scheduleWithDetails.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;
+      }
+
+      await OnCallDutyPolicyScheduleService.getRepository()
+        .createQueryBuilder()
+        .relation(OnCallDutyPolicySchedule, "labels")
+        .of(schedule.id.toString())
+        .add(newLabelIds);
+
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      schedule.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
+      logger.debug(
+        `OnCallDutyPolicyScheduleLabelRuleEngine attached ${newLabelIds.length} labels to schedule ${schedule.id}`,
+        { projectId: schedule.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(
+        `Error applying on-call duty schedule label rules: ${error}`,
+        {
+          projectId: schedule.projectId?.toString(),
+          onCallDutyPolicyScheduleId: schedule.id?.toString(),
+        } as LogAttributes,
+      );
+    }
+  }
+
+  private doesScheduleMatchRule(
+    schedule: OnCallDutyPolicySchedule,
+    rule: OnCallDutyPolicyScheduleLabelRule,
+  ): boolean {
+    if (
+      rule.onCallDutyPolicyScheduleLabels &&
+      rule.onCallDutyPolicyScheduleLabels.length > 0
+    ) {
+      if (!schedule.labels || schedule.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> =
+        rule.onCallDutyPolicyScheduleLabels.map((l: Label) => {
+          return l.id?.toString() || "";
+        });
+      const labelIds: Array<string> = schedule.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.onCallDutyPolicyScheduleNamePattern &&
+      (!schedule.name ||
+        !this.testRegex(
+          rule.onCallDutyPolicyScheduleNamePattern,
+          schedule.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.onCallDutyPolicyScheduleDescriptionPattern &&
+      (!schedule.description ||
+        !this.testRegex(
+          rule.onCallDutyPolicyScheduleDescriptionPattern,
+          schedule.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: OnCallDutyPolicyScheduleLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in on-call duty schedule label rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new OnCallDutyPolicyScheduleLabelRuleEngineServiceClass();

package/Server/Services/OnCallDutyPolicyScheduleLabelRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLabelRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();