@oneuptime/common 10.2.22 → 10.3.0

package/Server/Services/RunbookRuleEngineService.ts

@@ -0,0 +1,302 @@
+import Alert from "../../Models/DatabaseModels/Alert";
+import Incident from "../../Models/DatabaseModels/Incident";
+import Runbook from "../../Models/DatabaseModels/Runbook";
+import RunbookExecution from "../../Models/DatabaseModels/RunbookExecution";
+import RunbookRule from "../../Models/DatabaseModels/RunbookRule";
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
+import { JSONArray } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import RunbookExecutionStatus from "../../Types/Runbook/RunbookExecutionStatus";
+import RunbookRuleTriggerEntity from "../../Types/Runbook/RunbookRuleTriggerEntity";
+import RunbookStepExecutionStatus from "../../Types/Runbook/RunbookStepExecutionStatus";
+import { RunbookStep } from "../../Types/Runbook/RunbookStep";
+import { RunbookStepExecutionState } from "../../Types/Runbook/RunbookStepExecution";
+import RunbookExecutionService from "./RunbookExecutionService";
+import RunbookRuleService from "./RunbookRuleService";
+import RunbookService from "./RunbookService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+type EnqueueExecutionFn = (data: {
+  runbookExecutionId: ObjectID;
+}) => Promise<void>;
+
+class RunbookRuleEngineServiceClass {
+  // Lazily-set queue hook so Common doesn't depend on App/FeatureSet.
+  private enqueue: EnqueueExecutionFn | null = null;
+
+  public registerExecutionEnqueuer(fn: EnqueueExecutionFn): void {
+    this.enqueue = fn;
+  }
+
+  @CaptureSpan()
+  public async applyRulesToIncident(incident: Incident): Promise<void> {
+    if (!incident.id || !incident.projectId) {
+      return;
+    }
+    await this.applyRules({
+      projectId: incident.projectId,
+      triggerEntityType: RunbookRuleTriggerEntity.Incident,
+      title: incident.title,
+      description: incident.description,
+      linkage: { incidentId: incident.id },
+    });
+  }
+
+  @CaptureSpan()
+  public async applyRulesToAlert(alert: Alert): Promise<void> {
+    if (!alert.id || !alert.projectId) {
+      return;
+    }
+    await this.applyRules({
+      projectId: alert.projectId,
+      triggerEntityType: RunbookRuleTriggerEntity.Alert,
+      title: alert.title,
+      description: alert.description,
+      linkage: { alertId: alert.id },
+    });
+  }
+
+  @CaptureSpan()
+  public async applyRulesToScheduledMaintenance(
+    event: ScheduledMaintenance,
+  ): Promise<void> {
+    if (!event.id || !event.projectId) {
+      return;
+    }
+    await this.applyRules({
+      projectId: event.projectId,
+      triggerEntityType: RunbookRuleTriggerEntity.ScheduledMaintenance,
+      title: event.title,
+      description: event.description,
+      linkage: { scheduledMaintenanceId: event.id },
+    });
+  }
+
+  @CaptureSpan()
+  private async applyRules(data: {
+    projectId: ObjectID;
+    triggerEntityType: RunbookRuleTriggerEntity;
+    title?: string | undefined;
+    description?: string | undefined;
+    linkage: {
+      incidentId?: ObjectID;
+      alertId?: ObjectID;
+      scheduledMaintenanceId?: ObjectID;
+    };
+  }): Promise<void> {
+    try {
+      const rules: Array<RunbookRule> = await RunbookRuleService.findBy({
+        query: {
+          projectId: data.projectId,
+          isEnabled: true,
+          triggerEntityType: data.triggerEntityType,
+        },
+        props: { isRoot: true },
+        select: {
+          _id: true,
+          name: true,
+          titlePattern: true,
+          descriptionPattern: true,
+          runbooks: { _id: true },
+        },
+        limit: 100,
+        skip: 0,
+      });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const runbookIdsToStart: Set<string> = new Set<string>();
+      const matchedRuleNames: Array<string> = [];
+
+      for (const rule of rules) {
+        if (!this.matches(rule, data.title, data.description)) {
+          continue;
+        }
+        const runbookIds: Array<string> = (rule.runbooks || [])
+          .map((rb: Runbook) => {
+            return rb.id?.toString() || "";
+          })
+          .filter((id: string) => {
+            return id !== "";
+          });
+        if (runbookIds.length === 0) {
+          continue;
+        }
+        for (const id of runbookIds) {
+          runbookIdsToStart.add(id);
+        }
+        if (rule.name) {
+          matchedRuleNames.push(rule.name);
+        }
+      }
+
+      if (runbookIdsToStart.size === 0) {
+        return;
+      }
+
+      for (const runbookIdStr of runbookIdsToStart) {
+        await this.startRunbookFor({
+          projectId: data.projectId,
+          runbookId: new ObjectID(runbookIdStr),
+          linkage: data.linkage,
+        });
+      }
+
+      logger.debug(
+        `RunbookRuleEngine: started ${runbookIdsToStart.size} runbook(s) for ${data.triggerEntityType}`,
+        {
+          projectId: data.projectId.toString(),
+          matchedRules: matchedRuleNames.join(", "),
+        } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying runbook rules: ${error}`, {
+        projectId: data.projectId?.toString(),
+        triggerEntityType: data.triggerEntityType,
+      } as LogAttributes);
+    }
+  }
+
+  private matches(
+    rule: RunbookRule,
+    title: string | undefined,
+    description: string | undefined,
+  ): boolean {
+    if (rule.titlePattern) {
+      if (!title || !this.testRegex(rule.titlePattern, title, rule)) {
+        return false;
+      }
+    }
+    if (rule.descriptionPattern) {
+      if (
+        !description ||
+        !this.testRegex(rule.descriptionPattern, description, rule)
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: RunbookRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(`Invalid regex in runbook rule ${rule.id}: ${pattern}`);
+      return false;
+    }
+  }
+
+  @CaptureSpan()
+  public async startRunbookFor(data: {
+    projectId: ObjectID;
+    runbookId: ObjectID;
+    linkage: {
+      incidentId?: ObjectID;
+      alertId?: ObjectID;
+      scheduledMaintenanceId?: ObjectID;
+    };
+    triggeredByUserId?: ObjectID;
+  }): Promise<RunbookExecution | null> {
+    const runbook: Runbook | null = await RunbookService.findOneById({
+      id: data.runbookId,
+      select: {
+        _id: true,
+        projectId: true,
+        name: true,
+        steps: true,
+        isEnabled: true,
+      },
+      props: { isRoot: true },
+    });
+
+    if (!runbook) {
+      return null;
+    }
+
+    if (runbook.projectId?.toString() !== data.projectId.toString()) {
+      return null;
+    }
+
+    if (runbook.isEnabled === false) {
+      return null;
+    }
+
+    const steps: RunbookStep[] =
+      (runbook.steps as unknown as RunbookStep[]) || [];
+
+    if (steps.length === 0) {
+      return null;
+    }
+
+    const stepExecutions: RunbookStepExecutionState[] = steps
+      .slice()
+      .sort((a: RunbookStep, b: RunbookStep) => {
+        return a.order - b.order;
+      })
+      .map((step: RunbookStep) => {
+        return {
+          step,
+          status: RunbookStepExecutionStatus.Pending,
+        };
+      });
+
+    const execution: RunbookExecution = new RunbookExecution();
+    execution.projectId = runbook.projectId;
+    execution.runbookId = new ObjectID(runbook._id!);
+    execution.runbookNameSnapshot = runbook.name || "Runbook";
+    execution.status = RunbookExecutionStatus.Scheduled;
+    execution.stepExecutions = stepExecutions as unknown as JSONArray;
+    if (data.linkage.incidentId) {
+      execution.incidentId = data.linkage.incidentId;
+    }
+    if (data.linkage.alertId) {
+      execution.alertId = data.linkage.alertId;
+    }
+    if (data.linkage.scheduledMaintenanceId) {
+      execution.scheduledMaintenanceId = data.linkage.scheduledMaintenanceId;
+    }
+    if (data.triggeredByUserId) {
+      execution.triggeredByUserId = data.triggeredByUserId;
+    }
+
+    const created: RunbookExecution = await RunbookExecutionService.create({
+      data: execution,
+      props: { isRoot: true },
+    });
+
+    if (this.enqueue) {
+      try {
+        await this.enqueue({
+          runbookExecutionId: new ObjectID(created._id!),
+        });
+      } catch (err) {
+        logger.error(
+          `RunbookRuleEngine: failed to enqueue runbook execution: ${err}`,
+          {
+            runbookExecutionId: created._id?.toString(),
+          } as LogAttributes,
+        );
+      }
+    } else {
+      logger.warn(
+        "RunbookRuleEngine: enqueue hook not registered; execution created but not started.",
+      );
+    }
+
+    return created;
+  }
+}
+
+const RunbookRuleEngineService: RunbookRuleEngineServiceClass =
+  new RunbookRuleEngineServiceClass();
+
+export default RunbookRuleEngineService;

package/Server/Services/RunbookRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/RunbookRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/RunbookSecretService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import RunbookSecret from "../../Models/DatabaseModels/RunbookSecret";
+
+export class Service extends DatabaseService<RunbookSecret> {
+  public constructor() {
+    super(RunbookSecret);
+  }
+}
+
+export default new Service();

package/Server/Services/RunbookService.ts

@@ -0,0 +1,46 @@
+import DatabaseService from "./DatabaseService";
+import RunbookLabelRuleEngineService from "./RunbookLabelRuleEngineService";
+import RunbookOwnerRuleEngineService from "./RunbookOwnerRuleEngineService";
+import Model from "../../Models/DatabaseModels/Runbook";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    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 RunbookLabelRuleEngineService.applyRulesToRunbook(createdItem);
+        })
+        .then(async () => {
+          await RunbookOwnerRuleEngineService.applyRulesToRunbook(createdItem);
+        })
+        .catch((error: Error) => {
+          logger.error(
+            `Error applying runbook rules in RunbookService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              runbookId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        });
+    }
+    return createdItem;
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -51,6 +51,7 @@ import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import ScheduledMaintenanceLabelRuleEngineService from "./ScheduledMaintenanceLabelRuleEngineService";
 import ScheduledMaintenanceOwnerRuleEngineService from "./ScheduledMaintenanceOwnerRuleEngineService";
+import RunbookRuleEngineService from "./RunbookRuleEngineService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import StatusPageSubscriberWebhookUtil from "../Utils/StatusPageSubscriberWebhook";
@@ -969,6 +970,21 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
           );
         }
       })
+      .then(async () => {
+        try {
+          await RunbookRuleEngineService.applyRulesToScheduledMaintenance(
+            createdItem,
+          );
+        } catch (error) {
+          logger.error(
+            `Apply runbook rules failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              scheduledMaintenanceId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in ScheduledMaintenanceService sequential operations: ${error}`,

package/Server/Services/ServiceLabelRuleEngineService.ts

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

package/Server/Services/ServiceLabelRuleService.ts

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