@oneuptime/common 12.0.25 → 12.0.27

package/Server/Services/CephClusterOwnerUserService.ts

@@ -1,10 +1,133 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/CephClusterOwnerUser";
+import CephClusterFeedService from "./CephClusterFeedService";
+import { CephClusterFeedEventType } from "../../Models/DatabaseModels/CephClusterFeed";
+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 CephClusterService from "./CephClusterService";
+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: {
+        cephClusterId: 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 cephClusterId: ObjectID | undefined = item.cephClusterId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (!cephClusterId || !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 CephClusterFeedService.createCephClusterFeedItem({
+        cephClusterId: cephClusterId,
+        projectId: projectId,
+        cephClusterFeedEventType: CephClusterFeedEventType.OwnerUserRemoved,
+        displayColor: Red500,
+        feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) as an owner of ${await CephClusterService.getCephClusterMarkdownLink(
+          projectId,
+          cephClusterId,
+        )}.`,
+        userId: deletedByUserId || undefined,
+      });
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const cephClusterId: ObjectID | undefined = createdItem.cephClusterId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (cephClusterId && userId && projectId) {
+      await CephClusterFeedService.createCephClusterFeedItem({
+        cephClusterId: cephClusterId,
+        projectId: projectId,
+        cephClusterFeedEventType: CephClusterFeedEventType.OwnerUserAdded,
+        displayColor: Gray500,
+        feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+          {
+            userId: userId,
+            projectId: projectId,
+          },
+        )}** as an owner of ${await CephClusterService.getCephClusterMarkdownLink(
+          projectId,
+          cephClusterId,
+        )}.`,
+        userId: createdByUserId || undefined,
+      });
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/CephClusterService.ts

@@ -3,7 +3,14 @@ import CephClusterLabelRuleEngineService from "./CephClusterLabelRuleEngineServi
 import CephClusterOwnerRuleEngineService from "./CephClusterOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/CephCluster";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CephClusterFeedService from "./CephClusterFeedService";
+import { CephClusterFeedEventType } from "../../Models/DatabaseModels/CephClusterFeed";
+import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
+import { Blue500, Gray500, Green500, Yellow500 } from "../../Types/BrandColors";
+import { JSONObject } from "../../Types/JSON";
+import URL from "../../Types/API/URL";
+import DatabaseConfig from "../DatabaseConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import ResourceHeartbeat from "../Utils/Telemetry/ResourceHeartbeat";
 import ObjectID from "../../Types/ObjectID";
@@ -27,7 +34,7 @@ export class Service extends DatabaseService<Model> {
 
   @CaptureSpan()
   protected override async onCreateSuccess(
-    _onCreate: OnCreate<Model>,
+    onCreate: OnCreate<Model>,
     createdItem: Model,
   ): Promise<Model> {
     /*
@@ -57,6 +64,18 @@ export class Service extends DatabaseService<Model> {
           );
         });
     }
+    /*
+     * The overview page can say what this Ceph cluster looks like now; only
+     * the feed can say why it exists at all - whether a person added it or
+     * ingest registered it the first time telemetry named it. Fire and
+     * forget: a feed write must never fail the create it describes.
+     */
+    this.writeCephClusterCreatedFeed(createdItem, onCreate).catch(
+      (error: Error) => {
+        logger.error(error);
+      },
+    );
+
     return createdItem;
   }
 
@@ -383,6 +402,208 @@ export class Service extends DatabaseService<Model> {
       }
     }
   }
+
+  /**
+   * Display name for this Ceph cluster, or an empty string when the row is
+   * gone. Feed writers call this on a best-effort basis, so a missing row must
+   * not throw and take the surrounding write down with it.
+   */
+  @CaptureSpan()
+  public async getCephClusterName(data: {
+    cephClusterId: ObjectID;
+  }): Promise<string> {
+    const cephCluster: Model | null = await this.findOneById({
+      id: data.cephClusterId,
+      select: {
+        name: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return cephCluster?.name || "";
+  }
+
+  @CaptureSpan()
+  public async getCephClusterLinkInDashboard(
+    projectId: ObjectID,
+    cephClusterId: ObjectID,
+  ): Promise<URL> {
+    const dashboardUrl: URL = await DatabaseConfig.getDashboardUrl();
+
+    return URL.fromString(dashboardUrl.toString()).addRoute(
+      `/${projectId.toString()}/ceph/${cephClusterId.toString()}`,
+    );
+  }
+
+  /**
+   * "[Ceph Cluster prod-1](https://…)" - the form every feed item uses to
+   * name the resource it is about.
+   */
+  @CaptureSpan()
+  public async getCephClusterMarkdownLink(
+    projectId: ObjectID,
+    cephClusterId: ObjectID,
+  ): Promise<string> {
+    const name: string = await this.getCephClusterName({
+      cephClusterId: cephClusterId,
+    });
+    const link: URL = await this.getCephClusterLinkInDashboard(
+      projectId,
+      cephClusterId,
+    );
+
+    return `[Ceph Cluster ${name}](${link.toString()})`;
+  }
+
+  private async writeCephClusterCreatedFeed(
+    createdItem: Model,
+    onCreate: OnCreate<Model>,
+  ): Promise<void> {
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const cephClusterId: ObjectID | undefined = createdItem.id || undefined;
+
+    if (!projectId || !cephClusterId) {
+      return;
+    }
+
+    /*
+     * Ingest creates these rows with root props and no acting user; every
+     * dashboard, API and Terraform create carries one. That is the whole
+     * signal for "was this discovered automatically or added by a person".
+     */
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId ||
+      onCreate.createBy.props.userId ||
+      undefined;
+
+    const markdown: {
+      feedInfoInMarkdown: string;
+      moreInformationInMarkdown: string;
+    } = await ResourceFeedUtil.getCreatedFeedMarkdown({
+      resourceTypeName: "Ceph cluster",
+      resourceMarkdownLink: await this.getCephClusterMarkdownLink(
+        projectId,
+        cephClusterId,
+      ),
+      projectId: projectId,
+      createdByUserId: createdByUserId,
+      description: createdItem.description,
+    });
+
+    await CephClusterFeedService.createCephClusterFeedItem({
+      cephClusterId: cephClusterId,
+      projectId: projectId,
+      cephClusterFeedEventType: CephClusterFeedEventType.CephClusterCreated,
+      displayColor: Green500,
+      feedInfoInMarkdown: markdown.feedInfoInMarkdown,
+      moreInformationInMarkdown: markdown.moreInformationInMarkdown,
+      userId: createdByUserId,
+    });
+  }
+
+  @CaptureSpan()
+  protected override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    this.writeCephClusterUpdatedFeed(onUpdate, updatedItemIds).catch(
+      (error: Error) => {
+        logger.error(error);
+      },
+    );
+
+    return onUpdate;
+  }
+
+  private async writeCephClusterUpdatedFeed(
+    onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<void> {
+    const updateData: JSONObject = onUpdate.updateBy
+      .data as unknown as JSONObject;
+
+    /*
+     * Heartbeats update lastSeenAt / otelCollectorStatus / agentVersion and the
+     * rollup counters constantly. Only the columns a person would recognise as
+     * a change earn a feed item - see MEANINGFUL_UPDATE_COLUMNS.
+     */
+    const changedColumns: Array<string> =
+      ResourceFeedUtil.getUpdatedColumnsWorthRecording(updateData);
+
+    if (changedColumns.length === 0 || updatedItemIds.length === 0) {
+      return;
+    }
+
+    const isArchiveChange: boolean =
+      ResourceFeedUtil.isArchiveChange(updateData);
+    const isArchived: boolean = Boolean(updateData["isArchived"]);
+    const otherColumns: Array<string> = changedColumns.filter(
+      (column: string) => {
+        return column !== "isArchived";
+      },
+    );
+
+    const updatedByUserId: ObjectID | undefined =
+      onUpdate.updateBy.props.userId || undefined;
+
+    for (const cephClusterId of updatedItemIds) {
+      const cephCluster: Model | null = await this.findOneById({
+        id: cephClusterId,
+        select: {
+          projectId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      const projectId: ObjectID | undefined = cephCluster?.projectId;
+
+      if (!projectId) {
+        continue;
+      }
+
+      const resourceMarkdownLink: string =
+        await this.getCephClusterMarkdownLink(projectId, cephClusterId);
+
+      if (isArchiveChange) {
+        await CephClusterFeedService.createCephClusterFeedItem({
+          cephClusterId: cephClusterId,
+          projectId: projectId,
+          cephClusterFeedEventType: isArchived
+            ? CephClusterFeedEventType.CephClusterArchived
+            : CephClusterFeedEventType.CephClusterRestored,
+          displayColor: isArchived ? Yellow500 : Blue500,
+          feedInfoInMarkdown: isArchived
+            ? `🗄️ ${resourceMarkdownLink} was archived.`
+            : `♻️ ${resourceMarkdownLink} was restored from the archive.`,
+          userId: updatedByUserId,
+        });
+      }
+
+      if (otherColumns.length > 0) {
+        const markdown: {
+          feedInfoInMarkdown: string;
+          moreInformationInMarkdown: string;
+        } = ResourceFeedUtil.getUpdatedFeedMarkdown({
+          resourceMarkdownLink: resourceMarkdownLink,
+          columns: otherColumns,
+        });
+
+        await CephClusterFeedService.createCephClusterFeedItem({
+          cephClusterId: cephClusterId,
+          projectId: projectId,
+          cephClusterFeedEventType: CephClusterFeedEventType.CephClusterUpdated,
+          displayColor: Gray500,
+          feedInfoInMarkdown: markdown.feedInfoInMarkdown,
+          moreInformationInMarkdown: markdown.moreInformationInMarkdown,
+          userId: updatedByUserId,
+        });
+      }
+    }
+  }
 }
 
 function fingerprintLabelIds(labelIds: Array<ObjectID>): string {

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

package/Server/Services/CloudResourceLabelRuleEngineService.ts

@@ -3,6 +3,9 @@ import CloudResource from "../../Models/DatabaseModels/CloudResource";
 import CloudResourceLabelRule from "../../Models/DatabaseModels/CloudResourceLabelRule";
 import CloudResourceLabelRuleService from "./CloudResourceLabelRuleService";
 import CloudResourceService from "./CloudResourceService";
+import CloudResourceFeedService from "./CloudResourceFeedService";
+import { CloudResourceFeedEventType } from "../../Models/DatabaseModels/CloudResourceFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -61,11 +64,17 @@ class CloudResourceLabelRuleEngineServiceClass {
       }
 
       const labelIdsToAdd: Set<string> = new Set();
+      const matchedRuleNames: Array<string> = [];
 
       for (const rule of rules) {
         if (!this.doesMatchRule(resourceWithDetails, rule)) {
           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());
@@ -111,6 +120,27 @@ class CloudResourceLabelRuleEngineServiceClass {
         label.id = new ObjectID(id);
         return label;
       });
+      /*
+       * 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 CloudResourceFeedService.createCloudResourceFeedItem({
+        cloudResourceId: cloudResource.id,
+        projectId: cloudResource.projectId,
+        cloudResourceFeedEventType:
+          CloudResourceFeedEventType.LabelRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `🏷️ ${newLabelIds.length} label(s) were attached to ${await CloudResourceService.getCloudResourceMarkdownLink(
+          cloudResource.projectId,
+          cloudResource.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 cloud resource label rules: ${error}`, {
         projectId: cloudResource.projectId?.toString(),

package/Server/Services/CloudResourceOwnerRuleEngineService.ts

@@ -7,6 +7,9 @@ import CloudResourceOwnerRuleService from "./CloudResourceOwnerRuleService";
 import CloudResourceOwnerUserService from "./CloudResourceOwnerUserService";
 import CloudResourceOwnerTeamService from "./CloudResourceOwnerTeamService";
 import CloudResourceService from "./CloudResourceService";
+import CloudResourceFeedService from "./CloudResourceFeedService";
+import { CloudResourceFeedEventType } from "../../Models/DatabaseModels/CloudResourceFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -76,11 +79,20 @@ class CloudResourceOwnerRuleEngineServiceClass {
       ]);
 
       let anyMatched: boolean = false;
+      const matchedRuleNames: Array<string> = [];
 
       for (const rule of rules) {
         if (!this.doesMatchRule(resourceWithDetails, rule)) {
           continue;
         }
+        if (
+          (rule.ownerUsers || []).length > 0 ||
+          (rule.ownerTeams || []).length > 0
+        ) {
+          matchedRuleNames.push(
+            rule.name || rule.id?.toString() || "Unnamed rule",
+          );
+        }
         const notify: boolean = rule.notifyOwners !== false;
         for (const user of rule.ownerUsers || []) {
           if (user.id) {
@@ -128,6 +140,27 @@ class CloudResourceOwnerRuleEngineServiceClass {
           });
         }
       }
+      /*
+       * 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 CloudResourceFeedService.createCloudResourceFeedItem({
+        cloudResourceId: cloudResource.id,
+        projectId: cloudResource.projectId,
+        cloudResourceFeedEventType:
+          CloudResourceFeedEventType.OwnerRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `👥 Owners were added to ${await CloudResourceService.getCloudResourceMarkdownLink(
+          cloudResource.projectId,
+          cloudResource.id,
+        )} by ${matchedRuleNames.length} owner ${matchedRuleNames.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRuleNames
+          .map((name: string) => {
+            return `\`${name}\``;
+          })
+          .join(", ")}`,
+      });
     } catch (error) {
       logger.error(`Error applying cloud resource owner rules: ${error}`, {
         projectId: cloudResource.projectId?.toString(),