@oneuptime/common 10.2.22 → 10.3.0

package/Server/Services/HostOwnerRuleEngineService.ts

@@ -0,0 +1,198 @@
+import Label from "../../Models/DatabaseModels/Label";
+import Host from "../../Models/DatabaseModels/Host";
+import HostOwnerRule from "../../Models/DatabaseModels/HostOwnerRule";
+import HostOwnerUser from "../../Models/DatabaseModels/HostOwnerUser";
+import HostOwnerTeam from "../../Models/DatabaseModels/HostOwnerTeam";
+import HostOwnerRuleService from "./HostOwnerRuleService";
+import HostOwnerUserService from "./HostOwnerUserService";
+import HostOwnerTeamService from "./HostOwnerTeamService";
+import HostService from "./HostService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class HostOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates HostOwnerRule rows for the given host and adds matched
+   * owner users / teams via HostOwnerUserService / HostOwnerTeamService. Rules
+   * with notifyOwners set notify the added owners; rules with notifyOwners off
+   * add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToHost(host: Host): Promise<void> {
+    if (!host.id || !host.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<HostOwnerRule> = await HostOwnerRuleService.findBy({
+        query: {
+          projectId: host.projectId,
+          isEnabled: true,
+        },
+        props: { isRoot: true },
+        select: {
+          _id: true,
+          name: true,
+          notifyOwners: true,
+          hostLabels: { _id: true },
+          hostNamePattern: true,
+          hostDescriptionPattern: true,
+          ownerUsers: { _id: true },
+          ownerTeams: { _id: true },
+        },
+        limit: 100,
+        skip: 0,
+      });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const hostWithDetails: Host | null = await HostService.findOneById({
+        id: host.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        props: { isRoot: true },
+      });
+
+      if (!hostWithDetails) {
+        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<HostOwnerRule> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesHostMatchRule(hostWithDetails, 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: HostOwnerUser = new HostOwnerUser();
+          owner.hostId = host.id;
+          owner.projectId = host.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await HostOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: HostOwnerTeam = new HostOwnerTeam();
+          owner.hostId = host.id;
+          owner.projectId = host.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await HostOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+
+      logger.debug(`HostOwnerRuleEngine added owners to host ${host.id}`, {
+        projectId: host.projectId.toString(),
+      } as LogAttributes);
+    } catch (error) {
+      logger.error(`Error applying host owner rules: ${error}`, {
+        projectId: host.projectId?.toString(),
+        hostId: host.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesHostMatchRule(host: Host, rule: HostOwnerRule): boolean {
+    if (rule.hostLabels && rule.hostLabels.length > 0) {
+      if (!host.labels || host.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.hostLabels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      const labelIds: Array<string> = host.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.hostNamePattern &&
+      (!host.name || !this.testRegex(rule.hostNamePattern, host.name, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.hostDescriptionPattern &&
+      (!host.description ||
+        !this.testRegex(rule.hostDescriptionPattern, host.description, rule))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: HostOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(`Invalid regex in host owner rule ${rule.id}: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new HostOwnerRuleEngineServiceClass();

package/Server/Services/HostOwnerRuleService.ts

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

@@ -1,13 +1,16 @@
 import DatabaseService from "./DatabaseService";
+import HostLabelRuleEngineService from "./HostLabelRuleEngineService";
+import HostOwnerRuleEngineService from "./HostOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/Host";
 import Label from "../../Models/DatabaseModels/Label";
+import { OnCreate } from "../Types/Database/Hooks";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import ObjectID from "../../Types/ObjectID";
 import QueryHelper from "../Types/Database/QueryHelper";
 import OneUptimeDate from "../../Types/Date";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import GlobalCache from "../Infrastructure/GlobalCache";
-import logger from "../Utils/Logger";
+import logger, { LogAttributes } from "../Utils/Logger";
 import crypto from "crypto";
 
 const LAST_SEEN_CACHE_NAMESPACE: string = "host-last-seen";
@@ -21,6 +24,37 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (createdItem.projectId && createdItem.id) {
+      /*
+       * Run label rule first so rule-added labels are persisted before
+       * owner rules run. Owner rules re-fetch labels, so this lets owner
+       * rules key on rule-added labels.
+       */
+      Promise.resolve()
+        .then(async () => {
+          await HostLabelRuleEngineService.applyRulesToHost(createdItem);
+        })
+        .then(async () => {
+          await HostOwnerRuleEngineService.applyRulesToHost(createdItem);
+        })
+        .catch((error: Error) => {
+          logger.error(
+            `Error applying host rules in HostService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              hostId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        });
+    }
+    return createdItem;
+  }
+
   @CaptureSpan()
   public async findOrCreateByHostIdentifier(data: {
     projectId: ObjectID;

package/Server/Services/IncidentEpisodeService.ts

@@ -717,7 +717,7 @@ export class Service extends DatabaseService<Model> {
       projectId: episode.projectId,
       episodeId: episodeId,
       incidentStateId: incidentState.id,
-      notifyOwners: false,
+      notifyOwners: true,
       rootCause: acknowledgedByUserId
         ? `Acknowledged by user.`
         : "Acknowledged via API.",
@@ -773,7 +773,7 @@ export class Service extends DatabaseService<Model> {
       projectId: episode.projectId,
       episodeId: episodeId,
       incidentStateId: incidentState.id,
-      notifyOwners: false,
+      notifyOwners: true,
       rootCause: resolvedByUserId ? `Resolved by user.` : "Resolved via API.",
       props: {
         isRoot: true,
@@ -827,7 +827,7 @@ export class Service extends DatabaseService<Model> {
       projectId: episode.projectId,
       episodeId: episodeId,
       incidentStateId: incidentState.id,
-      notifyOwners: false,
+      notifyOwners: true,
       rootCause: reopenedByUserId ? `Reopened by user.` : "Reopened via API.",
       props: {
         isRoot: true,

package/Server/Services/IncidentService.ts

@@ -59,6 +59,7 @@ import IncidentLabelRuleEngineService from "./IncidentLabelRuleEngineService";
 import IncidentOnCallRuleEngineService from "./IncidentOnCallRuleEngineService";
 import IncidentOwnerRuleEngineService from "./IncidentOwnerRuleEngineService";
 import IncidentPrivacyRuleEngineService from "./IncidentPrivacyRuleEngineService";
+import RunbookRuleEngineService from "./RunbookRuleEngineService";
 import { Blue500, Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
@@ -920,6 +921,19 @@ export class Service extends DatabaseService<Model> {
           );
         }
       })
+      .then(async () => {
+        try {
+          await RunbookRuleEngineService.applyRulesToIncident(createdItem);
+        } catch (error) {
+          logger.error(
+            `Apply runbook rules failed in IncidentService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              incidentId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .then(async () => {
         try {
           if (

package/Server/Services/Index.ts

@@ -52,6 +52,7 @@ import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
 import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorProbeService from "./MonitorProbeService";
 import MonitorSecretService from "./MonitorSecretService";
+import RunbookSecretService from "./RunbookSecretService";
 
 // Monitors
 import MonitorService from "./MonitorService";
@@ -280,6 +281,7 @@ const services: Array<BaseService> = [
   MonitorStatusService,
   MonitorStatusTimelineService,
   MonitorSecretService,
+  RunbookSecretService,
   MonitorFeedService,
 
   NotificationService,

package/Server/Services/KubernetesClusterLabelRuleEngineService.ts

@@ -0,0 +1,211 @@
+import Label from "../../Models/DatabaseModels/Label";
+import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import KubernetesClusterLabelRule from "../../Models/DatabaseModels/KubernetesClusterLabelRule";
+import KubernetesClusterLabelRuleService from "./KubernetesClusterLabelRuleService";
+import KubernetesClusterService from "./KubernetesClusterService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class KubernetesClusterLabelRuleEngineServiceClass {
+  /**
+   * Evaluates KubernetesClusterLabelRule rows for the given Kubernetes cluster and attaches matched
+   * labels to it. The union is deduped against labels already on the Kubernetes cluster
+   * before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToKubernetesCluster(
+    kubernetesCluster: KubernetesCluster,
+  ): Promise<void> {
+    if (!kubernetesCluster.id || !kubernetesCluster.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<KubernetesClusterLabelRule> =
+        await KubernetesClusterLabelRuleService.findBy({
+          query: {
+            projectId: kubernetesCluster.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            kubernetesClusterLabels: { _id: true },
+            kubernetesClusterNamePattern: true,
+            kubernetesClusterDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const kubernetesClusterWithDetails: KubernetesCluster | null =
+        await KubernetesClusterService.findOneById({
+          id: kubernetesCluster.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!kubernetesClusterWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesKubernetesClusterMatchRule(
+          kubernetesClusterWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        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(
+        (kubernetesClusterWithDetails.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 KubernetesClusterService.getRepository()
+        .createQueryBuilder()
+        .relation(KubernetesCluster, "labels")
+        .of(kubernetesCluster.id.toString())
+        .add(newLabelIds);
+
+      /*
+       * Sync in-memory kubernetesCluster.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,
+      ]);
+      kubernetesCluster.labels = Array.from(mergedLabelIds).map(
+        (id: string) => {
+          const label: Label = new Label();
+          label.id = new ObjectID(id);
+          return label;
+        },
+      );
+
+      logger.debug(
+        `KubernetesClusterLabelRuleEngine attached ${newLabelIds.length} labels to Kubernetes cluster ${kubernetesCluster.id}`,
+        { projectId: kubernetesCluster.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying Kubernetes cluster label rules: ${error}`, {
+        projectId: kubernetesCluster.projectId?.toString(),
+        kubernetesClusterId: kubernetesCluster.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesKubernetesClusterMatchRule(
+    kubernetesCluster: KubernetesCluster,
+    rule: KubernetesClusterLabelRule,
+  ): boolean {
+    if (
+      rule.kubernetesClusterLabels &&
+      rule.kubernetesClusterLabels.length > 0
+    ) {
+      if (!kubernetesCluster.labels || kubernetesCluster.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.kubernetesClusterLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = kubernetesCluster.labels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.kubernetesClusterNamePattern &&
+      (!kubernetesCluster.name ||
+        !this.testRegex(
+          rule.kubernetesClusterNamePattern,
+          kubernetesCluster.name,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.kubernetesClusterDescriptionPattern &&
+      (!kubernetesCluster.description ||
+        !this.testRegex(
+          rule.kubernetesClusterDescriptionPattern,
+          kubernetesCluster.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: KubernetesClusterLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in Kubernetes cluster label rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new KubernetesClusterLabelRuleEngineServiceClass();

package/Server/Services/KubernetesClusterLabelRuleService.ts

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