@oneuptime/common 13.0.5 → 13.0.6

package/Server/Services/WorkflowOwnerRuleEngineService.ts

@@ -8,13 +8,43 @@ import WorkflowOwnerTeamService from "./WorkflowOwnerTeamService";
 import WorkflowOwnerUserService from "./WorkflowOwnerUserService";
 import WorkflowService from "./WorkflowService";
 import ObjectID from "../../Types/ObjectID";
+import Select from "../Types/Database/Select";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import OwnerRuleAssignment, {
+  OwnersToAssign,
+} from "../Utils/Rules/OwnerRuleAssignment";
+import {
+  ApplyRulesToExistingResourceData,
+  RuleApplicationResult,
+  RuleApplicationResultUtil,
+  RuleRunEngine,
+} from "../Utils/Rules/RuleRun/RuleApplication";
+
+class WorkflowOwnerRuleEngineServiceClass
+  implements RuleRunEngine<Workflow, WorkflowOwnerRule>
+{
+  public readonly ruleSelect: Select<WorkflowOwnerRule> = {
+    _id: true,
+    name: true,
+    criteria: true,
+    notifyOwners: true,
+    workflowLabels: { _id: true },
+    workflowNamePattern: true,
+    workflowDescriptionPattern: true,
+    ownerUsers: { _id: true },
+    ownerTeams: { _id: true },
+  };
+
+  // Evaluation re-reads the workflow, so a run only has to name it.
+  public readonly resourceSelectForRuleRun: Select<Workflow> = {
+    _id: true,
+    projectId: true,
+  };
 
-class WorkflowOwnerRuleEngineServiceClass {
   /**
    * Evaluates WorkflowOwnerRule rows for the given workflow and adds matched
    * owner users / teams via WorkflowOwnerUserService / WorkflowOwnerTeamService.
@@ -35,17 +65,7 @@ class WorkflowOwnerRuleEngineServiceClass {
             isEnabled: true,
           },
           props: { isRoot: true },
-          select: {
-            _id: true,
-            name: true,
-            criteria: true,
-            notifyOwners: true,
-            workflowLabels: { _id: true },
-            workflowNamePattern: true,
-            workflowDescriptionPattern: true,
-            ownerUsers: { _id: true },
-            ownerTeams: { _id: true },
-          },
+          select: this.ruleSelect,
           limit: MAX_RULES_EVALUATED_PER_PROJECT,
           skip: 0,
         });
@@ -60,102 +80,202 @@ class WorkflowOwnerRuleEngineServiceClass {
         return;
       }
 
-      const workflowWithDetails: Workflow | null =
-        await WorkflowService.findOneById({
-          id: workflow.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+      await this.applyRules({
+        workflow: workflow,
+        rules: rules,
+        allowOwnerNotification: true,
+      });
+    } catch (error) {
+      logger.error(`Error applying workflow owner rules: ${error}`, {
+        projectId: workflow.projectId?.toString(),
+        workflowId: workflow.id?.toString(),
+      } as LogAttributes);
+    }
+  }
 
-      if (!workflowWithDetails) {
-        return;
-      }
+  /*
+   * "Run now": the same evaluation, for a workflow that already exists and
+   * only the rules being run.
+   */
+  @CaptureSpan()
+  public async applyRulesToExistingResource(
+    data: ApplyRulesToExistingResourceData<Workflow, WorkflowOwnerRule>,
+  ): Promise<RuleApplicationResult> {
+    try {
+      return await this.applyRules({
+        workflow: data.resource,
+        rules: data.rules,
+        allowOwnerNotification: data.allowOwnerNotification,
+      });
+    } catch (error) {
+      logger.error(`Error running workflow owner rules: ${error}`, {
+        projectId: data.resource.projectId?.toString(),
+        workflowId: data.resource.id?.toString(),
+      } as LogAttributes);
 
-      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()],
-      ]);
+      return RuleApplicationResultUtil.failed();
+    }
+  }
 
-      const matchedRules: Array<WorkflowOwnerRule> = [];
+  private async applyRules(data: {
+    workflow: Workflow;
+    rules: Array<WorkflowOwnerRule>;
+    allowOwnerNotification: boolean;
+  }): Promise<RuleApplicationResult> {
+    const { workflow, rules } = data;
 
-      for (const rule of rules) {
-        const matches: boolean = this.doesWorkflowMatchRule(
-          workflowWithDetails,
-          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 (!workflow.id || !workflow.projectId || rules.length === 0) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    const workflowWithDetails: Workflow | null =
+      await WorkflowService.findOneById({
+        id: workflow.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        props: { isRoot: true },
+      });
+
+    if (!workflowWithDetails) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    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<WorkflowOwnerRule> = [];
+    const allUserIds: Set<string> = new Set();
+    const allTeamIds: Set<string> = new Set();
+    let anyRuleMatched: boolean = false;
+
+    for (const rule of rules) {
+      const matches: boolean = this.doesWorkflowMatchRule(
+        workflowWithDetails,
+        rule,
+      );
+      if (!matches) {
+        continue;
+      }
+      anyRuleMatched = true;
+      let ruleAddedAny: boolean = false;
+      const notify: boolean =
+        rule.notifyOwners !== false && data.allowOwnerNotification;
+      for (const user of rule.ownerUsers || []) {
+        if (user.id) {
+          usersByNotify.get(notify)!.add(user.id.toString());
+          allUserIds.add(user.id.toString());
+          ruleAddedAny = true;
         }
-        if (ruleAddedAny) {
-          matchedRules.push(rule);
+      }
+      for (const team of rule.ownerTeams || []) {
+        if (team.id) {
+          teamsByNotify.get(notify)!.add(team.id.toString());
+          allTeamIds.add(team.id.toString());
+          ruleAddedAny = true;
         }
       }
-
-      if (matchedRules.length === 0) {
-        return;
+      if (ruleAddedAny) {
+        matchedRules.push(rule);
       }
+    }
 
-      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: WorkflowOwnerUser = new WorkflowOwnerUser();
-          owner.workflowId = workflow.id;
-          owner.projectId = workflow.projectId;
-          owner.userId = new ObjectID(userId);
-          owner.isOwnerNotified = !notify;
-          await WorkflowOwnerUserService.create({
-            data: owner,
-            props: { isRoot: true },
-          });
-        }
+    if (!anyRuleMatched) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-        for (const teamId of teamIds) {
-          const owner: WorkflowOwnerTeam = new WorkflowOwnerTeam();
-          owner.workflowId = workflow.id;
-          owner.projectId = workflow.projectId;
-          owner.teamId = new ObjectID(teamId);
-          owner.isOwnerNotified = !notify;
-          await WorkflowOwnerTeamService.create({
-            data: owner,
-            props: { isRoot: true },
-          });
-        }
+    if (
+      matchedRules.length === 0 ||
+      (allUserIds.size === 0 && allTeamIds.size === 0)
+    ) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
+
+    // Owners already on the workflow are skipped rather than duplicated.
+    const notYetAssigned: OwnersToAssign =
+      await OwnerRuleAssignment.getOwnersNotYetAssigned({
+        ownerUserService: WorkflowOwnerUserService,
+        ownerTeamService: WorkflowOwnerTeamService,
+        resourceIdColumn: "workflowId",
+        resourceId: workflow.id,
+        userIds: Array.from(allUserIds),
+        teamIds: Array.from(allTeamIds),
+      });
+
+    const userIdsToAdd: Set<string> = new Set(
+      notYetAssigned.userIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+    const teamIdsToAdd: Set<string> = new Set(
+      notYetAssigned.teamIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    let ownersAdded: number = 0;
+
+    /*
+     * The notifying set goes first, so an owner two matching rules disagree
+     * about is added once, and notified.
+     */
+    for (const notify of [true, false]) {
+      const userIds: Array<string> = Array.from(
+        usersByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return userIdsToAdd.delete(id);
+      });
+      const teamIds: Array<string> = Array.from(
+        teamsByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return teamIdsToAdd.delete(id);
+      });
+
+      for (const userId of userIds) {
+        const owner: WorkflowOwnerUser = new WorkflowOwnerUser();
+        owner.workflowId = workflow.id;
+        owner.projectId = workflow.projectId;
+        owner.userId = new ObjectID(userId);
+        owner.isOwnerNotified = !notify;
+        await WorkflowOwnerUserService.create({
+          data: owner,
+          props: { isRoot: true },
+        });
+        ownersAdded++;
       }
 
-      logger.debug(
-        `WorkflowOwnerRuleEngine added owners to workflow ${workflow.id}`,
-        { projectId: workflow.projectId.toString() } as LogAttributes,
-      );
-    } catch (error) {
-      logger.error(`Error applying workflow owner rules: ${error}`, {
-        projectId: workflow.projectId?.toString(),
-        workflowId: workflow.id?.toString(),
-      } as LogAttributes);
+      for (const teamId of teamIds) {
+        const owner: WorkflowOwnerTeam = new WorkflowOwnerTeam();
+        owner.workflowId = workflow.id;
+        owner.projectId = workflow.projectId;
+        owner.teamId = new ObjectID(teamId);
+        owner.isOwnerNotified = !notify;
+        await WorkflowOwnerTeamService.create({
+          data: owner,
+          props: { isRoot: true },
+        });
+        ownersAdded++;
+      }
     }
+
+    if (ownersAdded === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
+
+    logger.debug(
+      `WorkflowOwnerRuleEngine added owners to workflow ${workflow.id}`,
+      { projectId: workflow.projectId.toString() } as LogAttributes,
+    );
+
+    return RuleApplicationResultUtil.updated(ownersAdded);
   }
 
   private doesWorkflowMatchRule(

package/Server/Types/Database/UpdateByID.ts

@@ -2,9 +2,12 @@ import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/Database
 import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import ObjectID from "../../../Types/ObjectID";
 import QueryDeepPartialEntity from "../../../Types/Database/PartialEntity";
+import { JSONObject } from "../../../Types/JSON";
 
 export default interface UpdateBy<TBaseModel extends BaseModel> {
   id: ObjectID;
   data: QueryDeepPartialEntity<TBaseModel>;
+  // See UpdateOneBy.miscDataProps.
+  miscDataProps?: JSONObject | undefined;
   props: DatabaseCommonInteractionProps;
 }

package/Server/Types/Database/UpdateOneBy.ts

@@ -2,9 +2,16 @@ import Query from "./Query";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import PartialEntity from "../../../Types/Database/PartialEntity";
+import { JSONObject } from "../../../Types/JSON";
 
 export default interface UpdateOneBy<TBaseModel extends BaseModel> {
   query: Query<TBaseModel>;
   data: PartialEntity<TBaseModel>;
+  /*
+   * Request-scoped choices that are not columns, read by a service's update
+   * hooks - the update-side twin of CreateBy.miscDataProps. For example,
+   * whether an edit to a public note should notify status page subscribers.
+   */
+  miscDataProps?: JSONObject | undefined;
   props: DatabaseCommonInteractionProps;
 }

package/Server/Utils/AI/AlertAIContextBuilder.ts

@@ -47,6 +47,9 @@ export default class AlertAIContextBuilder {
         monitor: {
           name: true,
         },
+        serviceLevelObjectives: {
+          name: true,
+        },
         labels: {
           name: true,
           color: true,
@@ -148,6 +151,22 @@ export default class AlertAIContextBuilder {
       contextText += `**Monitor:** ${alert.monitor.name || "N/A"}\n\n`;
     }
 
+    /*
+     * Affected SLOs. A burn-rate alert has no monitor, so this is what tells
+     * the model which objective is burning its error budget.
+     */
+    const affectedSloNames: Array<string> = (alert.serviceLevelObjectives || [])
+      .map((slo: { name?: string | undefined }): string => {
+        return slo.name || "";
+      })
+      .filter((name: string): boolean => {
+        return name.length > 0;
+      });
+
+    if (affectedSloNames.length > 0) {
+      contextText += `**Affected SLOs:** ${affectedSloNames.join(", ")}\n\n`;
+    }
+
     // Labels
     if (alert.labels && alert.labels.length > 0) {
       contextText += "**Labels:** ";

package/Server/Utils/AI/IncidentAIContextBuilder.ts

@@ -62,6 +62,9 @@ export default class IncidentAIContextBuilder {
         monitors: {
           name: true,
         },
+        serviceLevelObjectives: {
+          name: true,
+        },
         labels: {
           name: true,
           color: true,
@@ -241,6 +244,24 @@ export default class IncidentAIContextBuilder {
       contextText += "\n\n";
     }
 
+    /*
+     * Affected SLOs. A burn-rate incident has no monitors, so without this
+     * the model would see an incident about nothing in particular.
+     */
+    const affectedSloNames: Array<string> = (
+      incident.serviceLevelObjectives || []
+    )
+      .map((slo: { name?: string | undefined }): string => {
+        return slo.name || "";
+      })
+      .filter((name: string): boolean => {
+        return name.length > 0;
+      });
+
+    if (affectedSloNames.length > 0) {
+      contextText += `**Affected SLOs:** ${affectedSloNames.join(", ")}\n\n`;
+    }
+
     // Labels
     if (incident.labels && incident.labels.length > 0) {
       contextText += "**Labels:** ";
@@ -432,6 +453,24 @@ Grounding rules (important):
       contextText += "\n\n";
     }
 
+    /*
+     * Affected SLOs. A burn-rate incident has no monitors, so without this
+     * the model would see an incident about nothing in particular.
+     */
+    const affectedSloNames: Array<string> = (
+      incident.serviceLevelObjectives || []
+    )
+      .map((slo: { name?: string | undefined }): string => {
+        return slo.name || "";
+      })
+      .filter((name: string): boolean => {
+        return name.length > 0;
+      });
+
+    if (affectedSloNames.length > 0) {
+      contextText += `**Affected SLOs:** ${affectedSloNames.join(", ")}\n\n`;
+    }
+
     // Labels
     if (incident.labels && incident.labels.length > 0) {
       contextText += "**Labels:** ";

package/Server/Utils/AI/Toolbox/AlertTools.ts

@@ -39,10 +39,33 @@ const resolveReadPermissions: () => Array<Permission> =
 
 type AlertStateFilter = "active" | "resolved" | "any";
 
+/*
+ * The SLOs an alert is linked to, as one comma-separated value. An SLO burn
+ * rate alert has no monitor, so this is the only source such a row can name;
+ * undefined when there are none, so the serializer drops the field.
+ */
+type JoinSloNamesFunction = (
+  serviceLevelObjectives: Array<{ name?: string | undefined }> | undefined,
+) => string | undefined;
+
+const joinSloNames: JoinSloNamesFunction = (
+  serviceLevelObjectives: Array<{ name?: string | undefined }> | undefined,
+): string | undefined => {
+  const names: Array<string> = (serviceLevelObjectives || [])
+    .map((slo: { name?: string | undefined }): string => {
+      return slo.name || "";
+    })
+    .filter((name: string): boolean => {
+      return name.length > 0;
+    });
+
+  return names.length > 0 ? names.join(", ") : undefined;
+};
+
 export const QueryAlertsTool: ObservabilityTool = {
   name: "query_alerts",
   description:
-    "Query alerts in this project with their current state and severity. Every row also carries the monitor the alert was raised for, so counting rows by monitor answers 'which monitor or source is the noisiest?'. To answer 'which alerts are active/firing right now?' pass state='active' — it returns every unresolved alert regardless of age (no time window unless createdWithinHours is passed explicitly). state='resolved' returns only resolved alerts; the default 'any' returns both, limited to the createdWithinHours window. Results are newest-first; the result reports the total match count — pass skip to page through more. Pass alertId to get full details of one alert, including its description and its owners (teams and users).",
+    "Query alerts in this project with their current state and severity. Every row also carries the monitor the alert was raised for — or, for an alert raised by an SLO burn rate rule, the SLO (slos) — so counting rows by monitor or SLO answers 'which monitor or source is the noisiest?'. To answer 'which alerts are active/firing right now?' pass state='active' — it returns every unresolved alert regardless of age (no time window unless createdWithinHours is passed explicitly). state='resolved' returns only resolved alerts; the default 'any' returns both, limited to the createdWithinHours window. Results are newest-first; the result reports the total match count — pass skip to page through more. Pass alertId to get full details of one alert, including its description and its owners (teams and users).",
   inputSchema: {
     type: "object",
     properties: {
@@ -100,6 +123,13 @@ export const QueryAlertsTool: ObservabilityTool = {
           monitor: {
             name: true,
           },
+          /*
+           * name is flagged canReadOnRelationQuery on the SLO, so this reads
+           * for a caller who can see alerts but not SLOs.
+           */
+          serviceLevelObjectives: {
+            name: true,
+          },
         },
         props: ctx.props,
       });
@@ -181,6 +211,7 @@ export const QueryAlertsTool: ObservabilityTool = {
               state: alert.currentAlertState?.name,
               severity: alert.alertSeverity?.name,
               monitor: alert.monitor?.name,
+              slos: joinSloNames(alert.serviceLevelObjectives),
               createdAt: alert.createdAt,
               ownerTeams: ownerTeamNames || undefined,
               ownerUsers: ownerUserNames || undefined,
@@ -299,6 +330,10 @@ export const QueryAlertsTool: ObservabilityTool = {
         monitor: {
           name: true,
         },
+        // A burn-rate alert has no monitor; the SLO is its source.
+        serviceLevelObjectives: {
+          name: true,
+        },
       },
       sort: {
         createdAt: SortOrder.Descending,
@@ -323,6 +358,7 @@ export const QueryAlertsTool: ObservabilityTool = {
         state: alert.currentAlertState?.name,
         severity: alert.alertSeverity?.name,
         monitor: alert.monitor?.name,
+        slos: joinSloNames(alert.serviceLevelObjectives),
         createdAt: alert.createdAt,
       };
     });

package/Server/Utils/AI/Toolbox/IncidentTools.ts

@@ -51,7 +51,7 @@ const resolveReadPermissions: () => Array<Permission> =
 export const QueryIncidentsTool: ObservabilityTool = {
   name: "query_incidents",
   description:
-    'Query incidents in this project. Returns the most recent incidents with their current state and severity. Pass state="active" to list currently unresolved incidents regardless of when they were created (use this for \'what incidents are active/open right now?\'), or state="resolved" for closed ones. Pass incidentId to get full details of one incident — including its owner teams and owner users, affected monitors, labels, root cause, remediation and postmortem notes, and the incident window (telemetryWindowStart) to pivot into logs/traces/metrics for the affected services. For the incident\'s activity thread — state changes, notes and the latest updates — use get_incident_timeline.',
+    'Query incidents in this project. Returns the most recent incidents with their current state and severity. Pass state="active" to list currently unresolved incidents regardless of when they were created (use this for \'what incidents are active/open right now?\'), or state="resolved" for closed ones. Pass incidentId to get full details of one incident — including its owner teams and owner users, affected monitors, affected SLOs (set when an SLO burn rate rule declared it), labels, root cause, remediation and postmortem notes, and the incident window (telemetryWindowStart) to pivot into logs/traces/metrics for the affected services. For the incident\'s activity thread — state changes, notes and the latest updates — use get_incident_timeline.',
   inputSchema: {
     type: "object",
     properties: {
@@ -112,6 +112,13 @@ export const QueryIncidentsTool: ObservabilityTool = {
             _id: true,
             name: true,
           },
+          /*
+           * name is flagged canReadOnRelationQuery on the SLO, so this reads
+           * for a caller who can see incidents but not SLOs.
+           */
+          serviceLevelObjectives: {
+            name: true,
+          },
           labels: {
             name: true,
           },
@@ -207,6 +214,19 @@ export const QueryIncidentsTool: ObservabilityTool = {
         })
         .join(", ");
 
+      /*
+       * A burn-rate incident has no monitors, so its SLO is the blast radius:
+       * the objective whose error budget is burning.
+       */
+      const affectedSlos: string = (incident?.serviceLevelObjectives || [])
+        .map((slo: { name?: string | undefined }) => {
+          return slo.name || "";
+        })
+        .filter((value: string) => {
+          return value.length > 0;
+        })
+        .join(", ");
+
       const incidentLabels: string = (incident?.labels || [])
         .map((label: { name?: string }) => {
           return label.name || "";
@@ -229,6 +249,7 @@ export const QueryIncidentsTool: ObservabilityTool = {
               ownerTeams: ownerTeamNames || undefined,
               ownerUsers: ownerUserNames || undefined,
               affectedMonitors: affectedMonitors || undefined,
+              affectedSlos: affectedSlos || undefined,
               labels: incidentLabels || undefined,
               rootCause: incident.rootCause,
               remediationNotes: incident.remediationNotes,