@oneuptime/common 11.7.3 → 12.0.0

package/build/dist/Types/Monitor/Recommendation/MonitorRecommendationSeverityMapper.js

@@ -0,0 +1,110 @@
+/*
+ * Maps a recommendation's declared severity (`Critical` / `Warning`) onto one
+ * of the project's own incident or alert severities.
+ *
+ * Why this exists: the templates take a single `defaultIncidentSeverityId`
+ * argument, and the page filled it with the project's first severity. So
+ * "Deployment Replica Mismatch" (Warning) and "Node Not Ready" (Critical)
+ * both opened a Critical Incident. Every recommendation paged at the same
+ * level, and the Critical/Warning badge on the card described nothing that
+ * happened afterwards.
+ *
+ * The rule is intentionally boring and order-based rather than name-based:
+ * severities are user-renameable ("Sev1", "P0", "Critical Incident", localized
+ * names), so matching on a name works for the default seed and for nothing
+ * else. `order` is the field the product itself treats as rank.
+ */
+export default class MonitorRecommendationSeverityMapper {
+    /*
+     * Severities ranked most-severe first.
+     *
+     * Sorted by `order` ascending, with rows missing an order pushed to the end
+     * rather than treated as order 0 — an unset order is "unranked", and
+     * silently promoting it to most-severe would map every Critical
+     * recommendation onto it.
+     *
+     * Ties (two severities sharing an order, which the product permits) fall
+     * back to the incoming array order, so the mapping is stable across calls
+     * given the same input. Callers pass the list already sorted by order from
+     * the API, so in practice this is the API's own ordering.
+     */
+    static rankSeverities(options) {
+        return [...options].sort((a, b) => {
+            const aOrder = typeof a.order === "number" ? a.order : Number.MAX_SAFE_INTEGER;
+            const bOrder = typeof b.order === "number" ? b.order : Number.MAX_SAFE_INTEGER;
+            return aOrder - bOrder;
+        });
+    }
+    /*
+     * The default Critical -> ? / Warning -> ? mapping for a project.
+     *
+     * Critical takes the most severe row. Warning takes the next one down, and
+     * falls back to the same row as Critical when the project only defines one
+     * severity — a project with a single severity has no way to express the
+     * distinction, and refusing to map Warning at all would leave those monitors
+     * on the template's own choice, which is the bug this class exists to fix.
+     *
+     * Warning deliberately takes the SECOND severity rather than the LAST. On
+     * the default seed those are the same row (incidents: Critical/Major/Minor
+     * -> Major either way is second, Minor is last), but a project with five
+     * severities means "Warning" much closer to Major than to the bottom of the
+     * scale, and a recommendation the catalog calls Warning is a real
+     * production problem, not a nitpick.
+     */
+    static getDefaultSeverityMapping(options) {
+        const ranked = this.rankSeverities(options);
+        if (ranked.length === 0) {
+            return {};
+        }
+        const mostSevere = ranked[0];
+        const nextSevere = ranked[1] || mostSevere;
+        return {
+            Critical: mostSevere.id,
+            Warning: nextSevere.id,
+        };
+    }
+    /*
+     * Resolve one recommendation's severity through a mapping.
+     *
+     * Returns undefined when the mapping has no entry, which callers must treat
+     * as "leave the template's own severity alone" rather than as "no severity"
+     * — a criteria instance with a populated incident and no severity id fails
+     * `MonitorCriteriaInstance.getValidationError` and the whole create fails.
+     */
+    static resolveSeverityId(data) {
+        if (!data.severityMap) {
+            return undefined;
+        }
+        return data.severityMap[data.severity];
+    }
+    /*
+     * Human-readable "Critical -> Critical Incident" pairs, for the create form
+     * to show what it is about to do. Rendering the mapping is the only thing
+     * that makes an automatic choice reviewable instead of surprising.
+     */
+    static describeMapping(data) {
+        const severities = [
+            "Critical",
+            "Warning",
+        ];
+        const described = [];
+        for (const severity of severities) {
+            const id = this.resolveSeverityId({
+                severity: severity,
+                severityMap: data.severityMap,
+            });
+            if (!id) {
+                continue;
+            }
+            const match = data.options.find((option) => {
+                return option.id.toString() === id.toString();
+            });
+            if (!match) {
+                continue;
+            }
+            described.push({ severity: severity, name: match.name });
+        }
+        return described;
+    }
+}
+//# sourceMappingURL=MonitorRecommendationSeverityMapper.js.map

package/build/dist/Types/Monitor/Recommendation/MonitorRecommendationSeverityMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MonitorRecommendationSeverityMapper.js","sourceRoot":"","sources":["../../../../../Types/Monitor/Recommendation/MonitorRecommendationSeverityMapper.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,OAAO,mCAAmC;IACtD;;;;;;;;;;;;OAYG;IACI,MAAM,CAAC,cAAc,CAC1B,OAAmD;QAEnD,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CACtB,CACE,CAAsC,EACtC,CAAsC,EACtC,EAAE;YACF,MAAM,MAAM,GACV,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;YAClE,MAAM,MAAM,GACV,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;YAElE,OAAO,MAAM,GAAG,MAAM,CAAC;QACzB,CAAC,CACF,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,MAAM,CAAC,yBAAyB,CACrC,OAAmD;QAEnD,MAAM,MAAM,GACV,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAE/B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,UAAU,GAAwC,MAAM,CAAC,CAAC,CAAE,CAAC;QACnE,MAAM,UAAU,GACd,MAAM,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC;QAE1B,OAAO;YACL,QAAQ,EAAE,UAAU,CAAC,EAAE;YACvB,OAAO,EAAE,UAAU,CAAC,EAAE;SACvB,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,iBAAiB,CAAC,IAG/B;QACC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,eAAe,CAAC,IAG7B;QACC,MAAM,UAAU,GAAyC;YACvD,UAAU;YACV,SAAS;SACV,CAAC;QAEF,MAAM,SAAS,GAGV,EAAE,CAAC;QAER,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;YAClC,MAAM,EAAE,GAAyB,IAAI,CAAC,iBAAiB,CAAC;gBACtD,QAAQ,EAAE,QAAQ;gBAClB,WAAW,EAAE,IAAI,CAAC,WAAW;aAC9B,CAAC,CAAC;YAEH,IAAI,CAAC,EAAE,EAAE,CAAC;gBACR,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GACT,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAA2C,EAAE,EAAE;gBAChE,OAAO,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;YAChD,CAAC,CAAC,CAAC;YAEL,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,SAAS;YACX,CAAC;YAED,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/build/dist/Types/Monitor/Recommendation/MonitorRecommendationTypes.js

@@ -0,0 +1,59 @@
+/*
+ * The resource types that ship a curated alert-template library. There is
+ * exactly one member per `<X>AlertTemplates.ts` module in
+ * `Common/Types/Monitor` — adding another template module means adding a
+ * member here and an adapter in `MonitorRecommendationCatalog.ts`, and the
+ * catalog's own tests fail until both exist.
+ *
+ * These values are persisted nowhere. They are a UI/registry key only, so
+ * they are free to differ from `MonitorType` (which they do: `DockerSwarm`
+ * here vs `"Docker Swarm"` there).
+ */
+export var MonitorRecommendationResourceType;
+(function (MonitorRecommendationResourceType) {
+    MonitorRecommendationResourceType["Kubernetes"] = "Kubernetes";
+    MonitorRecommendationResourceType["Host"] = "Host";
+    MonitorRecommendationResourceType["Docker"] = "Docker";
+    MonitorRecommendationResourceType["DockerSwarm"] = "DockerSwarm";
+    MonitorRecommendationResourceType["Podman"] = "Podman";
+    MonitorRecommendationResourceType["Proxmox"] = "Proxmox";
+    MonitorRecommendationResourceType["Ceph"] = "Ceph";
+    MonitorRecommendationResourceType["IoTDevice"] = "IoTDevice";
+    MonitorRecommendationResourceType["RumApplication"] = "RumApplication";
+})(MonitorRecommendationResourceType || (MonitorRecommendationResourceType = {}));
+/*
+ * Registry-wide unique id for a recommendation.
+ *
+ * Every template module happens to self-prefix its ids today (`host-high-cpu`,
+ * `docker-high-cpu`, `podman-high-cpu`), so the 76 template ids are in fact
+ * globally unique right now. That is a convention across eight independently
+ * maintained files, not a contract — each module only guarantees uniqueness
+ * WITHIN itself. Prefixing here makes the registry correct regardless: without
+ * it, the day two modules pick the same id, selecting one card in the UI would
+ * silently also select the other. `MonitorRecommendationCatalog.test.ts` keeps
+ * a canary on the current global uniqueness so the drift is at least visible.
+ */
+export function buildRecommendationId(resourceType, templateId) {
+    return `${resourceType}:${templateId}`;
+}
+/*
+ * What a created monitor should open when its condition is met.
+ *
+ * Every shipped template sets BOTH `createIncidents: true` and
+ * `createAlerts: true` on its unhealthy criteria, so today one threshold
+ * breach opens an incident AND an alert describing the same thing — two
+ * records, two notification fan-outs, two things to resolve. That is almost
+ * never what anyone wants, and there is no way to say so from the
+ * recommendations page. This is that choice.
+ *
+ * The distinction the product draws (see the monitor criteria form's own
+ * tooltips): an alert notifies the team; an incident notifies the team AND
+ * shows on the status page.
+ */
+export var MonitorRecommendationNotificationMode;
+(function (MonitorRecommendationNotificationMode) {
+    MonitorRecommendationNotificationMode["Alert"] = "Alert";
+    MonitorRecommendationNotificationMode["Incident"] = "Incident";
+    MonitorRecommendationNotificationMode["Both"] = "Both";
+})(MonitorRecommendationNotificationMode || (MonitorRecommendationNotificationMode = {}));
+//# sourceMappingURL=MonitorRecommendationTypes.js.map

package/build/dist/Types/Monitor/Recommendation/MonitorRecommendationTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MonitorRecommendationTypes.js","sourceRoot":"","sources":["../../../../../Types/Monitor/Recommendation/MonitorRecommendationTypes.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,CAAN,IAAY,iCAUX;AAVD,WAAY,iCAAiC;IAC3C,8DAAyB,CAAA;IACzB,kDAAa,CAAA;IACb,sDAAiB,CAAA;IACjB,gEAA2B,CAAA;IAC3B,sDAAiB,CAAA;IACjB,wDAAmB,CAAA;IACnB,kDAAa,CAAA;IACb,4DAAuB,CAAA;IACvB,sEAAiC,CAAA;AACnC,CAAC,EAVW,iCAAiC,KAAjC,iCAAiC,QAU5C;AA6DD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAA+C,EAC/C,UAAkB;IAElB,OAAO,GAAG,YAAY,IAAI,UAAU,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAN,IAAY,qCAIX;AAJD,WAAY,qCAAqC;IAC/C,wDAAe,CAAA;IACf,8DAAqB,CAAA;IACrB,sDAAa,CAAA;AACf,CAAC,EAJW,qCAAqC,KAArC,qCAAqC,QAIhD"}

package/build/dist/Types/Monitor/Recommendation/MonitorRecommendationUtil.js

@@ -0,0 +1,491 @@
+import MonitorSteps from "../MonitorSteps";
+import MonitorRecommendationSeverityMapper from "./MonitorRecommendationSeverityMapper";
+import { MonitorRecommendationNotificationMode, } from "./MonitorRecommendationTypes";
+export default class MonitorRecommendationUtil {
+    /*
+     * Deterministic monitor name for a recommendation applied to a resource.
+     *
+     * Used both as the created monitor's name and as the `monitorName` arg the
+     * template modules interpolate into their incident/alert titles.
+     */
+    static getMonitorName(data) {
+        const resourceName = data.resourceDisplayName.trim();
+        if (!resourceName) {
+            return data.recommendation.name;
+        }
+        return `${resourceName} - ${data.recommendation.name}`;
+    }
+    /*
+     * Push the user's chosen on-call policies, owners, labels, severities and
+     * incident-vs-alert choice into every criteria instance in a step.
+     *
+     * This is the whole reason the create form asks for on-call policies: every
+     * shipped template hardcodes `onCallPolicyIds: []`, so a template-created
+     * monitor would open incidents that page nobody. Templates are the source
+     * of the thresholds; this is the source of "who hears about it, how loudly,
+     * and through which record".
+     *
+     * `severity` is the RECOMMENDATION's severity (`Critical` / `Warning`), not
+     * a project severity. It selects which project severity to write, via the
+     * caller's mapping — see `MonitorRecommendationSeverityMapper`.
+     *
+     * Mutates and returns the step (the step was just built by the template and
+     * is not shared with anything else).
+     */
+    static applyNotificationSettingsToMonitorStep(data) {
+        var _a, _b, _c;
+        const settings = data.notificationSettings;
+        const incidentSeverityId = MonitorRecommendationSeverityMapper.resolveSeverityId({
+            severity: data.severity,
+            severityMap: settings.incidentSeverityIdBySeverity,
+        });
+        const alertSeverityId = MonitorRecommendationSeverityMapper.resolveSeverityId({
+            severity: data.severity,
+            severityMap: settings.alertSeverityIdBySeverity,
+        });
+        const criteriaInstances = ((_c = (_b = (_a = data.monitorStep.data) === null || _a === void 0 ? void 0 : _a.monitorCriteria) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.monitorCriteriaInstanceArray) || [];
+        for (const criteriaInstance of criteriaInstances) {
+            if (!criteriaInstance.data) {
+                continue;
+            }
+            for (const incident of criteriaInstance.data.incidents || []) {
+                this.applyToCriteriaIncident(incident, settings, incidentSeverityId);
+            }
+            for (const alert of criteriaInstance.data.alerts || []) {
+                this.applyToCriteriaAlert(alert, settings, alertSeverityId);
+            }
+            this.applyNotificationModeToCriteriaInstance(criteriaInstance, settings.notificationMode);
+        }
+        return data.monitorStep;
+    }
+    /*
+     * Turn the user's Alert / Incident / Both choice into the two flags the
+     * monitor evaluator actually reads (`MonitorIncident.ts` and
+     * `MonitorAlert.ts` both early-return unless the flag is true).
+     *
+     * Two things this deliberately does NOT do:
+     *
+     *   1. It never flips a flag on a criteria instance whose corresponding
+     *      array is empty. Every template ships a "Healthy" recovery criteria
+     *      with `incidents: []` and `createIncidents: false`; setting the flag
+     *      there would mark it as incident-creating, which the auto-resolve path
+     *      reads as "this criteria contributes breaches" and would stop
+     *      recovered monitors from resolving their own incidents.
+     *
+     *   2. It never empties the arrays of the mode that was NOT chosen. The
+     *      config stays on the monitor, inert, exactly like the monitor criteria
+     *      form's own toggles behave — so a user who later decides they do want
+     *      incidents flips one switch on the monitor instead of re-authoring the
+     *      incident title, description and severity.
+     */
+    static applyNotificationModeToCriteriaInstance(criteriaInstance, notificationMode) {
+        if (!notificationMode || !criteriaInstance.data) {
+            return;
+        }
+        const shouldCreateIncidents = notificationMode === MonitorRecommendationNotificationMode.Incident ||
+            notificationMode === MonitorRecommendationNotificationMode.Both;
+        const shouldCreateAlerts = notificationMode === MonitorRecommendationNotificationMode.Alert ||
+            notificationMode === MonitorRecommendationNotificationMode.Both;
+        if ((criteriaInstance.data.incidents || []).length > 0) {
+            criteriaInstance.data.createIncidents = shouldCreateIncidents;
+        }
+        if ((criteriaInstance.data.alerts || []).length > 0) {
+            criteriaInstance.data.createAlerts = shouldCreateAlerts;
+        }
+    }
+    static applyToCriteriaIncident(incident, settings, incidentSeverityId) {
+        if (settings.onCallPolicyIds && settings.onCallPolicyIds.length > 0) {
+            incident.onCallPolicyIds = [...settings.onCallPolicyIds];
+        }
+        if (settings.labelIds && settings.labelIds.length > 0) {
+            incident.labelIds = [...settings.labelIds];
+        }
+        if (settings.ownerTeamIds && settings.ownerTeamIds.length > 0) {
+            incident.ownerTeamIds = [...settings.ownerTeamIds];
+        }
+        if (settings.ownerUserIds && settings.ownerUserIds.length > 0) {
+            incident.ownerUserIds = [...settings.ownerUserIds];
+        }
+        if (incidentSeverityId) {
+            incident.incidentSeverityId = incidentSeverityId;
+        }
+    }
+    static applyToCriteriaAlert(alert, settings, alertSeverityId) {
+        if (settings.onCallPolicyIds && settings.onCallPolicyIds.length > 0) {
+            alert.onCallPolicyIds = [...settings.onCallPolicyIds];
+        }
+        if (settings.labelIds && settings.labelIds.length > 0) {
+            alert.labelIds = [...settings.labelIds];
+        }
+        if (settings.ownerTeamIds && settings.ownerTeamIds.length > 0) {
+            alert.ownerTeamIds = [...settings.ownerTeamIds];
+        }
+        if (settings.ownerUserIds && settings.ownerUserIds.length > 0) {
+            alert.ownerUserIds = [...settings.ownerUserIds];
+        }
+        if (alertSeverityId) {
+            alert.alertSeverityId = alertSeverityId;
+        }
+    }
+    /*
+     * Build the complete `MonitorSteps` for one recommendation, ready to hang
+     * off a `Monitor` and POST.
+     *
+     * `defaultMonitorStatusId` is separate from the online/offline ids in
+     * `args` because `MonitorSteps.getValidationError` requires it and the
+     * template modules never set it — they only produce the inner step.
+     */
+    static buildMonitorSteps(data) {
+        const monitorStep = data.recommendation.getMonitorStep(data.args);
+        if (data.notificationSettings) {
+            this.applyNotificationSettingsToMonitorStep({
+                monitorStep: monitorStep,
+                notificationSettings: data.notificationSettings,
+                severity: data.recommendation.severity,
+            });
+        }
+        const monitorSteps = new MonitorSteps();
+        monitorSteps.data = {
+            monitorStepsInstanceArray: [monitorStep],
+            defaultMonitorStatusId: data.defaultMonitorStatusId,
+        };
+        return monitorSteps;
+    }
+    /*
+     * Reduce a monitor step to what it watches. Returns undefined for steps that
+     * carry no recommendation config (an HTTP monitor step, say) — those can
+     * never match a recommendation.
+     *
+     * See `MonitorRecommendationFingerprint` for why each component is here.
+     */
+    static getFingerprintFromMonitorStep(monitorStep) {
+        var _a, _b, _c;
+        const configKind = this.getRecommendationConfigKind(monitorStep);
+        if (!configKind) {
+            return undefined;
+        }
+        const config = monitorStep.data[configKind];
+        const resourceIdentifier = config.clusterIdentifier ||
+            config.hostIdentifier ||
+            config.fleetIdentifier ||
+            this.getTelemetryResourceIdentifier(config) ||
+            "";
+        const metricNames = [];
+        const metricAliases = [];
+        const queryAttributes = [];
+        const formulas = [];
+        for (const queryConfig of ((_a = config.metricViewConfig) === null || _a === void 0 ? void 0 : _a.queryConfigs) || []) {
+            const metricName = this.getMetricNameFromQueryConfig(queryConfig);
+            if (metricName) {
+                metricNames.push(metricName);
+            }
+            const metricAlias = (_b = queryConfig.metricAliasData) === null || _b === void 0 ? void 0 : _b.metricVariable;
+            if (metricAlias) {
+                metricAliases.push(metricAlias);
+            }
+            queryAttributes.push(this.getQueryAttributeKey(queryConfig));
+        }
+        for (const formulaConfig of ((_c = config.metricViewConfig) === null || _c === void 0 ? void 0 : _c.formulaConfigs) || []) {
+            const formula = this.getFormulaFromFormulaConfig(formulaConfig);
+            if (formula) {
+                formulas.push(formula);
+            }
+        }
+        return {
+            resourceIdentifier: resourceIdentifier,
+            configKind: configKind,
+            /*
+             * Every list is sorted so that declaration order inside a template is
+             * not part of the identity — a template author reordering two queries
+             * must not orphan every monitor already created from it.
+             */
+            metricNames: metricNames.sort(),
+            formulas: formulas.sort(),
+            metricAliases: metricAliases.sort(),
+            queryAttributes: queryAttributes.sort(),
+            criteriaFilters: this.getCriteriaFilterKeys(monitorStep).sort(),
+            configValues: this.getConfigValues(configKind, config).sort(),
+        };
+    }
+    /*
+     * Which recommendation-capable config the step carries, as the property
+     * name.
+     *
+     * Returned instead of the config object itself because the NAME is part of
+     * the fingerprint: Docker, Docker Swarm and Podman ship structurally
+     * identical metric configs, so a Docker monitor and a Podman monitor
+     * watching container CPU are indistinguishable by contents alone.
+     */
+    static getRecommendationConfigKind(monitorStep) {
+        if (!monitorStep.data) {
+            return undefined;
+        }
+        const kinds = [
+            "kubernetesMonitor",
+            "hostMonitor",
+            "dockerMonitor",
+            "dockerSwarmMonitor",
+            "podmanMonitor",
+            "proxmoxMonitor",
+            "cephMonitor",
+            "iotMonitor",
+            "metricMonitor",
+            "traceMonitor",
+            "exceptionMonitor",
+        ];
+        const data = monitorStep.data;
+        return kinds.find((kind) => {
+            return Boolean(data[kind]);
+        });
+    }
+    static getTelemetryResourceIdentifier(config) {
+        return (config.telemetryServiceIds || [])
+            .map((id) => {
+            return id.toString();
+        })
+            .sort()
+            .join(",");
+    }
+    /*
+     * Query inputs that do not live in a metric view. They must participate in
+     * coverage identity: an all-span trace monitor does not cover an error-span
+     * recommendation, and a project-wide metric monitor does not cover the same
+     * metric scoped to one RUM application.
+     */
+    static getConfigValues(configKind, config) {
+        var _a, _b, _c;
+        const values = [];
+        if (config.metricViewConfig) {
+            values.push(`rollingTime=${String((_a = config.rollingTime) !== null && _a !== void 0 ? _a : "")}`);
+        }
+        if (configKind === "traceMonitor") {
+            values.push(`attributes=${this.getStableRecordKey(config.attributes || {})}`, `spanStatuses=${(config.spanStatuses || []).map(String).sort().join(",")}`, `spanName=${config.spanName || ""}`, `entityKeys=${(config.entityKeys || []).slice().sort().join(",")}`, `lastXSecondsOfSpans=${String((_b = config.lastXSecondsOfSpans) !== null && _b !== void 0 ? _b : "")}`);
+        }
+        if (configKind === "exceptionMonitor") {
+            values.push(`exceptionTypes=${(config.exceptionTypes || []).slice().sort().join(",")}`, `message=${config.message || ""}`, `entityKeys=${(config.entityKeys || []).slice().sort().join(",")}`, `includeResolved=${String(Boolean(config.includeResolved))}`, `includeArchived=${String(Boolean(config.includeArchived))}`, `lastXSecondsOfExceptions=${String((_c = config.lastXSecondsOfExceptions) !== null && _c !== void 0 ? _c : "")}`);
+        }
+        return values;
+    }
+    static getStableRecordKey(record) {
+        return Object.keys(record)
+            .sort()
+            .map((key) => {
+            return `${key}=${String(record[key])}`;
+        })
+            .join(",");
+    }
+    /*
+     * The attribute filter on one query, as a stable string.
+     *
+     * Keys are sorted before serializing: `{ name: "X", severity: "Y" }` and
+     * `{ severity: "Y", name: "X" }` describe the same query, and JSON.stringify
+     * alone would call them different.
+     */
+    static getQueryAttributeKey(queryConfig) {
+        var _a, _b;
+        const attributes = (_b = (_a = queryConfig.metricQueryData) === null || _a === void 0 ? void 0 : _a.filterData) === null || _b === void 0 ? void 0 : _b["attributes"];
+        if (!attributes || typeof attributes !== "object") {
+            return "";
+        }
+        const record = attributes;
+        return Object.keys(record).length > 0
+            ? this.getStableRecordKey(record)
+            : "";
+    }
+    /*
+     * Every threshold the step evaluates, as stable strings.
+     *
+     * Covers all criteria instances, healthy and unhealthy alike: the recovery
+     * criteria's own threshold is equally part of what the step watches, and two
+     * templates that differ only in their recovery bound are still two different
+     * monitors.
+     *
+     * `metricAlias` is included because a multi-query step's filters are only
+     * meaningful against the series they name.
+     */
+    static getCriteriaFilterKeys(monitorStep) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const keys = [];
+        const criteriaInstances = ((_c = (_b = (_a = monitorStep.data) === null || _a === void 0 ? void 0 : _a.monitorCriteria) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.monitorCriteriaInstanceArray) ||
+            [];
+        for (const criteriaInstance of criteriaInstances) {
+            for (const filter of ((_d = criteriaInstance.data) === null || _d === void 0 ? void 0 : _d.filters) || []) {
+                keys.push([
+                    String((_e = filter.checkOn) !== null && _e !== void 0 ? _e : ""),
+                    String((_f = filter.filterType) !== null && _f !== void 0 ? _f : ""),
+                    String((_g = filter.value) !== null && _g !== void 0 ? _g : ""),
+                    String((_j = (_h = filter.metricMonitorOptions) === null || _h === void 0 ? void 0 : _h.metricAlias) !== null && _j !== void 0 ? _j : ""),
+                ].join("|"));
+            }
+        }
+        return keys;
+    }
+    static getMetricNameFromQueryConfig(queryConfig) {
+        var _a, _b;
+        const metricName = (_b = (_a = queryConfig.metricQueryData) === null || _a === void 0 ? void 0 : _a.filterData) === null || _b === void 0 ? void 0 : _b["metricName"];
+        if (typeof metricName === "string" && metricName) {
+            return metricName;
+        }
+        return undefined;
+    }
+    static getFormulaFromFormulaConfig(formulaConfig) {
+        var _a;
+        const formula = (_a = formulaConfig.metricFormulaData) === null || _a === void 0 ? void 0 : _a.metricFormula;
+        if (typeof formula === "string" && formula) {
+            return formula;
+        }
+        return undefined;
+    }
+    /*
+     * A positional array rather than the object, so the serialization is stable
+     * regardless of the order the fields were written in. Every component of
+     * `MonitorRecommendationFingerprint` must appear here — a field added to the
+     * interface but forgotten below is invisible: the type checker is satisfied
+     * and the fingerprint silently keeps ignoring it, which is exactly the class
+     * of bug the interface's own comment describes.
+     */
+    static serializeFingerprint(fingerprint) {
+        return JSON.stringify([
+            fingerprint.resourceIdentifier,
+            fingerprint.configKind,
+            fingerprint.metricNames,
+            fingerprint.formulas,
+            fingerprint.metricAliases,
+            fingerprint.queryAttributes,
+            fingerprint.criteriaFilters,
+            fingerprint.configValues,
+        ]);
+    }
+    static areFingerprintsEqual(a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        return this.serializeFingerprint(a) === this.serializeFingerprint(b);
+    }
+    /*
+     * Which recommendations are already covered by monitors that exist.
+     *
+     * `existingMonitorSteps` is every step of every monitor already attached to
+     * this resource. A recommendation counts as covered when its freshly-built
+     * step fingerprints identically to one of them — i.e. same resource, same
+     * metrics, same formulas.
+     *
+     * `args` must use the same resource identifier the existing monitors were
+     * created with, otherwise nothing will ever match.
+     */
+    static getCoveredRecommendationIds(data) {
+        const existingFingerprints = new Set();
+        for (const monitorStep of data.existingMonitorSteps) {
+            const fingerprint = this.getFingerprintFromMonitorStep(monitorStep);
+            if (fingerprint) {
+                existingFingerprints.add(this.serializeFingerprint(fingerprint));
+            }
+        }
+        const covered = new Set();
+        if (existingFingerprints.size === 0) {
+            return covered;
+        }
+        for (const recommendation of data.recommendations) {
+            const fingerprint = this.getSerializedFingerprintForRecommendation({
+                recommendation: recommendation,
+                args: data.args,
+            });
+            if (fingerprint && existingFingerprints.has(fingerprint)) {
+                covered.add(recommendation.recommendationId);
+            }
+        }
+        return covered;
+    }
+    /*
+     * Same diff as `getCoveredRecommendationIds`, but keeps WHICH monitor
+     * covers each recommendation instead of only that one does.
+     *
+     * The set-only version is enough to grey a card out, and that is all the
+     * page could do with it: a user looking at "Already created" had no way to
+     * get from the card to the monitor to check its thresholds, its on-call
+     * policy, or whether it is even enabled. Returning the id lets the card link
+     * there.
+     *
+     * When several monitors fingerprint identically — which happens when someone
+     * creates the same recommendation twice by hand — the FIRST is kept, matching
+     * the order the caller passed them in (the API sorts monitors, so this is
+     * stable across loads rather than whichever row Postgres returned first).
+     */
+    static getCoveredRecommendationMonitorIds(data) {
+        const monitorIdByFingerprint = new Map();
+        for (const existingMonitor of data.existingMonitors) {
+            for (const monitorStep of existingMonitor.monitorSteps) {
+                const fingerprint = this.getFingerprintFromMonitorStep(monitorStep);
+                if (!fingerprint) {
+                    continue;
+                }
+                const serialized = this.serializeFingerprint(fingerprint);
+                if (!monitorIdByFingerprint.has(serialized)) {
+                    monitorIdByFingerprint.set(serialized, existingMonitor.monitorId);
+                }
+            }
+        }
+        const covered = new Map();
+        if (monitorIdByFingerprint.size === 0) {
+            return covered;
+        }
+        for (const recommendation of data.recommendations) {
+            const fingerprint = this.getSerializedFingerprintForRecommendation({
+                recommendation: recommendation,
+                args: data.args,
+            });
+            if (!fingerprint) {
+                continue;
+            }
+            const monitorId = monitorIdByFingerprint.get(fingerprint);
+            if (monitorId) {
+                covered.set(recommendation.recommendationId, monitorId);
+            }
+        }
+        return covered;
+    }
+    /*
+     * Build a recommendation's step exactly as the create flow would, and reduce
+     * it to its serialized fingerprint.
+     *
+     * The `monitorName` recomputation matters: templates interpolate the monitor
+     * name into incident titles, and while the name is not part of the
+     * fingerprint, building the step with a different name than the create flow
+     * uses would be an easy way for the two paths to drift apart later.
+     */
+    static getSerializedFingerprintForRecommendation(data) {
+        const fingerprint = this.getFingerprintFromMonitorStep(data.recommendation.getMonitorStep(Object.assign(Object.assign({}, data.args), { monitorName: this.getMonitorName({
+                recommendation: data.recommendation,
+                resourceDisplayName: data.args.monitorName,
+            }) })));
+        if (!fingerprint) {
+            return undefined;
+        }
+        return this.serializeFingerprint(fingerprint);
+    }
+    /*
+     * The recommendations worth showing first: not yet covered, Critical before
+     * Warning, otherwise the module's own declaration order (which puts the
+     * most important templates first).
+     */
+    static sortRecommendations(data) {
+        const indexOf = new Map();
+        data.recommendations.forEach((recommendation, index) => {
+            indexOf.set(recommendation.recommendationId, index);
+        });
+        return [...data.recommendations].sort((a, b) => {
+            var _a, _b;
+            const aCovered = data.coveredRecommendationIds.has(a.recommendationId);
+            const bCovered = data.coveredRecommendationIds.has(b.recommendationId);
+            if (aCovered !== bCovered) {
+                return aCovered ? 1 : -1;
+            }
+            if (a.severity !== b.severity) {
+                return a.severity === "Critical" ? -1 : 1;
+            }
+            return (((_a = indexOf.get(a.recommendationId)) !== null && _a !== void 0 ? _a : 0) -
+                ((_b = indexOf.get(b.recommendationId)) !== null && _b !== void 0 ? _b : 0));
+        });
+    }
+}
+//# sourceMappingURL=MonitorRecommendationUtil.js.map