@oneuptime/common 12.0.34 → 13.0.1

package/Server/Services/VMwareVCenterFeedService.ts

@@ -0,0 +1,99 @@
+import { Blue500 } from "../../Types/BrandColors";
+import Color from "../../Types/Color";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger, { LogAttributes } from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import VMwareVCenterFeed, {
+  VMwareVCenterFeedEventType,
+} from "../../Models/DatabaseModels/VMwareVCenterFeed";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<VMwareVCenterFeed> {
+  public constructor() {
+    super(VMwareVCenterFeed);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createVMwareVCenterFeedItem(data: {
+    vmwareVCenterId: ObjectID;
+    feedInfoInMarkdown: string;
+    vmwareVCenterFeedEventType: VMwareVCenterFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<void> {
+    /*
+     * A feed item is a side effect of the thing that actually happened. It must
+     * never be able to fail the write it is describing, so everything here is
+     * swallowed and logged rather than thrown - same contract as
+     * MonitorFeedService.
+     */
+    try {
+      const feed: VMwareVCenterFeed = new VMwareVCenterFeed();
+
+      if (!data.vmwareVCenterId) {
+        throw new BadDataException("vCenter ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.vmwareVCenterFeedEventType) {
+        throw new BadDataException("vCenter feed event is required");
+      }
+
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
+
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
+
+      feed.displayColor = data.displayColor;
+      feed.vmwareVCenterId = data.vmwareVCenterId;
+      feed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      feed.vmwareVCenterFeedEventType = data.vmwareVCenterFeedEventType;
+      feed.projectId = data.projectId;
+      feed.postedAt = data.postedAt || OneUptimeDate.getCurrentDate();
+
+      if (data.userId) {
+        feed.userId = data.userId;
+      }
+
+      if (data.moreInformationInMarkdown) {
+        feed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+      }
+
+      await this.create({
+        data: feed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (e) {
+      logger.error("Error in creating vCenter feed", {
+        projectId: data.projectId?.toString(),
+        vmwareVCenterId: data.vmwareVCenterId?.toString(),
+      } as LogAttributes);
+      logger.error(e, {
+        projectId: data.projectId?.toString(),
+        vmwareVCenterId: data.vmwareVCenterId?.toString(),
+      } as LogAttributes);
+
+      // we dont throw this error as it is not a critical error
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/VMwareVCenterLabelRuleEngineService.ts

@@ -0,0 +1,240 @@
+import Label from "../../Models/DatabaseModels/Label";
+import VMwareVCenter from "../../Models/DatabaseModels/VMwareVCenter";
+import VMwareVCenterLabelRule from "../../Models/DatabaseModels/VMwareVCenterLabelRule";
+import VMwareVCenterLabelRuleService from "./VMwareVCenterLabelRuleService";
+import VMwareVCenterService from "./VMwareVCenterService";
+import VMwareVCenterFeedService from "./VMwareVCenterFeedService";
+import { VMwareVCenterFeedEventType } from "../../Models/DatabaseModels/VMwareVCenterFeed";
+import { Purple500 } from "../../Types/BrandColors";
+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 logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+
+class VMwareVCenterLabelRuleEngineServiceClass {
+  /**
+   * Evaluates VMwareVCenterLabelRule rows for the given vCenter and attaches
+   * matched labels to it. The union is deduped against labels already on the
+   * vCenter before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToVMwareVCenter(
+    vmwareVCenter: VMwareVCenter,
+  ): Promise<void> {
+    if (!vmwareVCenter.id || !vmwareVCenter.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<VMwareVCenterLabelRule> =
+        await VMwareVCenterLabelRuleService.findBy({
+          query: {
+            projectId: vmwareVCenter.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            vmwareVCenterLabels: { _id: true },
+            vmwareVCenterNamePattern: true,
+            vmwareVCenterDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: MAX_RULES_EVALUATED_PER_PROJECT,
+          skip: 0,
+        });
+
+      logIfRuleReadWasTruncated({
+        ruleKind: "VMwareVCenterLabelRule",
+        projectId: vmwareVCenter.projectId,
+        rulesRead: rules.length,
+      });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const vmwareVCenterWithDetails: VMwareVCenter | null =
+        await VMwareVCenterService.findOneById({
+          id: vmwareVCenter.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!vmwareVCenterWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+      const matchedRuleNames: Array<string> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesVMwareVCenterMatchRule(
+          vmwareVCenterWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        if ((rule.labelsToAdd || []).length > 0) {
+          matchedRuleNames.push(
+            rule.name || rule.id?.toString() || "Unnamed rule",
+          );
+        }
+        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(
+        (vmwareVCenterWithDetails.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 VMwareVCenterService.getRepository()
+        .createQueryBuilder()
+        .relation(VMwareVCenter, "labels")
+        .of(vmwareVCenter.id.toString())
+        .add(newLabelIds);
+
+      /*
+       * Sync in-memory vmwareVCenter.labels 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,
+      ]);
+      vmwareVCenter.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
+      logger.debug(
+        `VMwareVCenterLabelRuleEngine attached ${newLabelIds.length} labels to vCenter ${vmwareVCenter.id}`,
+        { projectId: vmwareVCenter.projectId.toString() } as LogAttributes,
+      );
+      /*
+       * Labels arriving from a rule rather than from a person is exactly the
+       * kind of thing the overview page cannot explain, so record which rules
+       * did it.
+       */
+      await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+        vmwareVCenterId: vmwareVCenter.id,
+        projectId: vmwareVCenter.projectId,
+        vmwareVCenterFeedEventType:
+          VMwareVCenterFeedEventType.LabelRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `🏷️ ${newLabelIds.length} label(s) were attached to ${await VMwareVCenterService.getVMwareVCenterMarkdownLink(
+          vmwareVCenter.projectId,
+          vmwareVCenter.id,
+        )} by label ${matchedRuleNames.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Label rules that matched**: ${matchedRuleNames
+          .map((name: string) => {
+            return `\`${name}\``;
+          })
+          .join(", ")}`,
+      });
+    } catch (error) {
+      logger.error(`Error applying vCenter label rules: ${error}`, {
+        projectId: vmwareVCenter.projectId?.toString(),
+        vmwareVCenterId: vmwareVCenter.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesVMwareVCenterMatchRule(
+    vmwareVCenter: VMwareVCenter,
+    rule: VMwareVCenterLabelRule,
+  ): boolean {
+    if (rule.vmwareVCenterLabels && rule.vmwareVCenterLabels.length > 0) {
+      if (!vmwareVCenter.labels || vmwareVCenter.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.vmwareVCenterLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = vmwareVCenter.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.vmwareVCenterNamePattern &&
+      (!vmwareVCenter.name ||
+        !this.testRegex(
+          rule.vmwareVCenterNamePattern,
+          vmwareVCenter.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.vmwareVCenterDescriptionPattern &&
+      (!vmwareVCenter.description ||
+        !this.testRegex(
+          rule.vmwareVCenterDescriptionPattern,
+          vmwareVCenter.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: VMwareVCenterLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(`Invalid regex in vCenter label rule ${rule.id}: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new VMwareVCenterLabelRuleEngineServiceClass();

package/Server/Services/VMwareVCenterLabelRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/VMwareVCenterLabelRule";
+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/VMwareVCenterOwnerRuleEngineService.ts

@@ -0,0 +1,252 @@
+import Label from "../../Models/DatabaseModels/Label";
+import VMwareVCenter from "../../Models/DatabaseModels/VMwareVCenter";
+import VMwareVCenterOwnerRule from "../../Models/DatabaseModels/VMwareVCenterOwnerRule";
+import VMwareVCenterOwnerUser from "../../Models/DatabaseModels/VMwareVCenterOwnerUser";
+import VMwareVCenterOwnerTeam from "../../Models/DatabaseModels/VMwareVCenterOwnerTeam";
+import VMwareVCenterOwnerRuleService from "./VMwareVCenterOwnerRuleService";
+import VMwareVCenterOwnerUserService from "./VMwareVCenterOwnerUserService";
+import VMwareVCenterOwnerTeamService from "./VMwareVCenterOwnerTeamService";
+import VMwareVCenterService from "./VMwareVCenterService";
+import VMwareVCenterFeedService from "./VMwareVCenterFeedService";
+import { VMwareVCenterFeedEventType } from "../../Models/DatabaseModels/VMwareVCenterFeed";
+import { Purple500 } from "../../Types/BrandColors";
+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 logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+
+class VMwareVCenterOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates VMwareVCenterOwnerRule rows for the given vCenter and adds
+   * matched owner users / teams via VMwareVCenterOwnerUserService /
+   * VMwareVCenterOwnerTeamService. Rules with notifyOwners set notify the
+   * added owners; rules with notifyOwners off add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToVMwareVCenter(
+    vmwareVCenter: VMwareVCenter,
+  ): Promise<void> {
+    if (!vmwareVCenter.id || !vmwareVCenter.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<VMwareVCenterOwnerRule> =
+        await VMwareVCenterOwnerRuleService.findBy({
+          query: {
+            projectId: vmwareVCenter.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            vmwareVCenterLabels: { _id: true },
+            vmwareVCenterNamePattern: true,
+            vmwareVCenterDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+          },
+          limit: MAX_RULES_EVALUATED_PER_PROJECT,
+          skip: 0,
+        });
+
+      logIfRuleReadWasTruncated({
+        ruleKind: "VMwareVCenterOwnerRule",
+        projectId: vmwareVCenter.projectId,
+        rulesRead: rules.length,
+      });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const vmwareVCenterWithDetails: VMwareVCenter | null =
+        await VMwareVCenterService.findOneById({
+          id: vmwareVCenter.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!vmwareVCenterWithDetails) {
+        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<VMwareVCenterOwnerRule> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesVMwareVCenterMatchRule(
+          vmwareVCenterWithDetails,
+          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: VMwareVCenterOwnerUser = new VMwareVCenterOwnerUser();
+          owner.vmwareVCenterId = vmwareVCenter.id;
+          owner.projectId = vmwareVCenter.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await VMwareVCenterOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: VMwareVCenterOwnerTeam = new VMwareVCenterOwnerTeam();
+          owner.vmwareVCenterId = vmwareVCenter.id;
+          owner.projectId = vmwareVCenter.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await VMwareVCenterOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+
+      logger.debug(
+        `VMwareVCenterOwnerRuleEngine added owners to vCenter ${vmwareVCenter.id}`,
+        { projectId: vmwareVCenter.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 VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+        vmwareVCenterId: vmwareVCenter.id,
+        projectId: vmwareVCenter.projectId,
+        vmwareVCenterFeedEventType:
+          VMwareVCenterFeedEventType.OwnerRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `👥 Owners were added to ${await VMwareVCenterService.getVMwareVCenterMarkdownLink(
+          vmwareVCenter.projectId,
+          vmwareVCenter.id,
+        )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
+          .map((rule: VMwareVCenterOwnerRule) => {
+            return `\`${rule.name || rule.id?.toString() || "Unnamed rule"}\``;
+          })
+          .join(", ")}`,
+      });
+    } catch (error) {
+      logger.error(`Error applying vCenter owner rules: ${error}`, {
+        projectId: vmwareVCenter.projectId?.toString(),
+        vmwareVCenterId: vmwareVCenter.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesVMwareVCenterMatchRule(
+    vmwareVCenter: VMwareVCenter,
+    rule: VMwareVCenterOwnerRule,
+  ): boolean {
+    if (rule.vmwareVCenterLabels && rule.vmwareVCenterLabels.length > 0) {
+      if (!vmwareVCenter.labels || vmwareVCenter.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.vmwareVCenterLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = vmwareVCenter.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.vmwareVCenterNamePattern &&
+      (!vmwareVCenter.name ||
+        !this.testRegex(
+          rule.vmwareVCenterNamePattern,
+          vmwareVCenter.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.vmwareVCenterDescriptionPattern &&
+      (!vmwareVCenter.description ||
+        !this.testRegex(
+          rule.vmwareVCenterDescriptionPattern,
+          vmwareVCenter.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: VMwareVCenterOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(`Invalid regex in vCenter owner rule ${rule.id}: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new VMwareVCenterOwnerRuleEngineServiceClass();

package/Server/Services/VMwareVCenterOwnerRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/VMwareVCenterOwnerRule";
+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();