@oneuptime/common 12.0.25 → 12.0.27

package/Server/Services/HostFeedService.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 HostFeed, {
+  HostFeedEventType,
+} from "../../Models/DatabaseModels/HostFeed";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<HostFeed> {
+  public constructor() {
+    super(HostFeed);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createHostFeedItem(data: {
+    hostId: ObjectID;
+    feedInfoInMarkdown: string;
+    hostFeedEventType: HostFeedEventType;
+    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: HostFeed = new HostFeed();
+
+      if (!data.hostId) {
+        throw new BadDataException("Host ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.hostFeedEventType) {
+        throw new BadDataException("Host 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.hostId = data.hostId;
+      feed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      feed.hostFeedEventType = data.hostFeedEventType;
+      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 host feed", {
+        projectId: data.projectId?.toString(),
+        hostId: data.hostId?.toString(),
+      } as LogAttributes);
+      logger.error(e, {
+        projectId: data.projectId?.toString(),
+        hostId: data.hostId?.toString(),
+      } as LogAttributes);
+
+      // we dont throw this error as it is not a critical error
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/HostLabelRuleEngineService.ts

@@ -3,6 +3,9 @@ import Host from "../../Models/DatabaseModels/Host";
 import HostLabelRule from "../../Models/DatabaseModels/HostLabelRule";
 import HostLabelRuleService from "./HostLabelRuleService";
 import HostService from "./HostService";
+import HostFeedService from "./HostFeedService";
+import { HostFeedEventType } from "../../Models/DatabaseModels/HostFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -57,12 +60,18 @@ class HostLabelRuleEngineServiceClass {
       }
 
       const labelIdsToAdd: Set<string> = new Set();
+      const matchedRuleNames: Array<string> = [];
 
       for (const rule of rules) {
         const matches: boolean = this.doesHostMatchRule(hostWithDetails, 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());
@@ -117,6 +126,26 @@ class HostLabelRuleEngineServiceClass {
         `HostLabelRuleEngine attached ${newLabelIds.length} labels to host ${host.id}`,
         { projectId: host.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 HostFeedService.createHostFeedItem({
+        hostId: host.id,
+        projectId: host.projectId,
+        hostFeedEventType: HostFeedEventType.LabelRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `🏷️ ${newLabelIds.length} label(s) were attached to ${await HostService.getHostMarkdownLink(
+          host.projectId,
+          host.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 host label rules: ${error}`, {
         projectId: host.projectId?.toString(),

package/Server/Services/HostOwnerRuleEngineService.ts

@@ -7,6 +7,9 @@ import HostOwnerRuleService from "./HostOwnerRuleService";
 import HostOwnerUserService from "./HostOwnerUserService";
 import HostOwnerTeamService from "./HostOwnerTeamService";
 import HostService from "./HostService";
+import HostFeedService from "./HostFeedService";
+import { HostFeedEventType } from "../../Models/DatabaseModels/HostFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -134,6 +137,26 @@ class HostOwnerRuleEngineServiceClass {
       logger.debug(`HostOwnerRuleEngine added owners to host ${host.id}`, {
         projectId: host.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 HostFeedService.createHostFeedItem({
+        hostId: host.id,
+        projectId: host.projectId,
+        hostFeedEventType: HostFeedEventType.OwnerRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `👥 Owners were added to ${await HostService.getHostMarkdownLink(
+          host.projectId,
+          host.id,
+        )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
+          .map((rule: HostOwnerRule) => {
+            return `\`${rule.name || rule.id?.toString() || "Unnamed rule"}\``;
+          })
+          .join(", ")}`,
+      });
     } catch (error) {
       logger.error(`Error applying host owner rules: ${error}`, {
         projectId: host.projectId?.toString(),

package/Server/Services/HostOwnerTeamService.ts

@@ -1,10 +1,139 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/HostOwnerTeam";
+import HostFeedService from "./HostFeedService";
+import { HostFeedEventType } from "../../Models/DatabaseModels/HostFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import Team from "../../Models/DatabaseModels/Team";
+import TeamService from "./TeamService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import HostService from "./HostService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    /*
+     * The rows are gone by the time onDeleteSuccess runs, so the feed item has
+     * to be built from what was read here.
+     */
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        hostId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Array<Model> = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const hostId: ObjectID | undefined = item.hostId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (!hostId || !projectId || !teamId) {
+        continue;
+      }
+
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!team || !team.name) {
+        continue;
+      }
+
+      await HostFeedService.createHostFeedItem({
+        hostId: hostId,
+        projectId: projectId,
+        hostFeedEventType: HostFeedEventType.OwnerTeamRemoved,
+        displayColor: Red500,
+        feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** as an owner of ${await HostService.getHostMarkdownLink(
+          projectId,
+          hostId,
+        )}.`,
+        userId: deletedByUserId || undefined,
+      });
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const hostId: ObjectID | undefined = createdItem.hostId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (hostId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await HostFeedService.createHostFeedItem({
+          hostId: hostId,
+          projectId: projectId,
+          hostFeedEventType: HostFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** as an owner of ${await HostService.getHostMarkdownLink(
+            projectId,
+            hostId,
+          )}.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/HostOwnerUserService.ts

@@ -1,10 +1,133 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/HostOwnerUser";
+import HostFeedService from "./HostFeedService";
+import { HostFeedEventType } from "../../Models/DatabaseModels/HostFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import User from "../../Models/DatabaseModels/User";
+import UserService from "./UserService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import HostService from "./HostService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    /*
+     * The rows are gone by the time onDeleteSuccess runs, so the feed item has
+     * to be built from what was read here.
+     */
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        hostId: true,
+        projectId: true,
+        userId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Array<Model> = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const hostId: ObjectID | undefined = item.hostId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (!hostId || !projectId || !userId) {
+        continue;
+      }
+
+      const user: User | null = await UserService.findOneById({
+        id: userId,
+        select: {
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!user || !user.name) {
+        continue;
+      }
+
+      await HostFeedService.createHostFeedItem({
+        hostId: hostId,
+        projectId: projectId,
+        hostFeedEventType: HostFeedEventType.OwnerUserRemoved,
+        displayColor: Red500,
+        feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) as an owner of ${await HostService.getHostMarkdownLink(
+          projectId,
+          hostId,
+        )}.`,
+        userId: deletedByUserId || undefined,
+      });
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const hostId: ObjectID | undefined = createdItem.hostId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (hostId && userId && projectId) {
+      await HostFeedService.createHostFeedItem({
+        hostId: hostId,
+        projectId: projectId,
+        hostFeedEventType: HostFeedEventType.OwnerUserAdded,
+        displayColor: Gray500,
+        feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+          {
+            userId: userId,
+            projectId: projectId,
+          },
+        )}** as an owner of ${await HostService.getHostMarkdownLink(
+          projectId,
+          hostId,
+        )}.`,
+        userId: createdByUserId || undefined,
+      });
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();