@oneuptime/common 10.2.18 → 10.2.20

package/Server/Services/ScheduledMaintenanceOwnerRuleEngineService.ts

@@ -0,0 +1,545 @@
+import Label from "../../Models/DatabaseModels/Label";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import MonitorOwnerTeam from "../../Models/DatabaseModels/MonitorOwnerTeam";
+import MonitorOwnerUser from "../../Models/DatabaseModels/MonitorOwnerUser";
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceOwnerRule from "../../Models/DatabaseModels/ScheduledMaintenanceOwnerRule";
+import Team from "../../Models/DatabaseModels/Team";
+import User from "../../Models/DatabaseModels/User";
+import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
+import MonitorOwnerUserService from "./MonitorOwnerUserService";
+import MonitorService from "./MonitorService";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import ScheduledMaintenanceOwnerRuleService from "./ScheduledMaintenanceOwnerRuleService";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
+import TeamService from "./TeamService";
+import UserService from "./UserService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Indigo500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import QueryHelper from "../Types/Database/QueryHelper";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class ScheduledMaintenanceOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates ScheduledMaintenanceOwnerRule rows for the given event and adds
+   * matched owner users / teams via ScheduledMaintenanceService.addOwners.
+   * Rules with notifyOwners set notify the added owners; rules with
+   * notifyOwners off add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToScheduledMaintenance(
+    scheduledMaintenance: ScheduledMaintenance,
+  ): Promise<void> {
+    if (!scheduledMaintenance.id || !scheduledMaintenance.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<ScheduledMaintenanceOwnerRule> =
+        await ScheduledMaintenanceOwnerRuleService.findBy({
+          query: {
+            projectId: scheduledMaintenance.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            monitors: { _id: true },
+            scheduledMaintenanceLabels: { _id: true },
+            monitorLabels: { _id: true },
+            titlePattern: true,
+            descriptionPattern: true,
+            monitorNamePattern: true,
+            monitorDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+            inheritOwnersFromMonitors: true,
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        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<ScheduledMaintenanceOwnerRule> = [];
+      const allUserIds: Set<string> = new Set();
+      const allTeamIds: Set<string> = new Set();
+      let inheritFromMonitors: boolean = false;
+      const inheritNotifyMode: { value: boolean | null } = { value: null };
+
+      for (const rule of rules) {
+        const matches: boolean = await this.doesScheduledMaintenanceMatchRule(
+          scheduledMaintenance,
+          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());
+            allUserIds.add(user.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        for (const team of rule.ownerTeams || []) {
+          if (team.id) {
+            teamsByNotify.get(notify)!.add(team.id.toString());
+            allTeamIds.add(team.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        if (rule.inheritOwnersFromMonitors) {
+          inheritFromMonitors = true;
+          ruleAddedAny = true;
+          inheritNotifyMode.value =
+            inheritNotifyMode.value === true ? true : notify;
+        }
+        if (ruleAddedAny) {
+          matchedRules.push(rule);
+        }
+      }
+
+      const inheritedFromMonitorUserIds: Set<string> = new Set();
+      const inheritedFromMonitorTeamIds: Set<string> = new Set();
+
+      if (inheritFromMonitors && scheduledMaintenance.monitors?.length) {
+        const monitorIds: Array<ObjectID> = scheduledMaintenance.monitors
+          .map((m: Monitor) => {
+            return m.id;
+          })
+          .filter((id: ObjectID | null | undefined): id is ObjectID => {
+            return Boolean(id);
+          });
+        if (monitorIds.length > 0) {
+          const [monitorOwnerUsers, monitorOwnerTeams]: [
+            Array<MonitorOwnerUser>,
+            Array<MonitorOwnerTeam>,
+          ] = await Promise.all([
+            MonitorOwnerUserService.findBy({
+              query: { monitorId: QueryHelper.any(monitorIds) },
+              select: { userId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+            MonitorOwnerTeamService.findBy({
+              query: { monitorId: QueryHelper.any(monitorIds) },
+              select: { teamId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+          ]);
+          for (const ownerUser of monitorOwnerUsers) {
+            if (ownerUser.userId) {
+              inheritedFromMonitorUserIds.add(ownerUser.userId.toString());
+            }
+          }
+          for (const ownerTeam of monitorOwnerTeams) {
+            if (ownerTeam.teamId) {
+              inheritedFromMonitorTeamIds.add(ownerTeam.teamId.toString());
+            }
+          }
+        }
+      }
+
+      if (
+        inheritedFromMonitorUserIds.size > 0 ||
+        inheritedFromMonitorTeamIds.size > 0
+      ) {
+        const inheritNotify: boolean = inheritNotifyMode.value === true;
+        for (const id of inheritedFromMonitorUserIds) {
+          usersByNotify.get(inheritNotify)!.add(id);
+          allUserIds.add(id);
+        }
+        for (const id of inheritedFromMonitorTeamIds) {
+          teamsByNotify.get(inheritNotify)!.add(id);
+          allTeamIds.add(id);
+        }
+      }
+
+      if (matchedRules.length === 0) {
+        return;
+      }
+
+      if (allUserIds.size === 0 && allTeamIds.size === 0) {
+        return;
+      }
+
+      for (const notify of [true, false]) {
+        const userIds: Array<ObjectID> = Array.from(
+          usersByNotify.get(notify)!,
+        ).map((id: string) => {
+          return new ObjectID(id);
+        });
+        const teamIds: Array<ObjectID> = Array.from(
+          teamsByNotify.get(notify)!,
+        ).map((id: string) => {
+          return new ObjectID(id);
+        });
+
+        if (userIds.length === 0 && teamIds.length === 0) {
+          continue;
+        }
+
+        await ScheduledMaintenanceService.addOwners(
+          scheduledMaintenance.projectId,
+          scheduledMaintenance.id,
+          userIds,
+          teamIds,
+          notify,
+          { isRoot: true },
+        );
+      }
+
+      logger.debug(
+        `ScheduledMaintenanceOwnerRuleEngine added owners to event ${scheduledMaintenance.id}`,
+        {
+          projectId: scheduledMaintenance.projectId.toString(),
+        } as LogAttributes,
+      );
+
+      await this.createRuleExecutedFeedItem({
+        scheduledMaintenance,
+        matchedRules,
+        userIds: Array.from(allUserIds),
+        teamIds: Array.from(allTeamIds),
+        inheritedFromMonitors:
+          inheritedFromMonitorUserIds.size + inheritedFromMonitorTeamIds.size >
+          0,
+      });
+    } catch (error) {
+      logger.error(
+        `Error applying scheduled maintenance owner rules: ${error}`,
+        {
+          projectId: scheduledMaintenance.projectId?.toString(),
+          scheduledMaintenanceId: scheduledMaintenance.id?.toString(),
+        } as LogAttributes,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  private async createRuleExecutedFeedItem(data: {
+    scheduledMaintenance: ScheduledMaintenance;
+    matchedRules: Array<ScheduledMaintenanceOwnerRule>;
+    userIds: Array<string>;
+    teamIds: Array<string>;
+    inheritedFromMonitors: boolean;
+  }): Promise<void> {
+    const {
+      scheduledMaintenance,
+      matchedRules,
+      userIds,
+      teamIds,
+      inheritedFromMonitors,
+    } = data;
+    if (
+      !scheduledMaintenance.id ||
+      !scheduledMaintenance.projectId ||
+      matchedRules.length === 0 ||
+      (userIds.length === 0 && teamIds.length === 0)
+    ) {
+      return;
+    }
+
+    try {
+      const userObjectIds: Array<ObjectID> = userIds.map((id: string) => {
+        return new ObjectID(id);
+      });
+      const teamObjectIds: Array<ObjectID> = teamIds.map((id: string) => {
+        return new ObjectID(id);
+      });
+
+      const [users, teams]: [Array<User>, Array<Team>] = await Promise.all([
+        userObjectIds.length > 0
+          ? UserService.findBy({
+              query: { _id: QueryHelper.any(userObjectIds) },
+              select: { name: true, email: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            })
+          : Promise.resolve([] as Array<User>),
+        teamObjectIds.length > 0
+          ? TeamService.findBy({
+              query: { _id: QueryHelper.any(teamObjectIds) },
+              select: { name: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            })
+          : Promise.resolve([] as Array<Team>),
+      ]);
+
+      const userLines: Array<string> = users.map((u: User) => {
+        const display: string =
+          u.name?.toString() || u.email?.toString() || "Unknown User";
+        return `\n- 👤 ${display}`;
+      });
+      const teamLines: Array<string> = teams.map((t: Team) => {
+        return `\n- 👥 ${t.name?.toString() || "Unnamed Team"}`;
+      });
+
+      const ruleNames: Array<string> = matchedRules
+        .map((r: ScheduledMaintenanceOwnerRule) => {
+          return r.name?.toString() || "Unnamed Rule";
+        })
+        .filter((n: string) => {
+          return n !== "";
+        });
+
+      const rulesPart: string =
+        ruleNames.length === 1
+          ? `**${ruleNames[0]}**`
+          : ruleNames
+              .map((n: string) => {
+                return `**${n}**`;
+              })
+              .join(", ");
+
+      const ownersPart: string =
+        userLines.length + teamLines.length > 0
+          ? userLines.concat(teamLines).join("")
+          : "\n- (no named owners)";
+
+      const inheritedNote: string = inheritedFromMonitors
+        ? `\n\n_Some owners were inherited from the event's monitors._`
+        : "";
+
+      const feedInfoInMarkdown: string = `🛡️ **Scheduled Maintenance Owner Rule${
+        matchedRules.length > 1 ? "s" : ""
+      } executed:** ${rulesPart}\n\nAssigned the following owner${
+        userLines.length + teamLines.length === 1 ? "" : "s"
+      } to the event:${ownersPart}${inheritedNote}`;
+
+      await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
+        scheduledMaintenanceId: scheduledMaintenance.id,
+        projectId: scheduledMaintenance.projectId,
+        scheduledMaintenanceFeedEventType:
+          ScheduledMaintenanceFeedEventType.OwnerRuleExecuted,
+        displayColor: Indigo500,
+        feedInfoInMarkdown,
+      });
+    } catch (error) {
+      logger.error(
+        `ScheduledMaintenanceOwnerRuleEngine: failed to create rule-executed feed item: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        {
+          projectId: scheduledMaintenance.projectId?.toString(),
+          scheduledMaintenanceId: scheduledMaintenance.id?.toString(),
+        } as LogAttributes,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  private async doesScheduledMaintenanceMatchRule(
+    scheduledMaintenance: ScheduledMaintenance,
+    rule: ScheduledMaintenanceOwnerRule,
+  ): Promise<boolean> {
+    if (rule.monitors && rule.monitors.length > 0) {
+      if (
+        !scheduledMaintenance.monitors ||
+        scheduledMaintenance.monitors.length === 0
+      ) {
+        return false;
+      }
+      const ruleMonitorIds: Array<string> = rule.monitors.map((m: Monitor) => {
+        return m.id?.toString() || "";
+      });
+      const eventMonitorIds: Array<string> = scheduledMaintenance.monitors.map(
+        (m: Monitor) => {
+          return m.id?.toString() || "";
+        },
+      );
+      if (
+        !ruleMonitorIds.some((id: string) => {
+          return eventMonitorIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.scheduledMaintenanceLabels &&
+      rule.scheduledMaintenanceLabels.length > 0
+    ) {
+      if (
+        !scheduledMaintenance.labels ||
+        scheduledMaintenance.labels.length === 0
+      ) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.scheduledMaintenanceLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const eventLabelIds: Array<string> = scheduledMaintenance.labels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return eventLabelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    const hasMonitorCriteria: boolean = Boolean(
+      (rule.monitorLabels && rule.monitorLabels.length > 0) ||
+        rule.monitorNamePattern ||
+        rule.monitorDescriptionPattern,
+    );
+
+    if (hasMonitorCriteria) {
+      if (
+        !scheduledMaintenance.monitors ||
+        scheduledMaintenance.monitors.length === 0
+      ) {
+        return false;
+      }
+
+      let anyMonitorMatches: boolean = false;
+      for (const eventMonitor of scheduledMaintenance.monitors) {
+        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 },
+        });
+        if (!monitor) {
+          continue;
+        }
+
+        let monitorMatches: boolean = true;
+
+        if (rule.monitorLabels && rule.monitorLabels.length > 0) {
+          if (!monitor.labels || monitor.labels.length === 0) {
+            monitorMatches = false;
+          } else {
+            const ruleMonitorLabelIds: Array<string> = rule.monitorLabels.map(
+              (l: Label) => {
+                return l.id?.toString() || "";
+              },
+            );
+            const monitorLabelIds: Array<string> = monitor.labels.map(
+              (l: Label) => {
+                return l.id?.toString() || "";
+              },
+            );
+            if (
+              !ruleMonitorLabelIds.some((id: string) => {
+                return monitorLabelIds.includes(id);
+              })
+            ) {
+              monitorMatches = false;
+            }
+          }
+        }
+
+        if (
+          monitorMatches &&
+          rule.monitorNamePattern &&
+          (!monitor.name ||
+            !this.testRegex(rule.monitorNamePattern, monitor.name, rule))
+        ) {
+          monitorMatches = false;
+        }
+
+        if (
+          monitorMatches &&
+          rule.monitorDescriptionPattern &&
+          (!monitor.description ||
+            !this.testRegex(
+              rule.monitorDescriptionPattern,
+              monitor.description,
+              rule,
+            ))
+        ) {
+          monitorMatches = false;
+        }
+
+        if (monitorMatches) {
+          anyMonitorMatches = true;
+          break;
+        }
+      }
+
+      if (!anyMonitorMatches) {
+        return false;
+      }
+    }
+
+    if (
+      rule.titlePattern &&
+      (!scheduledMaintenance.title ||
+        !this.testRegex(rule.titlePattern, scheduledMaintenance.title, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.descriptionPattern &&
+      (!scheduledMaintenance.description ||
+        !this.testRegex(
+          rule.descriptionPattern,
+          scheduledMaintenance.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: ScheduledMaintenanceOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in scheduled maintenance owner rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new ScheduledMaintenanceOwnerRuleEngineServiceClass();

package/Server/Services/ScheduledMaintenanceOwnerRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ScheduledMaintenanceOwnerRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -49,6 +49,8 @@ import Protocol from "../../Types/API/Protocol";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import ScheduledMaintenanceLabelRuleEngineService from "./ScheduledMaintenanceLabelRuleEngineService";
+import ScheduledMaintenanceOwnerRuleEngineService from "./ScheduledMaintenanceOwnerRuleEngineService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import StatusPageSubscriberWebhookUtil from "../Utils/StatusPageSubscriberWebhook";
@@ -935,6 +937,38 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
           return Promise.resolve();
         }
       })
+      .then(async () => {
+        // Apply owner rules: add matched owner users/teams to the event.
+        try {
+          await ScheduledMaintenanceOwnerRuleEngineService.applyRulesToScheduledMaintenance(
+            createdItem,
+          );
+        } catch (error) {
+          logger.error(
+            `Apply scheduled maintenance owner rules failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              scheduledMaintenanceId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
+      .then(async () => {
+        // Apply label rules: attach matched (and optionally inherited monitor) labels to the event.
+        try {
+          await ScheduledMaintenanceLabelRuleEngineService.applyRulesToScheduledMaintenance(
+            createdItem,
+          );
+        } catch (error) {
+          logger.error(
+            `Apply scheduled maintenance label rules failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              scheduledMaintenanceId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in ScheduledMaintenanceService sequential operations: ${error}`,

package/Types/Call/CallRequest.ts

@@ -31,13 +31,37 @@ export default interface CallRequest extends CallRequestMessage {
 
 type IsHighRiskPhoneNumberFunction = (phoneNumber: Phone) => boolean;
 
+/*
+ * Country dialing codes flagged as high-risk for IRSF / SMS pumping fraud.
+ * Twilio surfaces its current list dynamically in the Console; this set is
+ * drawn from publicly reported fraud patterns and should be reviewed
+ * periodically against Twilio Geo Permissions and Fraud Guard.
+ */
+const HIGH_RISK_COUNTRY_DIALING_CODES: Array<string> = [
+  "+92", // Pakistan
+  "+27", // South Africa
+  "+213", // Algeria
+  "+371", // Latvia
+  "+370", // Lithuania
+  "+372", // Estonia
+  "+252", // Somalia
+  "+232", // Sierra Leone
+  "+231", // Liberia
+  "+53", // Cuba
+  "+960", // Maldives
+  "+992", // Tajikistan
+  "+880", // Bangladesh
+  "+62", // Indonesia
+  "+84", // Vietnam
+  "+95", // Myanmar
+];
+
 export const isHighRiskPhoneNumber: IsHighRiskPhoneNumberFunction = (
   phoneNumber: Phone,
 ): boolean => {
-  // Pakistan
-  if (phoneNumber.toString().startsWith("+92")) {
-    return true;
-  }
+  const phoneNumberString: string = phoneNumber.toString();
 
-  return false;
+  return HIGH_RISK_COUNTRY_DIALING_CODES.some((code: string) => {
+    return phoneNumberString.startsWith(code);
+  });
 };

package/Types/Docs/DocsLanguage.ts

@@ -0,0 +1,36 @@
+export interface DocsLanguage {
+  code: string;
+  nativeName: string;
+  englishName: string;
+}
+
+export const DEFAULT_DOCS_LANGUAGE: string = "en";
+
+export const SUPPORTED_DOCS_LANGUAGES: Array<DocsLanguage> = [
+  { code: "en", nativeName: "English", englishName: "English" },
+  { code: "de", nativeName: "Deutsch", englishName: "German" },
+  { code: "fr", nativeName: "Français", englishName: "French" },
+  { code: "es", nativeName: "Español", englishName: "Spanish" },
+  { code: "it", nativeName: "Italiano", englishName: "Italian" },
+  { code: "pt", nativeName: "Português", englishName: "Portuguese" },
+  { code: "nl", nativeName: "Nederlands", englishName: "Dutch" },
+  { code: "da", nativeName: "Dansk", englishName: "Danish" },
+  { code: "no", nativeName: "Norsk", englishName: "Norwegian" },
+  { code: "sv", nativeName: "Svenska", englishName: "Swedish" },
+  { code: "ru", nativeName: "Русский", englishName: "Russian" },
+  { code: "ja", nativeName: "日本語", englishName: "Japanese" },
+  { code: "ko", nativeName: "한국어", englishName: "Korean" },
+  { code: "zh", nativeName: "中文", englishName: "Chinese" },
+  { code: "hi", nativeName: "हिन्दी", englishName: "Hindi" },
+];
+
+export const SUPPORTED_DOCS_LANGUAGE_CODES: Array<string> =
+  SUPPORTED_DOCS_LANGUAGES.map((language: DocsLanguage) => {
+    return language.code;
+  });
+
+export const isSupportedDocsLanguage: (code: string) => boolean = (
+  code: string,
+): boolean => {
+  return SUPPORTED_DOCS_LANGUAGE_CODES.includes(code);
+};