@oneuptime/common 9.4.7 → 9.4.8

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

@@ -0,0 +1,893 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import ObjectID from "../../Types/ObjectID";
+import AlertGroupingRule from "../../Models/DatabaseModels/AlertGroupingRule";
+import Alert from "../../Models/DatabaseModels/Alert";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
+import AlertEpisodeMember, { AlertEpisodeMemberAddedBy, } from "../../Models/DatabaseModels/AlertEpisodeMember";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import OneUptimeDate from "../../Types/Date";
+import QueryHelper from "../Types/Database/QueryHelper";
+import AlertGroupingRuleService from "./AlertGroupingRuleService";
+import AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
+import MonitorService from "./MonitorService";
+import ServiceMonitorService from "./ServiceMonitorService";
+import Semaphore from "../Infrastructure/Semaphore";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import AlertFeedService from "./AlertFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Green500, Purple500 } from "../../Types/BrandColors";
+class AlertGroupingEngineServiceClass {
+    async processAlert(alert) {
+        logger.debug(`Processing alert ${alert.id} for grouping`);
+        try {
+            if (!alert.id || !alert.projectId) {
+                logger.warn("Alert missing id or projectId, skipping grouping");
+                return { grouped: false };
+            }
+            // If alert already has an episode, don't reprocess
+            if (alert.alertEpisodeId) {
+                return { grouped: true, episodeId: alert.alertEpisodeId };
+            }
+            // Get enabled rules sorted by priority
+            const rules = await AlertGroupingRuleService.findBy({
+                query: {
+                    projectId: alert.projectId,
+                    isEnabled: true,
+                },
+                sort: {
+                    priority: SortOrder.Ascending,
+                },
+                props: {
+                    isRoot: true,
+                },
+                select: {
+                    _id: true,
+                    name: true,
+                    priority: true,
+                    // Match criteria fields
+                    monitors: {
+                        _id: true,
+                    },
+                    alertSeverities: {
+                        _id: true,
+                    },
+                    alertLabels: {
+                        _id: true,
+                    },
+                    monitorLabels: {
+                        _id: true,
+                    },
+                    alertTitlePattern: true,
+                    alertDescriptionPattern: true,
+                    monitorNamePattern: true,
+                    monitorDescriptionPattern: true,
+                    // Group by fields
+                    groupByMonitor: true,
+                    groupBySeverity: true,
+                    groupByAlertTitle: true,
+                    groupByService: true,
+                    // Time settings
+                    enableTimeWindow: true,
+                    timeWindowMinutes: true,
+                    episodeTitleTemplate: true,
+                    episodeDescriptionTemplate: true,
+                    enableResolveDelay: true,
+                    resolveDelayMinutes: true,
+                    enableReopenWindow: true,
+                    reopenWindowMinutes: true,
+                    enableInactivityTimeout: true,
+                    inactivityTimeoutMinutes: true,
+                    defaultAssignToUserId: true,
+                    defaultAssignToTeamId: true,
+                    onCallDutyPolicies: {
+                        _id: true,
+                    },
+                },
+                limit: 100,
+                skip: 0,
+            });
+            if (rules.length === 0) {
+                logger.debug(`No enabled grouping rules found for project ${alert.projectId}`);
+                return { grouped: false };
+            }
+            logger.debug(`Found ${rules.length} enabled grouping rules for project ${alert.projectId}`);
+            // Find first matching rule
+            for (const rule of rules) {
+                const matches = await this.doesAlertMatchRule(alert, rule);
+                if (matches) {
+                    logger.debug(`Alert ${alert.id} matches rule ${rule.name || rule.id}`);
+                    // Try to find existing episode or create new one
+                    const result = await this.groupAlertWithRule(alert, rule);
+                    return result;
+                }
+            }
+            logger.debug(`Alert ${alert.id} did not match any grouping rules`);
+            return { grouped: false };
+        }
+        catch (error) {
+            logger.error(`Error processing alert for grouping: ${error}`);
+            return { grouped: false };
+        }
+    }
+    async doesAlertMatchRule(alert, rule) {
+        logger.debug(`Checking if alert ${alert.id} matches rule ${rule.name || rule.id}`);
+        // Check monitor IDs - if monitors are specified, alert must be from one of them
+        if (rule.monitors && rule.monitors.length > 0) {
+            if (!alert.monitorId) {
+                return false;
+            }
+            const monitorIds = rule.monitors.map((m) => {
+                var _a;
+                return ((_a = m.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            });
+            const alertMonitorIdStr = alert.monitorId.toString();
+            if (!monitorIds.includes(alertMonitorIdStr)) {
+                return false;
+            }
+        }
+        // Check alert severity IDs - if severities are specified, alert must have one of them
+        if (rule.alertSeverities && rule.alertSeverities.length > 0) {
+            if (!alert.alertSeverityId) {
+                return false;
+            }
+            const severityIds = rule.alertSeverities.map((s) => {
+                var _a;
+                return ((_a = s.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            });
+            const alertSeverityIdStr = alert.alertSeverityId.toString();
+            if (!severityIds.includes(alertSeverityIdStr)) {
+                return false;
+            }
+        }
+        // Check alert label IDs - if alert labels are specified, alert must have at least one of them
+        if (rule.alertLabels && rule.alertLabels.length > 0) {
+            if (!alert.labels || alert.labels.length === 0) {
+                return false;
+            }
+            const ruleLabelIds = rule.alertLabels.map((l) => {
+                var _a;
+                return ((_a = l.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            });
+            const alertLabelIds = alert.labels.map((l) => {
+                var _a;
+                return ((_a = l.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            });
+            const hasMatchingLabel = ruleLabelIds.some((labelId) => {
+                return alertLabelIds.includes(labelId);
+            });
+            if (!hasMatchingLabel) {
+                return false;
+            }
+        }
+        // Check monitor-related criteria (labels, name pattern, description pattern)
+        const hasMonitorCriteria = Boolean((rule.monitorLabels && rule.monitorLabels.length > 0) ||
+            rule.monitorNamePattern ||
+            rule.monitorDescriptionPattern);
+        if (hasMonitorCriteria) {
+            if (!alert.monitorId) {
+                return false;
+            }
+            // Load monitor with all needed fields
+            const monitor = await MonitorService.findOneById({
+                id: alert.monitorId,
+                select: {
+                    name: true,
+                    description: true,
+                    labels: {
+                        _id: true,
+                    },
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!monitor) {
+                return false;
+            }
+            // Check monitor labels
+            if (rule.monitorLabels && rule.monitorLabels.length > 0) {
+                if (!monitor.labels || monitor.labels.length === 0) {
+                    return false;
+                }
+                const ruleMonitorLabelIds = rule.monitorLabels.map((l) => {
+                    var _a;
+                    return ((_a = l.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+                });
+                const monitorLabelIds = monitor.labels.map((l) => {
+                    var _a;
+                    return ((_a = l.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+                });
+                const hasMatchingMonitorLabel = ruleMonitorLabelIds.some((labelId) => {
+                    return monitorLabelIds.includes(labelId);
+                });
+                if (!hasMatchingMonitorLabel) {
+                    return false;
+                }
+            }
+            // Check monitor name pattern (regex)
+            if (rule.monitorNamePattern) {
+                if (!monitor.name) {
+                    return false;
+                }
+                try {
+                    const regex = new RegExp(rule.monitorNamePattern, "i");
+                    if (!regex.test(monitor.name)) {
+                        return false;
+                    }
+                }
+                catch (_a) {
+                    logger.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.monitorNamePattern}`);
+                    return false;
+                }
+            }
+            // Check monitor description pattern (regex)
+            if (rule.monitorDescriptionPattern) {
+                if (!monitor.description) {
+                    return false;
+                }
+                try {
+                    const regex = new RegExp(rule.monitorDescriptionPattern, "i");
+                    if (!regex.test(monitor.description)) {
+                        return false;
+                    }
+                }
+                catch (_b) {
+                    logger.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.monitorDescriptionPattern}`);
+                    return false;
+                }
+            }
+        }
+        // Check alert title pattern (regex)
+        if (rule.alertTitlePattern) {
+            if (!alert.title) {
+                return false;
+            }
+            try {
+                const regex = new RegExp(rule.alertTitlePattern, "i");
+                if (!regex.test(alert.title)) {
+                    return false;
+                }
+            }
+            catch (_c) {
+                logger.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.alertTitlePattern}`);
+                return false;
+            }
+        }
+        // Check alert description pattern (regex)
+        if (rule.alertDescriptionPattern) {
+            if (!alert.description) {
+                return false;
+            }
+            try {
+                const regex = new RegExp(rule.alertDescriptionPattern, "i");
+                if (!regex.test(alert.description)) {
+                    return false;
+                }
+            }
+            catch (_d) {
+                logger.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.alertDescriptionPattern}`);
+                return false;
+            }
+        }
+        // If no criteria specified (all fields empty), rule matches all alerts
+        logger.debug(`Rule ${rule.name || rule.id} matched alert ${alert.id} (all criteria passed)`);
+        return true;
+    }
+    async groupAlertWithRule(alert, rule) {
+        var _a, _b;
+        // Build the grouping key based on groupBy fields
+        const groupingKey = await this.buildGroupingKey(alert, rule);
+        // Create mutex key to prevent race conditions when creating episodes
+        const mutexKey = `${(_a = alert.projectId) === null || _a === void 0 ? void 0 : _a.toString()}-${(_b = rule.id) === null || _b === void 0 ? void 0 : _b.toString()}-${groupingKey}`;
+        let mutex = null;
+        try {
+            /*
+             * Acquire mutex to prevent concurrent episode creation for the same grouping key
+             * This is critical - we must have the lock before proceeding to prevent race conditions
+             */
+            logger.debug(`Acquiring mutex for grouping key: ${mutexKey} for alert ${alert.id}`);
+            mutex = await Semaphore.lock({
+                key: mutexKey,
+                namespace: "AlertGroupingEngine.groupAlertWithRule",
+                lockTimeout: 30000, // 30 seconds - enough time to complete episode creation
+                acquireTimeout: 60000, // Wait up to 60 seconds to acquire the lock
+            });
+            logger.debug(`Acquired mutex for grouping key: ${mutexKey} for alert ${alert.id}`);
+            // Calculate time window cutoff (only if time window is enabled)
+            let timeWindowCutoff = null;
+            if (rule.enableTimeWindow) {
+                const timeWindowMinutes = rule.timeWindowMinutes || 60;
+                timeWindowCutoff = OneUptimeDate.getSomeMinutesAgo(timeWindowMinutes);
+            }
+            // Find existing active episode that matches
+            const existingEpisode = await this.findMatchingActiveEpisode(alert.projectId, rule.id, groupingKey, timeWindowCutoff);
+            if (existingEpisode && existingEpisode.id) {
+                // Add alert to existing episode
+                await this.addAlertToEpisode(alert, existingEpisode.id, AlertEpisodeMemberAddedBy.Rule, rule.id, rule, false, // isNewEpisode
+                false);
+                // Update episode severity if alert has higher severity
+                if (alert.alertSeverityId) {
+                    await AlertEpisodeService.updateEpisodeSeverity({
+                        episodeId: existingEpisode.id,
+                        severityId: alert.alertSeverityId,
+                        onlyIfHigher: true,
+                    });
+                }
+                return {
+                    grouped: true,
+                    episodeId: existingEpisode.id,
+                    isNewEpisode: false,
+                };
+            }
+            // Check if we can reopen a recently resolved episode (only if enabled)
+            if (rule.enableReopenWindow) {
+                const reopenWindowMinutes = rule.reopenWindowMinutes || 0;
+                if (reopenWindowMinutes > 0) {
+                    const reopenCutoff = OneUptimeDate.getSomeMinutesAgo(reopenWindowMinutes);
+                    const recentlyResolvedEpisode = await this.findRecentlyResolvedEpisode(alert.projectId, rule.id, groupingKey, reopenCutoff);
+                    if (recentlyResolvedEpisode && recentlyResolvedEpisode.id) {
+                        // Reopen the episode
+                        await AlertEpisodeService.reopenEpisode(recentlyResolvedEpisode.id);
+                        // Add alert to reopened episode
+                        await this.addAlertToEpisode(alert, recentlyResolvedEpisode.id, AlertEpisodeMemberAddedBy.Rule, rule.id, rule, false, // isNewEpisode
+                        true);
+                        // Update episode severity if alert has higher severity
+                        if (alert.alertSeverityId) {
+                            await AlertEpisodeService.updateEpisodeSeverity({
+                                episodeId: recentlyResolvedEpisode.id,
+                                severityId: alert.alertSeverityId,
+                                onlyIfHigher: true,
+                            });
+                        }
+                        return {
+                            grouped: true,
+                            episodeId: recentlyResolvedEpisode.id,
+                            isNewEpisode: false,
+                            wasReopened: true,
+                        };
+                    }
+                }
+            }
+            // Create new episode
+            const newEpisode = await this.createNewEpisode(alert, rule, groupingKey);
+            if (newEpisode && newEpisode.id) {
+                // Add alert to new episode
+                await this.addAlertToEpisode(alert, newEpisode.id, AlertEpisodeMemberAddedBy.Rule, rule.id, rule, true, // isNewEpisode
+                false);
+                return { grouped: true, episodeId: newEpisode.id, isNewEpisode: true };
+            }
+            return { grouped: false };
+        }
+        finally {
+            // Release mutex
+            if (mutex) {
+                try {
+                    logger.debug(`Releasing mutex for grouping key: ${mutexKey} for alert ${alert.id}`);
+                    await Semaphore.release(mutex);
+                    logger.debug(`Released mutex for grouping key: ${mutexKey} for alert ${alert.id}`);
+                }
+                catch (err) {
+                    logger.error(`Error releasing mutex for grouping key: ${mutexKey}: ${err}`);
+                }
+            }
+        }
+    }
+    async buildGroupingKey(alert, rule) {
+        const parts = [];
+        /*
+         * Group by service - only if explicitly enabled
+         * Must be checked before monitor since service contains multiple monitors
+         */
+        if (rule.groupByService && alert.monitorId) {
+            const serviceMonitor = await ServiceMonitorService.findOneBy({
+                query: {
+                    monitorId: alert.monitorId,
+                },
+                select: {
+                    serviceId: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (serviceMonitor === null || serviceMonitor === void 0 ? void 0 : serviceMonitor.serviceId) {
+                parts.push(`service:${serviceMonitor.serviceId.toString()}`);
+            }
+        }
+        // Group by monitor - only if explicitly enabled
+        if (rule.groupByMonitor && alert.monitorId) {
+            parts.push(`monitor:${alert.monitorId.toString()}`);
+        }
+        // Group by severity - only if explicitly enabled
+        if (rule.groupBySeverity && alert.alertSeverityId) {
+            parts.push(`severity:${alert.alertSeverityId.toString()}`);
+        }
+        // Group by alert title - only if explicitly enabled
+        if (rule.groupByAlertTitle && alert.title) {
+            // Normalize title for grouping (remove numbers, etc.)
+            const normalizedTitle = alert.title
+                .toLowerCase()
+                .replace(/\d+/g, "X");
+            parts.push(`title:${normalizedTitle}`);
+        }
+        // If no group by options are enabled, all matching alerts go into a single episode
+        return parts.join("|") || "default";
+    }
+    async findMatchingActiveEpisode(projectId, ruleId, groupingKey, timeWindowCutoff) {
+        const query = {
+            projectId: projectId,
+            alertGroupingRuleId: ruleId,
+            groupingKey: groupingKey,
+            resolvedAt: null, // Only find active (non-resolved) episodes
+        };
+        // Only add time window filter if enabled
+        if (timeWindowCutoff) {
+            query.lastAlertAddedAt = QueryHelper.greaterThanEqualTo(timeWindowCutoff);
+        }
+        const episode = await AlertEpisodeService.findOneBy({
+            query: query,
+            sort: {
+                lastAlertAddedAt: SortOrder.Descending,
+            },
+            select: {
+                _id: true,
+                lastAlertAddedAt: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        return episode;
+    }
+    async findRecentlyResolvedEpisode(projectId, ruleId, groupingKey, reopenCutoff) {
+        // Find recently resolved episode with matching rule and grouping key
+        const episode = await AlertEpisodeService.findOneBy({
+            query: {
+                projectId: projectId,
+                alertGroupingRuleId: ruleId,
+                groupingKey: groupingKey,
+                resolvedAt: QueryHelper.greaterThanEqualTo(reopenCutoff),
+            },
+            sort: {
+                resolvedAt: SortOrder.Descending,
+            },
+            select: {
+                _id: true,
+                resolvedAt: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        return episode;
+    }
+    async createNewEpisode(alert, rule, groupingKey) {
+        // Generate episode title from template (with initial alertCount of 1)
+        const title = this.generateEpisodeTitle(alert, rule.episodeTitleTemplate, 1);
+        // Generate episode description from template (with initial alertCount of 1)
+        const description = this.generateEpisodeDescription(alert, rule.episodeDescriptionTemplate, 1);
+        const newEpisode = new AlertEpisode();
+        newEpisode.projectId = alert.projectId;
+        newEpisode.title = title;
+        if (description) {
+            newEpisode.description = description;
+        }
+        /*
+         * Store preprocessed templates for dynamic variable updates
+         * Static variables are replaced, dynamic ones (like {{alertCount}}) remain as placeholders
+         */
+        if (rule.episodeTitleTemplate) {
+            newEpisode.titleTemplate = this.preprocessTemplate(alert, rule.episodeTitleTemplate);
+        }
+        if (rule.episodeDescriptionTemplate) {
+            newEpisode.descriptionTemplate = this.preprocessTemplate(alert, rule.episodeDescriptionTemplate);
+        }
+        newEpisode.alertGroupingRuleId = rule.id;
+        newEpisode.groupingKey = groupingKey;
+        newEpisode.isManuallyCreated = false;
+        // Set severity from alert
+        if (alert.alertSeverityId) {
+            newEpisode.alertSeverityId = alert.alertSeverityId;
+        }
+        // Set default ownership from rule
+        if (rule.defaultAssignToUserId) {
+            newEpisode.assignedToUserId = rule.defaultAssignToUserId;
+        }
+        if (rule.defaultAssignToTeamId) {
+            newEpisode.assignedToTeamId = rule.defaultAssignToTeamId;
+        }
+        // Copy on-call policies from rule
+        if (rule.onCallDutyPolicies && rule.onCallDutyPolicies.length > 0) {
+            newEpisode.onCallDutyPolicies = rule.onCallDutyPolicies;
+        }
+        try {
+            const createdEpisode = await AlertEpisodeService.create({
+                data: newEpisode,
+                props: {
+                    isRoot: true,
+                },
+            });
+            // Add episode feed entry for episode creation
+            if (createdEpisode.id) {
+                const groupByParts = [];
+                if (rule.groupByMonitor) {
+                    groupByParts.push("Monitor");
+                }
+                if (rule.groupBySeverity) {
+                    groupByParts.push("Severity");
+                }
+                if (rule.groupByAlertTitle) {
+                    groupByParts.push("Alert Title");
+                }
+                if (rule.groupByService) {
+                    groupByParts.push("Service");
+                }
+                const groupByDescription = groupByParts.length > 0
+                    ? `Grouping by: ${groupByParts.join(", ")}`
+                    : "Grouping all matching alerts together";
+                let moreInfo = `**Rule:** ${rule.name || "Unnamed Rule"}\n\n`;
+                moreInfo += `**Grouping Key:** \`${groupingKey}\`\n\n`;
+                moreInfo += `**${groupByDescription}**`;
+                if (rule.enableTimeWindow && rule.timeWindowMinutes) {
+                    moreInfo += `\n\n**Time Window:** ${rule.timeWindowMinutes} minutes`;
+                }
+                try {
+                    await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+                        alertEpisodeId: createdEpisode.id,
+                        projectId: alert.projectId,
+                        alertEpisodeFeedEventType: AlertEpisodeFeedEventType.EpisodeCreated,
+                        displayColor: Green500,
+                        feedInfoInMarkdown: `🔔 **Episode Created** by grouping rule **${rule.name || "Unnamed Rule"}**`,
+                        moreInformationInMarkdown: moreInfo,
+                    });
+                }
+                catch (feedError) {
+                    logger.error(`Error creating episode feed for episode creation: ${feedError}`);
+                }
+            }
+            return createdEpisode;
+        }
+        catch (error) {
+            logger.error(`Error creating new episode: ${error}`);
+            return null;
+        }
+    }
+    generateEpisodeTitle(alert, template, alertCount = 1) {
+        var _a;
+        if (!template) {
+            // Default title based on alert
+            if ((_a = alert.monitor) === null || _a === void 0 ? void 0 : _a.name) {
+                return `Alert Episode: ${alert.monitor.name}`;
+            }
+            if (alert.title) {
+                return `Alert Episode: ${alert.title.substring(0, 50)}`;
+            }
+            return "Alert Episode";
+        }
+        return (this.replaceTemplatePlaceholders(alert, template, alertCount) ||
+            "Alert Episode");
+    }
+    generateEpisodeDescription(alert, template, alertCount = 1) {
+        if (!template) {
+            return undefined;
+        }
+        return (this.replaceTemplatePlaceholders(alert, template, alertCount) || undefined);
+    }
+    replaceTemplatePlaceholders(alert, template, alertCount = 1) {
+        var _a, _b;
+        let result = template;
+        /*
+         * Static variables (from first alert)
+         * {{alertTitle}}
+         */
+        if (alert.title) {
+            result = result.replace(/\{\{alertTitle\}\}/g, alert.title);
+        }
+        // {{alertDescription}}
+        if (alert.description) {
+            result = result.replace(/\{\{alertDescription\}\}/g, alert.description);
+        }
+        // {{monitorName}}
+        if ((_a = alert.monitor) === null || _a === void 0 ? void 0 : _a.name) {
+            result = result.replace(/\{\{monitorName\}\}/g, alert.monitor.name);
+        }
+        // {{alertSeverity}}
+        if ((_b = alert.alertSeverity) === null || _b === void 0 ? void 0 : _b.name) {
+            result = result.replace(/\{\{alertSeverity\}\}/g, alert.alertSeverity.name);
+        }
+        /*
+         * Dynamic variables (updated when alerts are added/removed)
+         * {{alertCount}}
+         */
+        result = result.replace(/\{\{alertCount\}\}/g, alertCount.toString());
+        // Clean up any remaining unknown placeholders
+        result = result.replace(/\{\{[^}]+\}\}/g, "");
+        return result;
+    }
+    /*
+     * Preprocess template: replace static variables but keep dynamic ones as placeholders
+     * This is stored on the episode so we can re-render with updated dynamic values later
+     */
+    preprocessTemplate(alert, template) {
+        var _a, _b;
+        let result = template;
+        /*
+         * Replace static variables (from first alert)
+         * {{alertTitle}}
+         */
+        if (alert.title) {
+            result = result.replace(/\{\{alertTitle\}\}/g, alert.title);
+        }
+        // {{alertDescription}}
+        if (alert.description) {
+            result = result.replace(/\{\{alertDescription\}\}/g, alert.description);
+        }
+        // {{monitorName}}
+        if ((_a = alert.monitor) === null || _a === void 0 ? void 0 : _a.name) {
+            result = result.replace(/\{\{monitorName\}\}/g, alert.monitor.name);
+        }
+        // {{alertSeverity}}
+        if ((_b = alert.alertSeverity) === null || _b === void 0 ? void 0 : _b.name) {
+            result = result.replace(/\{\{alertSeverity\}\}/g, alert.alertSeverity.name);
+        }
+        /*
+         * Keep dynamic variables as placeholders (e.g., {{alertCount}})
+         * They will be replaced when title/description is re-rendered
+         */
+        return result;
+    }
+    async addAlertToEpisode(alert, episodeId, addedBy, ruleId, rule, isNewEpisode, wasReopened) {
+        const member = new AlertEpisodeMember();
+        member.projectId = alert.projectId;
+        member.alertEpisodeId = episodeId;
+        member.alertId = alert.id;
+        member.addedBy = addedBy;
+        if (ruleId) {
+            member.matchedRuleId = ruleId;
+        }
+        try {
+            await AlertEpisodeMemberService.create({
+                data: member,
+                props: {
+                    isRoot: true,
+                },
+            });
+            // Create feed entries for alert being added to episode
+            await this.createAlertAddedFeedEntries({
+                alert,
+                episodeId,
+                addedBy,
+                rule,
+                isNewEpisode,
+                wasReopened,
+            });
+        }
+        catch (error) {
+            // Check if it's a duplicate error (alert already in episode)
+            if (error instanceof Error &&
+                error.message.includes("already a member")) {
+                logger.debug(`Alert ${alert.id} is already in episode ${episodeId}`);
+                return;
+            }
+            throw error;
+        }
+    }
+    async createAlertAddedFeedEntries(data) {
+        const { alert, episodeId, addedBy, rule, isNewEpisode, wasReopened, addedByUserId, } = data;
+        // Fetch episode number for feed entry
+        const episode = await AlertEpisodeService.findOneById({
+            id: episodeId,
+            select: {
+                episodeNumber: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        const episodeNumber = (episode === null || episode === void 0 ? void 0 : episode.episodeNumber) || 0;
+        const alertNumber = alert.alertNumber || 0;
+        // Build explanation of why the alert was added
+        let matchReason = "";
+        let alertFeedMessage = "";
+        let episodeFeedMessage = "";
+        if (addedBy === AlertEpisodeMemberAddedBy.Rule && rule) {
+            const matchCriteria = [];
+            if (rule.monitors && rule.monitors.length > 0) {
+                matchCriteria.push("monitor matches rule criteria");
+            }
+            if (rule.alertSeverities && rule.alertSeverities.length > 0) {
+                matchCriteria.push("severity matches rule criteria");
+            }
+            if (rule.alertLabels && rule.alertLabels.length > 0) {
+                matchCriteria.push("alert labels match rule criteria");
+            }
+            if (rule.monitorLabels && rule.monitorLabels.length > 0) {
+                matchCriteria.push("monitor labels match rule criteria");
+            }
+            if (rule.alertTitlePattern) {
+                matchCriteria.push(`alert title matches pattern \`${rule.alertTitlePattern}\``);
+            }
+            if (rule.alertDescriptionPattern) {
+                matchCriteria.push(`alert description matches pattern \`${rule.alertDescriptionPattern}\``);
+            }
+            if (rule.monitorNamePattern) {
+                matchCriteria.push(`monitor name matches pattern \`${rule.monitorNamePattern}\``);
+            }
+            if (rule.monitorDescriptionPattern) {
+                matchCriteria.push(`monitor description matches pattern \`${rule.monitorDescriptionPattern}\``);
+            }
+            if (matchCriteria.length === 0) {
+                matchCriteria.push("all criteria matched (rule matches all alerts)");
+            }
+            matchReason = `**Match Criteria:**\n- ${matchCriteria.join("\n- ")}`;
+            if (wasReopened) {
+                alertFeedMessage = `➕ **Added to Episode #${episodeNumber}** (reopened) by rule **${rule.name || "Unnamed Rule"}**`;
+                episodeFeedMessage = `➕ **Alert #${alertNumber}** added (episode reopened) by rule **${rule.name || "Unnamed Rule"}**`;
+            }
+            else if (isNewEpisode) {
+                alertFeedMessage = `➕ **Added to new Episode #${episodeNumber}** by rule **${rule.name || "Unnamed Rule"}**`;
+                episodeFeedMessage = `➕ **Alert #${alertNumber}** added (initial alert) by rule **${rule.name || "Unnamed Rule"}**`;
+            }
+            else {
+                alertFeedMessage = `➕ **Added to Episode #${episodeNumber}** by rule **${rule.name || "Unnamed Rule"}**`;
+                episodeFeedMessage = `➕ **Alert #${alertNumber}** added by rule **${rule.name || "Unnamed Rule"}**`;
+            }
+        }
+        else {
+            // Manual addition
+            alertFeedMessage = `➕ **Manually added to Episode #${episodeNumber}**`;
+            episodeFeedMessage = `➕ **Alert #${alertNumber}** manually added`;
+            matchReason = "**Reason:** Manually added by user";
+        }
+        // Create alert feed entry
+        try {
+            await AlertFeedService.createAlertFeedItem({
+                alertId: alert.id,
+                projectId: alert.projectId,
+                alertFeedEventType: AlertFeedEventType.AddedToEpisode,
+                displayColor: Purple500,
+                feedInfoInMarkdown: alertFeedMessage,
+                moreInformationInMarkdown: matchReason,
+                userId: addedByUserId,
+            });
+        }
+        catch (feedError) {
+            logger.error(`Error creating alert feed for alert added to episode: ${feedError}`);
+        }
+        // Create episode feed entry
+        try {
+            let moreInfo = `**Alert:** #${alertNumber}`;
+            if (alert.title) {
+                moreInfo += ` - ${alert.title}`;
+            }
+            moreInfo += `\n\n${matchReason}`;
+            await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+                alertEpisodeId: episodeId,
+                projectId: alert.projectId,
+                alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertAdded,
+                displayColor: Purple500,
+                feedInfoInMarkdown: episodeFeedMessage,
+                moreInformationInMarkdown: moreInfo,
+                userId: addedByUserId,
+            });
+        }
+        catch (feedError) {
+            logger.error(`Error creating episode feed for alert added: ${feedError}`);
+        }
+    }
+    async addAlertToEpisodeManually(alert, episodeId, addedByUserId) {
+        const member = new AlertEpisodeMember();
+        member.projectId = alert.projectId;
+        member.alertEpisodeId = episodeId;
+        member.alertId = alert.id;
+        member.addedBy = AlertEpisodeMemberAddedBy.Manual;
+        if (addedByUserId) {
+            member.addedByUserId = addedByUserId;
+        }
+        await AlertEpisodeMemberService.create({
+            data: member,
+            props: {
+                isRoot: true,
+            },
+        });
+        // Create feed entries for manual addition
+        await this.createAlertAddedFeedEntries({
+            alert,
+            episodeId,
+            addedBy: AlertEpisodeMemberAddedBy.Manual,
+            addedByUserId,
+        });
+        // Update episode severity if needed
+        if (alert.alertSeverityId) {
+            await AlertEpisodeService.updateEpisodeSeverity({
+                episodeId: episodeId,
+                severityId: alert.alertSeverityId,
+                onlyIfHigher: true,
+            });
+        }
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "processAlert", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        AlertGroupingRule]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "doesAlertMatchRule", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        AlertGroupingRule]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "groupAlertWithRule", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        AlertGroupingRule]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "buildGroupingKey", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID,
+        ObjectID, String, Object]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "findMatchingActiveEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID,
+        ObjectID, String, Date]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "findRecentlyResolvedEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        AlertGroupingRule, String]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "createNewEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        ObjectID, String, ObjectID,
+        AlertGroupingRule, Boolean, Boolean]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "addAlertToEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "createAlertAddedFeedEntries", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Alert,
+        ObjectID,
+        ObjectID]),
+    __metadata("design:returntype", Promise)
+], AlertGroupingEngineServiceClass.prototype, "addAlertToEpisodeManually", null);
+export default new AlertGroupingEngineServiceClass();
+//# sourceMappingURL=AlertGroupingEngineService.js.map