@oneuptime/common 12.0.25 → 12.0.27

package/Server/Services/AIService.ts

@@ -2,7 +2,7 @@ import { getAllEnvVars, IsBillingEnabled } from "../EnvironmentConfig";
 import BaseService from "./BaseService";
 import LlmProviderService from "./LlmProviderService";
 import LlmLogService from "./LlmLogService";
-import ProjectService from "./ProjectService";
+import ProjectService, { CurrentPlan } from "./ProjectService";
 import Project from "../../Models/DatabaseModels/Project";
 import AIBillingService from "./AIBillingService";
 import LLMService, {
@@ -278,6 +278,43 @@ export interface AutonomousBudgetStatus {
   usedTokensToday: number;
 }
 
+/*
+ * How long a synchronous "Generate with AI" endpoint may spend inside the
+ * provider on a single attempt.
+ *
+ * These endpoints — incident and episode postmortems, and incident, alert and
+ * scheduled-maintenance notes — hold the browser's HTTP connection open across
+ * the whole completion and write nothing until it returns. nginx gives the
+ * request 300s (`location /api` in Nginx/default.conf.template), so this MUST
+ * stay strictly below that: whichever side gives up first decides what the
+ * user reads. When the server wins, the browser gets the provider's own
+ * explanation ("model not found", "connection refused", a rate limit). When
+ * the proxy wins, it synthesizes a gateway error — a 504, or a 502 when the
+ * app's hostname resolves to more than one address and nginx's retry also
+ * fails — and getFriendlyMessage in Common/UI/Utils/API/API.ts turns BOTH of
+ * those, and only those, into the generic "Error connecting to server. Please
+ * try again in few minutes." That is exactly the report in GH#3434.
+ *
+ * The remaining ~60s of headroom pays for building the incident context and
+ * writing the response. Callers pair this with `requestRetries: 0`: a second
+ * full-length attempt cannot fit inside the proxy budget, and by the time it
+ * began the browser would already have been handed a 504. The retry ladder is
+ * still the right default for unattended work (LLMService.DEFAULT_REQUEST_
+ * ATTEMPTS), which nothing here changes — a person watching a spinner can
+ * simply press the button again, and now sees why they need to.
+ */
+export const INTERACTIVE_AI_GENERATION_TIMEOUT_IN_MS: number = 4 * 60 * 1000;
+
+/*
+ * The single wording for a refusal by the Project.enableAi kill switch. Every
+ * surface that has to tell somebody AI is switched off imports this, so the
+ * message a user reads in Slack, in Teams, on a runbook step and on a
+ * "Generate with AI" button is the same sentence, and it always names the
+ * screen where the switch can be turned back on.
+ */
+export const AI_DISABLED_MESSAGE: string =
+  "AI features are disabled for this project. Enable them in Project Settings > AI Credits.";
+
 export interface AILogRequest {
   projectId: ObjectID;
   userId?: ObjectID | undefined;
@@ -338,34 +375,96 @@ export class Service extends BaseService {
   }
 
   /**
-   * Assert the project-level feature, subscription, and payment gates shared by
-   * background AI entry points. Provider availability, balance, and token
-   * budgets are checked later by executeWithLogging so those failures are
-   * captured in the metered LLM log.
+   * Assert the project-level `enableAi` kill switch, and nothing else.
+   *
+   * This is admission control, not the guarantee. The guarantee lives inside
+   * executeWithLogging (see assertProjectAIEnabledOnRow), which no caller can
+   * route around. What this buys on top is an EARLY refusal: the synchronous
+   * "Generate with AI" endpoints call it before their context builders run,
+   * so a project with AI off never pays for the expensive reads that only
+   * exist to build a prompt nobody is allowed to send.
+   *
+   * Fails closed: a project row we cannot read is not a project we can
+   * confirm has AI enabled, so a missing project is refused rather than
+   * waved through.
    */
   @CaptureSpan()
-  public async assertProjectCanUseAI(projectId: ObjectID): Promise<void> {
-    const [project, planStatus]: [
-      Project | null,
-      { plan: PlanType | null; isSubscriptionUnpaid: boolean },
-    ] = await Promise.all([
-      ProjectService.findOneById({
-        id: projectId,
-        select: { enableAi: true },
-        props: { isRoot: true },
-      }),
-      ProjectService.getCurrentPlan(projectId),
-    ]);
+  public async assertProjectAIEnabled(projectId: ObjectID): Promise<void> {
+    const project: Project | null = await ProjectService.findOneById({
+      id: projectId,
+      select: { enableAi: true },
+      props: { isRoot: true },
+    });
+
+    this.assertProjectAIEnabledOnRow(project);
+  }
 
+  /**
+   * The toggle verdict itself, over an already-loaded row. Split out so the
+   * one place that owns the rule is shared by every caller — the throwing
+   * assert above, the non-throwing predicate below, and the backstop inside
+   * executeWithLogging, which reads the row for its own reasons and must not
+   * pay for a second read to ask the same question.
+   */
+  private assertProjectAIEnabledOnRow(project: Project | null): void {
     if (!project) {
       throw new BadDataException("Project not found.");
     }
 
+    /*
+     * Strictly `=== false`. The column is NOT NULL DEFAULT true, so an
+     * undefined value here means "not selected", not "disabled", and must
+     * keep working — same semantics as every other enableAi read.
+     */
     if (project.enableAi === false) {
-      throw new BadDataException(
-        "AI features are disabled for this project. Enable AI in Project Settings before running this workflow.",
+      throw new BadDataException(AI_DISABLED_MESSAGE);
+    }
+  }
+
+  /**
+   * The same verdict as assertProjectAIEnabled, as a boolean.
+   *
+   * For the autonomous, fire-and-forget lanes — on-resolve grading and
+   * friends — where "this project has AI switched off" is not an error and
+   * must not be logged as one. Those callers sit inside a catch that reports
+   * failures, so letting the backstop throw would turn a deliberate,
+   * correctly-configured setting into recurring error noise. They ask this
+   * first and simply skip.
+   *
+   * Fails closed the same way: an unreadable project row answers false.
+   */
+  @CaptureSpan()
+  public async isProjectAIEnabled(projectId: ObjectID): Promise<boolean> {
+    try {
+      await this.assertProjectAIEnabled(projectId);
+      return true;
+    } catch (err) {
+      logger.debug(
+        `Project AI toggle: ${projectId.toString()} may not use AI — ${err}`,
       );
+      return false;
     }
+  }
+
+  /**
+   * Assert the project-level feature, subscription, and payment gates shared by
+   * background AI entry points. Provider availability, balance, and token
+   * budgets are checked later by executeWithLogging so those failures are
+   * captured in the metered LLM log.
+   */
+  @CaptureSpan()
+  public async assertProjectCanUseAI(projectId: ObjectID): Promise<void> {
+    /*
+     * The kill switch and the plan read stay in flight together — the plan
+     * read does not depend on the toggle's verdict. The ordering that matters
+     * is still preserved: the unpaid and plan refusals below run only once
+     * this resolves, so a project with AI switched off is refused for being
+     * switched off, never for something billing has to say about it.
+     */
+    const [, planStatus]: [void, CurrentPlan] = await Promise.all([
+      this.assertProjectAIEnabled(projectId),
+      ProjectService.getCurrentPlan(projectId),
+    ]);
 
     if (planStatus.isSubscriptionUnpaid) {
       throw new PaymentRequiredException(
@@ -462,6 +561,40 @@ export class Service extends BaseService {
   ): Promise<AILogResponse> {
     this.assertSingleSubject(request);
 
+    /*
+     * ===================== The enableAi kill switch =======================
+     *
+     * Every AI call in this codebase — user-triggered, autonomous, chat-ops,
+     * runbook step, agent loop — comes through here. That makes this the only
+     * place the project toggle can be enforced ONCE and be true for callers
+     * that do not exist yet. Enforcing it at entry points instead is what
+     * this method used to rely on, and it leaked exactly the way per-site
+     * admission control always leaks: five endpoints were gated and nine
+     * other call sites were not, so a project with AI switched off could
+     * still be made to spend provider tokens through any of them.
+     *
+     * There is deliberately NO per-request opt-out. A `skipAICheck` flag
+     * would re-open the hole with a one-word diff, and the caller most likely
+     * to reach for it is the one that has not thought about the switch. A
+     * lane that must not throw — fire-and-forget autonomous work — asks
+     * isProjectAIEnabled() first and skips silently; a lane that owes the
+     * user a readable refusal (Slack, Teams) checks first and posts one. Both
+     * are about DELIVERY, and both still land here if they forget.
+     *
+     * The row is read once and carried to the balance check below, so on the
+     * billing path this costs no extra query. Off the billing path it adds a
+     * single primary-key read per LLM call — set against a provider round
+     * trip measured in seconds, and against the alternative of billing a
+     * project that told us not to.
+     */
+    const project: Project | null = await ProjectService.findOneById({
+      id: request.projectId,
+      select: { enableAi: true, aiCurrentBalanceInUSDCents: true },
+      props: { isRoot: true },
+    });
+
+    this.assertProjectAIEnabledOnRow(project);
+
     const startTime: Date = new Date();
 
     // Get LLM provider for the project (honoring an explicit per-chat choice).
@@ -543,29 +676,25 @@ export class Service extends BaseService {
       (llmProvider.isGlobalLlm || false) &&
       (llmProvider.costPerMillionTokensInUSDCents || 0) > 0;
 
-    // Check balance if billing enabled and using global provider
-    if (shouldBill) {
-      const project: Project | null = await ProjectService.findOneById({
-        id: request.projectId,
-        select: { aiCurrentBalanceInUSDCents: true },
+    /*
+     * Check balance if billing enabled and using global provider. The row was
+     * already read for the kill switch above and is non-null past that gate,
+     * so this reuses it rather than issuing a second read of the same row.
+     */
+    if (shouldBill && (project!.aiCurrentBalanceInUSDCents || 0) <= 0) {
+      logEntry.status = LlmLogStatus.InsufficientBalance;
+      logEntry.statusMessage = "Insufficient AI balance";
+      logEntry.requestCompletedAt = new Date();
+      logEntry.durationMs = new Date().getTime() - startTime.getTime();
+
+      await LlmLogService.create({
+        data: logEntry,
         props: { isRoot: true },
       });
 
-      if (!project || (project.aiCurrentBalanceInUSDCents || 0) <= 0) {
-        logEntry.status = LlmLogStatus.InsufficientBalance;
-        logEntry.statusMessage = "Insufficient AI balance";
-        logEntry.requestCompletedAt = new Date();
-        logEntry.durationMs = new Date().getTime() - startTime.getTime();
-
-        await LlmLogService.create({
-          data: logEntry,
-          props: { isRoot: true },
-        });
-
-        throw new BadDataException(
-          "Insufficient AI balance. Please recharge your AI balance in Project Settings > AI Credits.",
-        );
-      }
+      throw new BadDataException(
+        "Insufficient AI balance. Please recharge your AI balance in Project Settings > AI Credits.",
+      );
     }
 
     /*
@@ -722,9 +851,20 @@ export class Service extends BaseService {
           ? "The AI provider request failed. Review the provider configuration and try again."
           : rawErrorMessage;
 
-      // Log the error without persisting private provider details when asked.
+      /*
+       * Log the error without persisting private provider details when asked.
+       *
+       * statusMessage is varchar(500) (ColumnLength.LongText), and
+       * DatabaseService rejects an over-length value BEFORE any SQL runs — so
+       * an untruncated provider error does not just fail to be logged, its
+       * BadDataException about column length replaces the real failure on the
+       * way out and the operator never learns what the provider said. Provider
+       * errors are routinely longer than 500 characters (an echoed request
+       * body, an HTML error page). Truncate the same way the budget path
+       * above does.
+       */
       logEntry.status = LlmLogStatus.Error;
-      logEntry.statusMessage = errorMessage;
+      logEntry.statusMessage = errorMessage.substring(0, 490);
       logEntry.requestCompletedAt = new Date();
       logEntry.durationMs = new Date().getTime() - startTime.getTime();
 

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

package/Server/Services/CephClusterLabelRuleEngineService.ts

@@ -3,6 +3,9 @@ import CephCluster from "../../Models/DatabaseModels/CephCluster";
 import CephClusterLabelRule from "../../Models/DatabaseModels/CephClusterLabelRule";
 import CephClusterLabelRuleService from "./CephClusterLabelRuleService";
 import CephClusterService from "./CephClusterService";
+import CephClusterFeedService from "./CephClusterFeedService";
+import { CephClusterFeedEventType } from "../../Models/DatabaseModels/CephClusterFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -61,6 +64,7 @@ class CephClusterLabelRuleEngineServiceClass {
       }
 
       const labelIdsToAdd: Set<string> = new Set();
+      const matchedRuleNames: Array<string> = [];
 
       for (const rule of rules) {
         const matches: boolean = this.doesCephClusterMatchRule(
@@ -70,6 +74,11 @@ class CephClusterLabelRuleEngineServiceClass {
         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());
@@ -124,6 +133,26 @@ class CephClusterLabelRuleEngineServiceClass {
         `CephClusterLabelRuleEngine attached ${newLabelIds.length} labels to Ceph cluster ${cephCluster.id}`,
         { projectId: cephCluster.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 CephClusterFeedService.createCephClusterFeedItem({
+        cephClusterId: cephCluster.id,
+        projectId: cephCluster.projectId,
+        cephClusterFeedEventType: CephClusterFeedEventType.LabelRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `🏷️ ${newLabelIds.length} label(s) were attached to ${await CephClusterService.getCephClusterMarkdownLink(
+          cephCluster.projectId,
+          cephCluster.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 Ceph cluster label rules: ${error}`, {
         projectId: cephCluster.projectId?.toString(),

package/Server/Services/CephClusterOwnerRuleEngineService.ts

@@ -7,6 +7,9 @@ import CephClusterOwnerRuleService from "./CephClusterOwnerRuleService";
 import CephClusterOwnerUserService from "./CephClusterOwnerUserService";
 import CephClusterOwnerTeamService from "./CephClusterOwnerTeamService";
 import CephClusterService from "./CephClusterService";
+import CephClusterFeedService from "./CephClusterFeedService";
+import { CephClusterFeedEventType } from "../../Models/DatabaseModels/CephClusterFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -142,6 +145,26 @@ class CephClusterOwnerRuleEngineServiceClass {
         `CephClusterOwnerRuleEngine added owners to Ceph cluster ${cephCluster.id}`,
         { projectId: cephCluster.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 CephClusterFeedService.createCephClusterFeedItem({
+        cephClusterId: cephCluster.id,
+        projectId: cephCluster.projectId,
+        cephClusterFeedEventType: CephClusterFeedEventType.OwnerRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `👥 Owners were added to ${await CephClusterService.getCephClusterMarkdownLink(
+          cephCluster.projectId,
+          cephCluster.id,
+        )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
+          .map((rule: CephClusterOwnerRule) => {
+            return `\`${rule.name || rule.id?.toString() || "Unnamed rule"}\``;
+          })
+          .join(", ")}`,
+      });
     } catch (error) {
       logger.error(`Error applying Ceph cluster owner rules: ${error}`, {
         projectId: cephCluster.projectId?.toString(),

package/Server/Services/CephClusterOwnerTeamService.ts

@@ -1,10 +1,139 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/CephClusterOwnerTeam";
+import CephClusterFeedService from "./CephClusterFeedService";
+import { CephClusterFeedEventType } from "../../Models/DatabaseModels/CephClusterFeed";
+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 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,
+        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 cephClusterId: ObjectID | undefined = item.cephClusterId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (!cephClusterId || !projectId || !teamId) {
+        continue;
+      }
+
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!team || !team.name) {
+        continue;
+      }
+
+      await CephClusterFeedService.createCephClusterFeedItem({
+        cephClusterId: cephClusterId,
+        projectId: projectId,
+        cephClusterFeedEventType: CephClusterFeedEventType.OwnerTeamRemoved,
+        displayColor: Red500,
+        feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** 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 teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (cephClusterId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await CephClusterFeedService.createCephClusterFeedItem({
+          cephClusterId: cephClusterId,
+          projectId: projectId,
+          cephClusterFeedEventType: CephClusterFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** as an owner of ${await CephClusterService.getCephClusterMarkdownLink(
+            projectId,
+            cephClusterId,
+          )}.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();