@oneuptime/common 13.0.4 → 13.0.6

package/build/dist/Server/Services/AlertOwnerRuleEngineService.js

@@ -11,6 +11,8 @@ import Alert from "../../Models/DatabaseModels/Alert";
 import AlertOwnerRule from "../../Models/DatabaseModels/AlertOwnerRule";
 import AlertFeedService from "./AlertFeedService";
 import AlertOwnerRuleService from "./AlertOwnerRuleService";
+import AlertOwnerTeamService from "./AlertOwnerTeamService";
+import AlertOwnerUserService from "./AlertOwnerUserService";
 import AlertService from "./AlertService";
 import DockerHostOwnerTeamService from "./DockerHostOwnerTeamService";
 import DockerHostOwnerUserService from "./DockerHostOwnerUserService";
@@ -37,13 +39,77 @@ import logger from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
+import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
+import { RuleApplicationResultUtil, } from "../Utils/Rules/RuleRun/RuleApplication";
+/*
+ * Whether any owner that was actually added came from one inherited source.
+ * The feed note names a source only for owners it lists, and an inherited
+ * owner the alert already had is not listed.
+ */
+function addedAnyInheritedOwner(data) {
+    for (const id of data.inheritedUserIds) {
+        if (data.addedUserIds.has(id)) {
+            return true;
+        }
+    }
+    for (const id of data.inheritedTeamIds) {
+        if (data.addedTeamIds.has(id)) {
+            return true;
+        }
+    }
+    return false;
+}
 class AlertOwnerRuleEngineServiceClass {
+    constructor() {
+        this.ruleSelect = {
+            _id: true,
+            name: true,
+            criteria: true,
+            notifyOwners: true,
+            monitors: { _id: true },
+            alertSeverities: { _id: true },
+            alertLabels: { _id: true },
+            monitorLabels: { _id: true },
+            alertTitlePattern: true,
+            alertDescriptionPattern: true,
+            monitorNamePattern: true,
+            monitorDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+            inheritOwnersFromMonitors: true,
+            inheritOwnersFromHosts: true,
+            inheritOwnersFromKubernetesClusters: true,
+            inheritOwnersFromDockerHosts: true,
+            inheritOwnersFromPodmanHosts: true,
+            inheritOwnersFromServices: true,
+        };
+        /*
+         * Matching and inheritance read all of these straight off the alert they
+         * are handed instead of re-reading it, so a run has to load every one: a
+         * column left out here is a criterion a run silently never matches on, or
+         * a resource it silently never inherits owners from.
+         */
+        this.resourceSelectForRuleRun = {
+            _id: true,
+            projectId: true,
+            title: true,
+            description: true,
+            alertSeverityId: true,
+            monitorId: true,
+            labels: { _id: true },
+            hosts: { _id: true },
+            kubernetesClusters: { _id: true },
+            dockerHosts: { _id: true },
+            podmanHosts: { _id: true },
+            services: { _id: true },
+        };
+    }
     /**
      * Evaluates AlertOwnerRule rows for the given alert and adds matched
      * owner users / teams via AlertService.addOwners.
      */
     async applyRulesToAlert(alert) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b;
         if (!alert.id || !alert.projectId) {
             return;
         }
@@ -54,28 +120,7 @@ class AlertOwnerRuleEngineServiceClass {
                     isEnabled: true,
                 },
                 props: { isRoot: true },
-                select: {
-                    _id: true,
-                    name: true,
-                    criteria: true,
-                    notifyOwners: true,
-                    monitors: { _id: true },
-                    alertSeverities: { _id: true },
-                    alertLabels: { _id: true },
-                    monitorLabels: { _id: true },
-                    alertTitlePattern: true,
-                    alertDescriptionPattern: true,
-                    monitorNamePattern: true,
-                    monitorDescriptionPattern: true,
-                    ownerUsers: { _id: true },
-                    ownerTeams: { _id: true },
-                    inheritOwnersFromMonitors: true,
-                    inheritOwnersFromHosts: true,
-                    inheritOwnersFromKubernetesClusters: true,
-                    inheritOwnersFromDockerHosts: true,
-                    inheritOwnersFromPodmanHosts: true,
-                    inheritOwnersFromServices: true,
-                },
+                select: this.ruleSelect,
                 limit: MAX_RULES_EVALUATED_PER_PROJECT,
                 skip: 0,
             });
@@ -87,385 +132,478 @@ class AlertOwnerRuleEngineServiceClass {
             if (rules.length === 0) {
                 return;
             }
-            const usersByNotify = new Map([
-                [true, new Set()],
-                [false, new Set()],
-            ]);
-            const teamsByNotify = new Map([
-                [true, new Set()],
-                [false, new Set()],
-            ]);
-            const matchedRules = [];
-            const allUserIds = new Set();
-            const allTeamIds = new Set();
-            let inheritFromMonitors = false;
-            let inheritFromHosts = false;
-            let inheritFromKubernetesClusters = false;
-            let inheritFromDockerHosts = false;
-            let inheritFromPodmanHosts = false;
-            let inheritFromServices = false;
-            const inheritNotifyMode = { value: null };
-            for (const rule of rules) {
-                const matches = await this.doesAlertMatchRule(alert, rule);
-                if (!matches) {
-                    continue;
-                }
-                let ruleAddedAny = false;
-                const notify = rule.notifyOwners !== false;
-                for (const user of rule.ownerUsers || []) {
-                    if (user.id) {
-                        usersByNotify.get(notify).add(user.id.toString());
-                        allUserIds.add(user.id.toString());
-                        ruleAddedAny = true;
-                    }
-                }
-                for (const team of rule.ownerTeams || []) {
-                    if (team.id) {
-                        teamsByNotify.get(notify).add(team.id.toString());
-                        allTeamIds.add(team.id.toString());
-                        ruleAddedAny = true;
-                    }
-                }
-                if (rule.inheritOwnersFromMonitors) {
-                    inheritFromMonitors = true;
-                    ruleAddedAny = true;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
-                }
-                if (rule.inheritOwnersFromHosts) {
-                    inheritFromHosts = true;
-                    ruleAddedAny = true;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
-                }
-                if (rule.inheritOwnersFromKubernetesClusters) {
-                    inheritFromKubernetesClusters = true;
-                    ruleAddedAny = true;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
-                }
-                if (rule.inheritOwnersFromDockerHosts) {
-                    inheritFromDockerHosts = true;
+            await this.applyRules({
+                alert: alert,
+                rules: rules,
+                allowOwnerNotification: true,
+            });
+        }
+        catch (error) {
+            logger.error(`Error applying alert owner rules: ${error}`, {
+                projectId: (_a = alert.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                alertId: (_b = alert.id) === null || _b === void 0 ? void 0 : _b.toString(),
+            });
+        }
+    }
+    /*
+     * "Run now": the same evaluation, for an alert that already exists and only
+     * the rules being run.
+     */
+    async applyRulesToExistingResource(data) {
+        var _a, _b;
+        try {
+            return await this.applyRules({
+                alert: data.resource,
+                rules: data.rules,
+                allowOwnerNotification: data.allowOwnerNotification,
+            });
+        }
+        catch (error) {
+            logger.error(`Error running alert owner rules: ${error}`, {
+                projectId: (_a = data.resource.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                alertId: (_b = data.resource.id) === null || _b === void 0 ? void 0 : _b.toString(),
+            });
+            return RuleApplicationResultUtil.failed();
+        }
+    }
+    async applyRules(data) {
+        var _a, _b, _c, _d, _e;
+        const { alert, rules } = data;
+        if (!alert.id || !alert.projectId || rules.length === 0) {
+            return RuleApplicationResultUtil.noMatch();
+        }
+        const usersByNotify = new Map([
+            [true, new Set()],
+            [false, new Set()],
+        ]);
+        const teamsByNotify = new Map([
+            [true, new Set()],
+            [false, new Set()],
+        ]);
+        const matchedRules = [];
+        const allUserIds = new Set();
+        const allTeamIds = new Set();
+        let inheritFromMonitors = false;
+        let inheritFromHosts = false;
+        let inheritFromKubernetesClusters = false;
+        let inheritFromDockerHosts = false;
+        let inheritFromPodmanHosts = false;
+        let inheritFromServices = false;
+        const inheritNotifyMode = { value: null };
+        let anyRuleMatched = false;
+        for (const rule of rules) {
+            const matches = await this.doesAlertMatchRule(alert, rule);
+            if (!matches) {
+                continue;
+            }
+            anyRuleMatched = true;
+            let ruleAddedAny = false;
+            const notify = 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;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
                 }
-                if (rule.inheritOwnersFromPodmanHosts) {
-                    inheritFromPodmanHosts = true;
+            }
+            for (const team of rule.ownerTeams || []) {
+                if (team.id) {
+                    teamsByNotify.get(notify).add(team.id.toString());
+                    allTeamIds.add(team.id.toString());
                     ruleAddedAny = true;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
                 }
-                if (rule.inheritOwnersFromServices) {
-                    inheritFromServices = true;
-                    ruleAddedAny = true;
-                    inheritNotifyMode.value =
-                        inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromMonitors) {
+                inheritFromMonitors = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromHosts) {
+                inheritFromHosts = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromKubernetesClusters) {
+                inheritFromKubernetesClusters = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromDockerHosts) {
+                inheritFromDockerHosts = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromPodmanHosts) {
+                inheritFromPodmanHosts = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (rule.inheritOwnersFromServices) {
+                inheritFromServices = true;
+                ruleAddedAny = true;
+                inheritNotifyMode.value =
+                    inheritNotifyMode.value === true ? true : notify;
+            }
+            if (ruleAddedAny) {
+                matchedRules.push(rule);
+            }
+        }
+        if (!anyRuleMatched) {
+            return RuleApplicationResultUtil.noMatch();
+        }
+        const inheritedFromMonitorUserIds = new Set();
+        const inheritedFromMonitorTeamIds = new Set();
+        const inheritedFromHostUserIds = new Set();
+        const inheritedFromHostTeamIds = new Set();
+        const inheritedFromKubernetesClusterUserIds = new Set();
+        const inheritedFromKubernetesClusterTeamIds = new Set();
+        const inheritedFromDockerHostUserIds = new Set();
+        const inheritedFromDockerHostTeamIds = new Set();
+        const inheritedFromPodmanHostUserIds = new Set();
+        const inheritedFromPodmanHostTeamIds = new Set();
+        const inheritedFromServiceUserIds = new Set();
+        const inheritedFromServiceTeamIds = new Set();
+        if (inheritFromMonitors && alert.monitorId) {
+            const [monitorOwnerUsers, monitorOwnerTeams] = await Promise.all([
+                MonitorOwnerUserService.findBy({
+                    query: { monitorId: alert.monitorId },
+                    select: { userId: true },
+                    props: { isRoot: true },
+                    limit: LIMIT_MAX,
+                    skip: 0,
+                }),
+                MonitorOwnerTeamService.findBy({
+                    query: { monitorId: alert.monitorId },
+                    select: { teamId: true },
+                    props: { isRoot: true },
+                    limit: LIMIT_MAX,
+                    skip: 0,
+                }),
+            ]);
+            for (const ownerUser of monitorOwnerUsers) {
+                if (ownerUser.userId) {
+                    inheritedFromMonitorUserIds.add(ownerUser.userId.toString());
                 }
-                if (ruleAddedAny) {
-                    matchedRules.push(rule);
+            }
+            for (const ownerTeam of monitorOwnerTeams) {
+                if (ownerTeam.teamId) {
+                    inheritedFromMonitorTeamIds.add(ownerTeam.teamId.toString());
                 }
             }
-            const inheritedFromMonitorUserIds = new Set();
-            const inheritedFromMonitorTeamIds = new Set();
-            const inheritedFromHostUserIds = new Set();
-            const inheritedFromHostTeamIds = new Set();
-            const inheritedFromKubernetesClusterUserIds = new Set();
-            const inheritedFromKubernetesClusterTeamIds = new Set();
-            const inheritedFromDockerHostUserIds = new Set();
-            const inheritedFromDockerHostTeamIds = new Set();
-            const inheritedFromPodmanHostUserIds = new Set();
-            const inheritedFromPodmanHostTeamIds = new Set();
-            const inheritedFromServiceUserIds = new Set();
-            const inheritedFromServiceTeamIds = new Set();
-            if (inheritFromMonitors && alert.monitorId) {
-                const [monitorOwnerUsers, monitorOwnerTeams] = await Promise.all([
-                    MonitorOwnerUserService.findBy({
-                        query: { monitorId: alert.monitorId },
+        }
+        if (inheritFromHosts && ((_a = alert.hosts) === null || _a === void 0 ? void 0 : _a.length)) {
+            const hostIds = alert.hosts
+                .map((h) => {
+                return h.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            if (hostIds.length > 0) {
+                const [hostOwnerUsers, hostOwnerTeams] = await Promise.all([
+                    HostOwnerUserService.findBy({
+                        query: { hostId: QueryHelper.any(hostIds) },
                         select: { userId: true },
                         props: { isRoot: true },
                         limit: LIMIT_MAX,
                         skip: 0,
                     }),
-                    MonitorOwnerTeamService.findBy({
-                        query: { monitorId: alert.monitorId },
+                    HostOwnerTeamService.findBy({
+                        query: { hostId: QueryHelper.any(hostIds) },
                         select: { teamId: true },
                         props: { isRoot: true },
                         limit: LIMIT_MAX,
                         skip: 0,
                     }),
                 ]);
-                for (const ownerUser of monitorOwnerUsers) {
+                for (const ownerUser of hostOwnerUsers) {
                     if (ownerUser.userId) {
-                        inheritedFromMonitorUserIds.add(ownerUser.userId.toString());
+                        inheritedFromHostUserIds.add(ownerUser.userId.toString());
                     }
                 }
-                for (const ownerTeam of monitorOwnerTeams) {
+                for (const ownerTeam of hostOwnerTeams) {
                     if (ownerTeam.teamId) {
-                        inheritedFromMonitorTeamIds.add(ownerTeam.teamId.toString());
+                        inheritedFromHostTeamIds.add(ownerTeam.teamId.toString());
                     }
                 }
             }
-            if (inheritFromHosts && ((_a = alert.hosts) === null || _a === void 0 ? void 0 : _a.length)) {
-                const hostIds = alert.hosts
-                    .map((h) => {
-                    return h.id;
-                })
-                    .filter((id) => {
-                    return Boolean(id);
-                });
-                if (hostIds.length > 0) {
-                    const [hostOwnerUsers, hostOwnerTeams] = await Promise.all([
-                        HostOwnerUserService.findBy({
-                            query: { hostId: QueryHelper.any(hostIds) },
-                            select: { userId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                        HostOwnerTeamService.findBy({
-                            query: { hostId: QueryHelper.any(hostIds) },
-                            select: { teamId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                    ]);
-                    for (const ownerUser of hostOwnerUsers) {
-                        if (ownerUser.userId) {
-                            inheritedFromHostUserIds.add(ownerUser.userId.toString());
-                        }
-                    }
-                    for (const ownerTeam of hostOwnerTeams) {
-                        if (ownerTeam.teamId) {
-                            inheritedFromHostTeamIds.add(ownerTeam.teamId.toString());
-                        }
+        }
+        if (inheritFromKubernetesClusters && ((_b = alert.kubernetesClusters) === null || _b === void 0 ? void 0 : _b.length)) {
+            const clusterIds = alert.kubernetesClusters
+                .map((c) => {
+                return c.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            if (clusterIds.length > 0) {
+                const [clusterOwnerUsers, clusterOwnerTeams] = await Promise.all([
+                    KubernetesClusterOwnerUserService.findBy({
+                        query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
+                        select: { userId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                    KubernetesClusterOwnerTeamService.findBy({
+                        query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
+                        select: { teamId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                ]);
+                for (const ownerUser of clusterOwnerUsers) {
+                    if (ownerUser.userId) {
+                        inheritedFromKubernetesClusterUserIds.add(ownerUser.userId.toString());
                     }
                 }
-            }
-            if (inheritFromKubernetesClusters && ((_b = alert.kubernetesClusters) === null || _b === void 0 ? void 0 : _b.length)) {
-                const clusterIds = alert.kubernetesClusters
-                    .map((c) => {
-                    return c.id;
-                })
-                    .filter((id) => {
-                    return Boolean(id);
-                });
-                if (clusterIds.length > 0) {
-                    const [clusterOwnerUsers, clusterOwnerTeams] = await Promise.all([
-                        KubernetesClusterOwnerUserService.findBy({
-                            query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
-                            select: { userId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                        KubernetesClusterOwnerTeamService.findBy({
-                            query: { kubernetesClusterId: QueryHelper.any(clusterIds) },
-                            select: { teamId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                    ]);
-                    for (const ownerUser of clusterOwnerUsers) {
-                        if (ownerUser.userId) {
-                            inheritedFromKubernetesClusterUserIds.add(ownerUser.userId.toString());
-                        }
-                    }
-                    for (const ownerTeam of clusterOwnerTeams) {
-                        if (ownerTeam.teamId) {
-                            inheritedFromKubernetesClusterTeamIds.add(ownerTeam.teamId.toString());
-                        }
+                for (const ownerTeam of clusterOwnerTeams) {
+                    if (ownerTeam.teamId) {
+                        inheritedFromKubernetesClusterTeamIds.add(ownerTeam.teamId.toString());
                     }
                 }
             }
-            if (inheritFromDockerHosts && ((_c = alert.dockerHosts) === null || _c === void 0 ? void 0 : _c.length)) {
-                const dockerHostIds = alert.dockerHosts
-                    .map((d) => {
-                    return d.id;
-                })
-                    .filter((id) => {
-                    return Boolean(id);
-                });
-                if (dockerHostIds.length > 0) {
-                    const [dockerHostOwnerUsers, dockerHostOwnerTeams] = await Promise.all([
-                        DockerHostOwnerUserService.findBy({
-                            query: { dockerHostId: QueryHelper.any(dockerHostIds) },
-                            select: { userId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                        DockerHostOwnerTeamService.findBy({
-                            query: { dockerHostId: QueryHelper.any(dockerHostIds) },
-                            select: { teamId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                    ]);
-                    for (const ownerUser of dockerHostOwnerUsers) {
-                        if (ownerUser.userId) {
-                            inheritedFromDockerHostUserIds.add(ownerUser.userId.toString());
-                        }
-                    }
-                    for (const ownerTeam of dockerHostOwnerTeams) {
-                        if (ownerTeam.teamId) {
-                            inheritedFromDockerHostTeamIds.add(ownerTeam.teamId.toString());
-                        }
+        }
+        if (inheritFromDockerHosts && ((_c = alert.dockerHosts) === null || _c === void 0 ? void 0 : _c.length)) {
+            const dockerHostIds = alert.dockerHosts
+                .map((d) => {
+                return d.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            if (dockerHostIds.length > 0) {
+                const [dockerHostOwnerUsers, dockerHostOwnerTeams] = await Promise.all([
+                    DockerHostOwnerUserService.findBy({
+                        query: { dockerHostId: QueryHelper.any(dockerHostIds) },
+                        select: { userId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                    DockerHostOwnerTeamService.findBy({
+                        query: { dockerHostId: QueryHelper.any(dockerHostIds) },
+                        select: { teamId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                ]);
+                for (const ownerUser of dockerHostOwnerUsers) {
+                    if (ownerUser.userId) {
+                        inheritedFromDockerHostUserIds.add(ownerUser.userId.toString());
                     }
                 }
-            }
-            if (inheritFromPodmanHosts && ((_d = alert.podmanHosts) === null || _d === void 0 ? void 0 : _d.length)) {
-                const podmanHostIds = alert.podmanHosts
-                    .map((p) => {
-                    return p.id;
-                })
-                    .filter((id) => {
-                    return Boolean(id);
-                });
-                if (podmanHostIds.length > 0) {
-                    const [podmanHostOwnerUsers, podmanHostOwnerTeams] = await Promise.all([
-                        PodmanHostOwnerUserService.findBy({
-                            query: { podmanHostId: QueryHelper.any(podmanHostIds) },
-                            select: { userId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                        PodmanHostOwnerTeamService.findBy({
-                            query: { podmanHostId: QueryHelper.any(podmanHostIds) },
-                            select: { teamId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                    ]);
-                    for (const ownerUser of podmanHostOwnerUsers) {
-                        if (ownerUser.userId) {
-                            inheritedFromPodmanHostUserIds.add(ownerUser.userId.toString());
-                        }
-                    }
-                    for (const ownerTeam of podmanHostOwnerTeams) {
-                        if (ownerTeam.teamId) {
-                            inheritedFromPodmanHostTeamIds.add(ownerTeam.teamId.toString());
-                        }
+                for (const ownerTeam of dockerHostOwnerTeams) {
+                    if (ownerTeam.teamId) {
+                        inheritedFromDockerHostTeamIds.add(ownerTeam.teamId.toString());
                     }
                 }
             }
-            if (inheritFromServices && ((_e = alert.services) === null || _e === void 0 ? void 0 : _e.length)) {
-                const serviceIds = alert.services
-                    .map((s) => {
-                    return s.id;
-                })
-                    .filter((id) => {
-                    return Boolean(id);
-                });
-                if (serviceIds.length > 0) {
-                    const [serviceOwnerUsers, serviceOwnerTeams] = await Promise.all([
-                        ServiceOwnerUserService.findBy({
-                            query: { serviceId: QueryHelper.any(serviceIds) },
-                            select: { userId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                        ServiceOwnerTeamService.findBy({
-                            query: { serviceId: QueryHelper.any(serviceIds) },
-                            select: { teamId: true },
-                            props: { isRoot: true },
-                            limit: LIMIT_MAX,
-                            skip: 0,
-                        }),
-                    ]);
-                    for (const ownerUser of serviceOwnerUsers) {
-                        if (ownerUser.userId) {
-                            inheritedFromServiceUserIds.add(ownerUser.userId.toString());
-                        }
+        }
+        if (inheritFromPodmanHosts && ((_d = alert.podmanHosts) === null || _d === void 0 ? void 0 : _d.length)) {
+            const podmanHostIds = alert.podmanHosts
+                .map((p) => {
+                return p.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            if (podmanHostIds.length > 0) {
+                const [podmanHostOwnerUsers, podmanHostOwnerTeams] = await Promise.all([
+                    PodmanHostOwnerUserService.findBy({
+                        query: { podmanHostId: QueryHelper.any(podmanHostIds) },
+                        select: { userId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                    PodmanHostOwnerTeamService.findBy({
+                        query: { podmanHostId: QueryHelper.any(podmanHostIds) },
+                        select: { teamId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                ]);
+                for (const ownerUser of podmanHostOwnerUsers) {
+                    if (ownerUser.userId) {
+                        inheritedFromPodmanHostUserIds.add(ownerUser.userId.toString());
                     }
-                    for (const ownerTeam of serviceOwnerTeams) {
-                        if (ownerTeam.teamId) {
-                            inheritedFromServiceTeamIds.add(ownerTeam.teamId.toString());
-                        }
+                }
+                for (const ownerTeam of podmanHostOwnerTeams) {
+                    if (ownerTeam.teamId) {
+                        inheritedFromPodmanHostTeamIds.add(ownerTeam.teamId.toString());
                     }
                 }
             }
-            const inheritedUserIds = new Set([
-                ...inheritedFromMonitorUserIds,
-                ...inheritedFromHostUserIds,
-                ...inheritedFromKubernetesClusterUserIds,
-                ...inheritedFromDockerHostUserIds,
-                ...inheritedFromPodmanHostUserIds,
-                ...inheritedFromServiceUserIds,
-            ]);
-            const inheritedTeamIds = new Set([
-                ...inheritedFromMonitorTeamIds,
-                ...inheritedFromHostTeamIds,
-                ...inheritedFromKubernetesClusterTeamIds,
-                ...inheritedFromDockerHostTeamIds,
-                ...inheritedFromPodmanHostTeamIds,
-                ...inheritedFromServiceTeamIds,
-            ]);
-            if (inheritedUserIds.size > 0 || inheritedTeamIds.size > 0) {
-                const inheritNotify = inheritNotifyMode.value === true;
-                for (const id of inheritedUserIds) {
-                    usersByNotify.get(inheritNotify).add(id);
-                    allUserIds.add(id);
+        }
+        if (inheritFromServices && ((_e = alert.services) === null || _e === void 0 ? void 0 : _e.length)) {
+            const serviceIds = alert.services
+                .map((s) => {
+                return s.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            if (serviceIds.length > 0) {
+                const [serviceOwnerUsers, serviceOwnerTeams] = await Promise.all([
+                    ServiceOwnerUserService.findBy({
+                        query: { serviceId: QueryHelper.any(serviceIds) },
+                        select: { userId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                    ServiceOwnerTeamService.findBy({
+                        query: { serviceId: QueryHelper.any(serviceIds) },
+                        select: { teamId: true },
+                        props: { isRoot: true },
+                        limit: LIMIT_MAX,
+                        skip: 0,
+                    }),
+                ]);
+                for (const ownerUser of serviceOwnerUsers) {
+                    if (ownerUser.userId) {
+                        inheritedFromServiceUserIds.add(ownerUser.userId.toString());
+                    }
                 }
-                for (const id of inheritedTeamIds) {
-                    teamsByNotify.get(inheritNotify).add(id);
-                    allTeamIds.add(id);
+                for (const ownerTeam of serviceOwnerTeams) {
+                    if (ownerTeam.teamId) {
+                        inheritedFromServiceTeamIds.add(ownerTeam.teamId.toString());
+                    }
                 }
             }
-            if (matchedRules.length === 0) {
-                return;
-            }
-            if (allUserIds.size === 0 && allTeamIds.size === 0) {
-                return;
+        }
+        const inheritedUserIds = new Set([
+            ...inheritedFromMonitorUserIds,
+            ...inheritedFromHostUserIds,
+            ...inheritedFromKubernetesClusterUserIds,
+            ...inheritedFromDockerHostUserIds,
+            ...inheritedFromPodmanHostUserIds,
+            ...inheritedFromServiceUserIds,
+        ]);
+        const inheritedTeamIds = new Set([
+            ...inheritedFromMonitorTeamIds,
+            ...inheritedFromHostTeamIds,
+            ...inheritedFromKubernetesClusterTeamIds,
+            ...inheritedFromDockerHostTeamIds,
+            ...inheritedFromPodmanHostTeamIds,
+            ...inheritedFromServiceTeamIds,
+        ]);
+        if (inheritedUserIds.size > 0 || inheritedTeamIds.size > 0) {
+            // A run that did not opt in to notifications adds inherited owners silently too.
+            const inheritNotify = inheritNotifyMode.value === true && data.allowOwnerNotification;
+            for (const id of inheritedUserIds) {
+                usersByNotify.get(inheritNotify).add(id);
+                allUserIds.add(id);
             }
-            for (const notify of [true, false]) {
-                const userIds = Array.from(usersByNotify.get(notify)).map((id) => {
-                    return new ObjectID(id);
-                });
-                const teamIds = Array.from(teamsByNotify.get(notify)).map((id) => {
-                    return new ObjectID(id);
-                });
-                if (userIds.length === 0 && teamIds.length === 0) {
-                    continue;
-                }
-                await AlertService.addOwners(alert.projectId, alert.id, userIds, teamIds, notify, { isRoot: true });
+            for (const id of inheritedTeamIds) {
+                teamsByNotify.get(inheritNotify).add(id);
+                allTeamIds.add(id);
             }
-            logger.debug(`AlertOwnerRuleEngine added owners to alert ${alert.id}`, {
-                projectId: alert.projectId.toString(),
+        }
+        if (matchedRules.length === 0 ||
+            (allUserIds.size === 0 && allTeamIds.size === 0)) {
+            return RuleApplicationResultUtil.alreadyApplied();
+        }
+        // Owners already on the alert are skipped rather than duplicated.
+        const notYetAssigned = await OwnerRuleAssignment.getOwnersNotYetAssigned({
+            ownerUserService: AlertOwnerUserService,
+            ownerTeamService: AlertOwnerTeamService,
+            resourceIdColumn: "alertId",
+            resourceId: alert.id,
+            userIds: Array.from(allUserIds),
+            teamIds: Array.from(allTeamIds),
+        });
+        const userIdsToAdd = new Set(notYetAssigned.userIds.map((id) => {
+            return id.toString();
+        }));
+        const teamIdsToAdd = new Set(notYetAssigned.teamIds.map((id) => {
+            return id.toString();
+        }));
+        const addedUserIds = [];
+        const addedTeamIds = [];
+        /*
+         * 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.from(usersByNotify.get(notify)).filter((id) => {
+                return userIdsToAdd.delete(id);
             });
-            await this.createRuleExecutedFeedItem({
-                alert,
-                matchedRules,
-                userIds: Array.from(allUserIds),
-                teamIds: Array.from(allTeamIds),
-                inheritedFromMonitors: inheritedFromMonitorUserIds.size + inheritedFromMonitorTeamIds.size >
-                    0,
-                inheritedFromHosts: inheritedFromHostUserIds.size + inheritedFromHostTeamIds.size > 0,
-                inheritedFromKubernetesClusters: inheritedFromKubernetesClusterUserIds.size +
-                    inheritedFromKubernetesClusterTeamIds.size >
-                    0,
-                inheritedFromDockerHosts: inheritedFromDockerHostUserIds.size +
-                    inheritedFromDockerHostTeamIds.size >
-                    0,
-                inheritedFromPodmanHosts: inheritedFromPodmanHostUserIds.size +
-                    inheritedFromPodmanHostTeamIds.size >
-                    0,
-                inheritedFromServices: inheritedFromServiceUserIds.size + inheritedFromServiceTeamIds.size >
-                    0,
+            const teamIds = Array.from(teamsByNotify.get(notify)).filter((id) => {
+                return teamIdsToAdd.delete(id);
             });
+            if (userIds.length === 0 && teamIds.length === 0) {
+                continue;
+            }
+            await AlertService.addOwners(alert.projectId, alert.id, userIds.map((id) => {
+                return new ObjectID(id);
+            }), teamIds.map((id) => {
+                return new ObjectID(id);
+            }), notify, { isRoot: true });
+            addedUserIds.push(...userIds);
+            addedTeamIds.push(...teamIds);
         }
-        catch (error) {
-            logger.error(`Error applying alert owner rules: ${error}`, {
-                projectId: (_f = alert.projectId) === null || _f === void 0 ? void 0 : _f.toString(),
-                alertId: (_g = alert.id) === null || _g === void 0 ? void 0 : _g.toString(),
-            });
+        const ownersAdded = addedUserIds.length + addedTeamIds.length;
+        if (ownersAdded === 0) {
+            return RuleApplicationResultUtil.alreadyApplied();
         }
+        logger.debug(`AlertOwnerRuleEngine added owners to alert ${alert.id}`, {
+            projectId: alert.projectId.toString(),
+        });
+        const addedUserIdSet = new Set(addedUserIds);
+        const addedTeamIdSet = new Set(addedTeamIds);
+        await this.createRuleExecutedFeedItem({
+            alert,
+            matchedRules,
+            userIds: addedUserIds,
+            teamIds: addedTeamIds,
+            inheritedFromMonitors: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromMonitorUserIds,
+                inheritedTeamIds: inheritedFromMonitorTeamIds,
+            }),
+            inheritedFromHosts: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromHostUserIds,
+                inheritedTeamIds: inheritedFromHostTeamIds,
+            }),
+            inheritedFromKubernetesClusters: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromKubernetesClusterUserIds,
+                inheritedTeamIds: inheritedFromKubernetesClusterTeamIds,
+            }),
+            inheritedFromDockerHosts: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromDockerHostUserIds,
+                inheritedTeamIds: inheritedFromDockerHostTeamIds,
+            }),
+            inheritedFromPodmanHosts: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromPodmanHostUserIds,
+                inheritedTeamIds: inheritedFromPodmanHostTeamIds,
+            }),
+            inheritedFromServices: addedAnyInheritedOwner({
+                addedUserIds: addedUserIdSet,
+                addedTeamIds: addedTeamIdSet,
+                inheritedUserIds: inheritedFromServiceUserIds,
+                inheritedTeamIds: inheritedFromServiceTeamIds,
+            }),
+        });
+        return RuleApplicationResultUtil.updated(ownersAdded);
     }
     async createRuleExecutedFeedItem(data) {
         var _a, _b;
@@ -707,6 +845,12 @@ __decorate([
     __metadata("design:paramtypes", [Alert]),
     __metadata("design:returntype", Promise)
 ], AlertOwnerRuleEngineServiceClass.prototype, "applyRulesToAlert", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AlertOwnerRuleEngineServiceClass.prototype, "applyRulesToExistingResource", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),