@oneuptime/common 13.0.5 → 13.0.6

package/build/dist/Utils/Slo/SloFeedMarkdown.js

@@ -0,0 +1,934 @@
+import SloStatus from "../../Types/ServiceLevelObjective/SloStatus";
+import SloWindowType from "../../Types/ServiceLevelObjective/SloWindowType";
+import { escapeMarkdownInline } from "../Markdown/MarkdownEscape";
+/*
+ * The words of the SLO feed.
+ *
+ * Every SLO feed item is written by server code - the SLO service hooks, the
+ * burn rate rule service and the evaluation worker - but what it SAYS lives
+ * here, in one module with no database, React or window import, for two
+ * reasons:
+ *
+ *   - Safety. Feed items render without the markdown viewer's safe mode, and
+ *     almost every value in them is user-controlled: SLO, monitor, rule, label
+ *     and status names, descriptions, timezones. Everything that is not a
+ *     number we computed goes through escapeMarkdownInline exactly once, here,
+ *     so no caller can forget to and no caller can do it twice.
+ *
+ *   - Change detection. "What changed" is decided by comparing a row read
+ *     before an update with the row read after it. That comparison has to
+ *     agree with how the value is shown ("99.9%" -> "99.9%" is not a change,
+ *     a label set in a different order is not a change), so the diff and the
+ *     formatting sit side by side and are unit-tested together.
+ */
+export const SLO_FEED_NOT_SET_TEXT = "_not set_";
+export const SLO_FEED_NONE_TEXT = "_none_";
+/*
+ * A description is free text of any length; the feed is a timeline, not an
+ * editor. Long values are cut here and the full text stays one click away on
+ * the SLO itself.
+ */
+const MAX_INLINE_TEXT_LENGTH = 160;
+// Names listed inline in a single "Labels: a, b, c" style value.
+const MAX_LISTED_NAMES = 10;
+// Monitors named in the one-line summary of an attach/detach item.
+const MAX_SUMMARY_MONITORS = 3;
+// Monitors listed in More Information before collapsing into "and N more".
+const MAX_DETAIL_MONITORS = 50;
+/*
+ * Rounds for reading, never for deciding. "-0" is folded into "0" because a
+ * budget that rounds to zero is not "negative zero percent" to anybody.
+ */
+export const formatSloFeedNumber = (value, maximumFractionDigits = 2) => {
+    if (!Number.isFinite(value)) {
+        return "0";
+    }
+    const factor = Math.pow(10, maximumFractionDigits);
+    const rounded = Math.round(value * factor) / factor;
+    return (Object.is(rounded, -0) ? 0 : rounded).toString();
+};
+export const formatSloFeedPercent = (value, maximumFractionDigits = 2) => {
+    return `${formatSloFeedNumber(value, maximumFractionDigits)}%`;
+};
+const pluralize = (count, singular) => {
+    return `${count} ${count === "1" ? singular : `${singular}s`}`;
+};
+/*
+ * Burn rate windows are stored in minutes but thought about in hours and days
+ * ("1 hour", "6 hours"), so a whole number of hours or days is shown as one.
+ */
+export const formatSloFeedMinutes = (minutes) => {
+    if (!Number.isFinite(minutes)) {
+        return SLO_FEED_NOT_SET_TEXT;
+    }
+    if (minutes !== 0 && minutes % 1440 === 0) {
+        return pluralize(formatSloFeedNumber(minutes / 1440), "day");
+    }
+    if (minutes !== 0 && minutes % 60 === 0) {
+        return pluralize(formatSloFeedNumber(minutes / 60), "hour");
+    }
+    return pluralize(formatSloFeedNumber(minutes), "minute");
+};
+/*
+ * An error budget in the unit a person would say it in: seconds only when it
+ * really is seconds, minutes up to two hours, then hours, then days. The sign
+ * is dropped - callers say "remaining" or "over budget" around it.
+ */
+export const formatSloFeedDuration = (seconds) => {
+    const absoluteSeconds = Number.isFinite(seconds)
+        ? Math.abs(seconds)
+        : 0;
+    if (absoluteSeconds < 60) {
+        return pluralize(formatSloFeedNumber(absoluteSeconds, 0), "second");
+    }
+    if (absoluteSeconds < 2 * 60 * 60) {
+        return pluralize(formatSloFeedNumber(absoluteSeconds / 60, 0), "minute");
+    }
+    if (absoluteSeconds < 48 * 60 * 60) {
+        return pluralize(formatSloFeedNumber(absoluteSeconds / 3600, 1), "hour");
+    }
+    return pluralize(formatSloFeedNumber(absoluteSeconds / 86400, 1), "day");
+};
+/*
+ * User text for the middle of a sentence: escaped, trimmed, and cut at a
+ * length a timeline can carry. Cutting happens BEFORE escaping so an escape
+ * sequence can never be split in half and leave a dangling backslash.
+ */
+export const formatSloFeedText = (value, maximumLength = MAX_INLINE_TEXT_LENGTH) => {
+    if (value === undefined || value === null) {
+        return "";
+    }
+    const text = String(value).replace(/\s+/g, " ").trim();
+    if (text.length <= maximumLength) {
+        return escapeMarkdownInline(text);
+    }
+    return `${escapeMarkdownInline(text.substring(0, maximumLength).trimEnd())}…`;
+};
+/*
+ * Ids are uuids, and Postgres hands them back lower-case whatever case an API
+ * caller wrote them in - so "the same monitor" must compare equal across both.
+ */
+const normalizeId = (value) => {
+    const id = value.trim().toLowerCase();
+    return id && id !== "[object object]" ? id : null;
+};
+const toIdString = (value) => {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === "object") {
+        const record = value;
+        // A model row (`_id` string / `id` ObjectID) or a `{ _id }` payload stub.
+        if (record["_id"] !== undefined && record["_id"] !== null) {
+            return normalizeId(String(record["_id"]));
+        }
+        if (record["id"] !== undefined && record["id"] !== null) {
+            return normalizeId(String(record["id"]));
+        }
+    }
+    // A bare id string, or an ObjectID whose toString is the id.
+    return normalizeId(String(value));
+};
+/*
+ * The ids in a many-to-many value, whatever shape it arrived in: model rows
+ * read from the database, `{ _id }` stubs from the dashboard form, bare id
+ * strings or ObjectIDs from the API. Sorted and de-duplicated, so two sets
+ * that differ only in order compare equal.
+ */
+export const getSloFeedEntityIds = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const ids = new Set();
+    for (const item of value) {
+        const id = toIdString(item);
+        if (id) {
+            ids.add(id);
+        }
+    }
+    return Array.from(ids).sort();
+};
+const getEntityName = (item) => {
+    if (!item || typeof item !== "object") {
+        return "";
+    }
+    const record = item;
+    // User.name is a Name value object, Label.name a string - both stringify.
+    for (const key of ["name", "email"]) {
+        const candidate = record[key];
+        if (candidate !== undefined && candidate !== null) {
+            const text = String(candidate).trim();
+            if (text) {
+                return text;
+            }
+        }
+    }
+    return "";
+};
+/*
+ * "Production, Tier 1" for a label set, alphabetical so the before and after
+ * of an unchanged set read identically. A related row whose name could not be
+ * read is still counted rather than silently dropped.
+ */
+export const formatSloFeedEntityNames = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return SLO_FEED_NONE_TEXT;
+    }
+    const names = value
+        .map((item) => {
+        return getEntityName(item) || "Unnamed";
+    })
+        .sort((a, b) => {
+        return a.localeCompare(b);
+    });
+    const listed = names
+        .slice(0, MAX_LISTED_NAMES)
+        .map((name) => {
+        return formatSloFeedText(name, 80);
+    });
+    const remaining = names.length - listed.length;
+    return remaining > 0
+        ? `${listed.join(", ")} and ${remaining} more`
+        : listed.join(", ");
+};
+/*
+ * The CRUD API does not coerce Boolean columns, so "false" can reach a hook as
+ * a string. Anything that is not recognisably true or false is "not set".
+ */
+export const normalizeSloFeedBoolean = (value) => {
+    if (value === true || value === false) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0") {
+            return false;
+        }
+        return null;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    return null;
+};
+const normalizeNumber = (value) => {
+    if (value === undefined || value === null || value === "") {
+        return null;
+    }
+    const numeric = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+};
+/*
+ * ---------------------------------------------------------------------------
+ * Column changes
+ * ---------------------------------------------------------------------------
+ */
+export var SloFeedValueKind;
+(function (SloFeedValueKind) {
+    // Short user text shown in full (a name, a timezone, an enum value).
+    SloFeedValueKind["Text"] = "Text";
+    // Free text shown truncated, and never quoted in a one-line summary.
+    SloFeedValueKind["LongText"] = "LongText";
+    // Compared, never printed: templates and notes can be long markdown.
+    SloFeedValueKind["Opaque"] = "Opaque";
+    SloFeedValueKind["Percent"] = "Percent";
+    SloFeedValueKind["Days"] = "Days";
+    SloFeedValueKind["Minutes"] = "Minutes";
+    // A burn rate multiple, e.g. 14.4x.
+    SloFeedValueKind["Multiplier"] = "Multiplier";
+    SloFeedValueKind["Count"] = "Count";
+    SloFeedValueKind["Boolean"] = "Boolean";
+    // A many-to-many relation selected as rows with a name.
+    SloFeedValueKind["EntityList"] = "EntityList";
+    // A foreign key column whose name is read from `relationProperty`.
+    SloFeedValueKind["EntityReference"] = "EntityReference";
+})(SloFeedValueKind || (SloFeedValueKind = {}));
+const DEFAULT_RELATION_SELECT = {
+    _id: true,
+    name: true,
+};
+/*
+ * The watched columns an update payload actually writes. A key present with
+ * the value `undefined` writes nothing, so it does not count - otherwise a
+ * form that spreads an object with an undefined field would cost a read and
+ * post an item about a column it never touched.
+ */
+export const getSloFeedColumnsInPayload = (data, columns) => {
+    if (!data || typeof data !== "object") {
+        return [];
+    }
+    const record = data;
+    return columns.filter((column) => {
+        return (Object.prototype.hasOwnProperty.call(record, column.column) &&
+            record[column.column] !== undefined);
+    });
+};
+/*
+ * The select for a before/after read of exactly the columns being watched,
+ * with relation columns expanded to the fields the feed prints.
+ */
+export const getSloFeedSelect = (columns) => {
+    const select = {};
+    for (const column of columns) {
+        if (column.kind === SloFeedValueKind.EntityList) {
+            select[column.column] = Object.assign({}, (column.relationSelect || DEFAULT_RELATION_SELECT));
+            continue;
+        }
+        select[column.column] = true;
+        if (column.kind === SloFeedValueKind.EntityReference &&
+            column.relationProperty) {
+            select[column.relationProperty] = Object.assign({}, (column.relationSelect || DEFAULT_RELATION_SELECT));
+        }
+    }
+    return select;
+};
+export const isSloFeedValueEqual = (column, before, after) => {
+    const beforeValue = before[column.column];
+    const afterValue = after[column.column];
+    switch (column.kind) {
+        case SloFeedValueKind.EntityList:
+            return (getSloFeedEntityIds(beforeValue).join(",") ===
+                getSloFeedEntityIds(afterValue).join(","));
+        case SloFeedValueKind.EntityReference:
+            return toIdString(beforeValue) === toIdString(afterValue);
+        case SloFeedValueKind.Percent:
+        case SloFeedValueKind.Days:
+        case SloFeedValueKind.Minutes:
+        case SloFeedValueKind.Multiplier:
+        case SloFeedValueKind.Count:
+            return normalizeNumber(beforeValue) === normalizeNumber(afterValue);
+        case SloFeedValueKind.Boolean:
+            return (normalizeSloFeedBoolean(beforeValue) ===
+                normalizeSloFeedBoolean(afterValue));
+        default:
+            // Text kinds: an empty string and a null are both "not set".
+            return (String(beforeValue !== null && beforeValue !== void 0 ? beforeValue : "").trim() === String(afterValue !== null && afterValue !== void 0 ? afterValue : "").trim());
+    }
+};
+export const formatSloFeedValue = (column, row) => {
+    const value = row[column.column];
+    const emptyText = column.emptyText || SLO_FEED_NOT_SET_TEXT;
+    switch (column.kind) {
+        case SloFeedValueKind.EntityList:
+            return formatSloFeedEntityNames(value);
+        case SloFeedValueKind.EntityReference: {
+            if (!toIdString(value)) {
+                return emptyText;
+            }
+            const name = column.relationProperty
+                ? getEntityName(row[column.relationProperty])
+                : "";
+            // The row is referenced but its name could not be read.
+            return name ? formatSloFeedText(name, 80) : "_a deleted item_";
+        }
+        case SloFeedValueKind.Boolean: {
+            const flag = normalizeSloFeedBoolean(value);
+            if (flag === null) {
+                return emptyText;
+            }
+            return flag ? "On" : "Off";
+        }
+        case SloFeedValueKind.Percent:
+        case SloFeedValueKind.Days:
+        case SloFeedValueKind.Minutes:
+        case SloFeedValueKind.Multiplier:
+        case SloFeedValueKind.Count: {
+            const numeric = normalizeNumber(value);
+            if (numeric === null) {
+                return emptyText;
+            }
+            if (column.kind === SloFeedValueKind.Percent) {
+                return formatSloFeedPercent(numeric, 3);
+            }
+            if (column.kind === SloFeedValueKind.Days) {
+                return pluralize(formatSloFeedNumber(numeric), "day");
+            }
+            if (column.kind === SloFeedValueKind.Minutes) {
+                return formatSloFeedMinutes(numeric);
+            }
+            if (column.kind === SloFeedValueKind.Multiplier) {
+                return `${formatSloFeedNumber(numeric)}x`;
+            }
+            return formatSloFeedNumber(numeric);
+        }
+        case SloFeedValueKind.Opaque:
+            return String(value !== null && value !== void 0 ? value : "").trim() ? "_set_" : emptyText;
+        default: {
+            const text = formatSloFeedText(value);
+            return text || emptyText;
+        }
+    }
+};
+/*
+ * The changes worth telling somebody about. With a before-row, a column whose
+ * value did not actually change is dropped - a settings form re-submits every
+ * field it shows, and "Target: 99.9% -> 99.9%" is noise. Without one (the
+ * before-read failed, or the write path deliberately takes none), every
+ * written column is reported with its new value only.
+ */
+export const getSloFeedColumnChanges = (data) => {
+    const changes = [];
+    for (const column of data.columns) {
+        if (data.before && isSloFeedValueEqual(column, data.before, data.after)) {
+            continue;
+        }
+        changes.push({
+            column: column.column,
+            title: column.title,
+            kind: column.kind,
+            from: data.before ? formatSloFeedValue(column, data.before) : null,
+            to: formatSloFeedValue(column, data.after),
+        });
+    }
+    return changes;
+};
+// "**A**", "**A** and **B**", "**A**, **B** and **C**".
+const joinTitles = (titles) => {
+    const bold = titles.map((title) => {
+        return `**${title}**`;
+    });
+    if (bold.length <= 1) {
+        return bold.join("");
+    }
+    return `${bold.slice(0, -1).join(", ")} and ${bold[bold.length - 1]}`;
+};
+const formatChangeLine = (change) => {
+    if (change.kind === SloFeedValueKind.Opaque) {
+        return `**${change.title}**: changed`;
+    }
+    if (change.from === null) {
+        return `**${change.title}**: ${change.to}`;
+    }
+    return `**${change.title}**: ${change.from} → ${change.to}`;
+};
+/*
+ * A single short change is spelled out in the one-line summary, so the
+ * timeline answers "what changed" without opening anything. Several changes,
+ * or a long one, are named in the summary and spelled out in More Information.
+ */
+const formatChangeSummary = (changes) => {
+    const onlyChange = changes.length === 1 ? changes[0] : undefined;
+    if (onlyChange &&
+        onlyChange.kind !== SloFeedValueKind.LongText &&
+        onlyChange.kind !== SloFeedValueKind.Opaque) {
+        return onlyChange.from === null
+            ? `**${onlyChange.title}** set to ${onlyChange.to}`
+            : `**${onlyChange.title}** changed from ${onlyChange.from} to ${onlyChange.to}`;
+    }
+    return `${joinTitles(changes.map((change) => {
+        return change.title;
+    }))} changed`;
+};
+/*
+ * ---------------------------------------------------------------------------
+ * SLO lifecycle items
+ * ---------------------------------------------------------------------------
+ */
+/*
+ * The SLO columns whose edit earns a "was updated" item. A whitelist, never a
+ * blacklist: the evaluation worker writes this row on every tick (SLI, budget,
+ * burn rate, status, cadence stamps) and a blacklist would let the next worker
+ * column added to the model post an item every few minutes per SLO.
+ *
+ * isEnabled / isArchived and the monitor set are watched too, but get items
+ * of their own (see SLO_FEED_WATCHED_COLUMN_NAMES).
+ */
+export const SLO_FEED_UPDATE_COLUMNS = [
+    { column: "name", title: "Name", kind: SloFeedValueKind.Text },
+    {
+        column: "description",
+        title: "Description",
+        kind: SloFeedValueKind.LongText,
+    },
+    { column: "labels", title: "Labels", kind: SloFeedValueKind.EntityList },
+    {
+        column: "targetPercentage",
+        title: "Target",
+        kind: SloFeedValueKind.Percent,
+    },
+    {
+        column: "windowType",
+        title: "Compliance window",
+        kind: SloFeedValueKind.Text,
+    },
+    {
+        column: "windowDays",
+        title: "Rolling window length",
+        kind: SloFeedValueKind.Days,
+    },
+    {
+        column: "timezone",
+        title: "Timezone",
+        kind: SloFeedValueKind.Text,
+        emptyText: "UTC (default)",
+    },
+    {
+        column: "atRiskThresholdPercentage",
+        title: "At-risk threshold",
+        kind: SloFeedValueKind.Percent,
+        emptyText: "_default_",
+    },
+    {
+        column: "multiMonitorMode",
+        title: "Multi-monitor mode",
+        kind: SloFeedValueKind.Text,
+    },
+    {
+        column: "downtimeMonitorStatuses",
+        title: "Downtime monitor statuses",
+        kind: SloFeedValueKind.EntityList,
+    },
+];
+export const SLO_FEED_IS_ENABLED_COLUMN = {
+    column: "isEnabled",
+    title: "Enabled",
+    kind: SloFeedValueKind.Boolean,
+};
+export const SLO_FEED_IS_ARCHIVED_COLUMN = {
+    column: "isArchived",
+    title: "Archived",
+    kind: SloFeedValueKind.Boolean,
+};
+export const SLO_FEED_MONITORS_COLUMN = {
+    column: "monitors",
+    title: "Monitors",
+    kind: SloFeedValueKind.EntityList,
+};
+export const getSloFeedWatchedColumns = (data) => {
+    const watched = [
+        ...SLO_FEED_UPDATE_COLUMNS,
+        SLO_FEED_IS_ENABLED_COLUMN,
+        SLO_FEED_IS_ARCHIVED_COLUMN,
+    ];
+    if (data.includeMonitors) {
+        watched.push(SLO_FEED_MONITORS_COLUMN);
+    }
+    return getSloFeedColumnsInPayload(data.payload, watched);
+};
+// "above 14.4x over 1 hour, confirmed over 5 minutes".
+const describeBurnRateCondition = (rule) => {
+    const threshold = normalizeNumber(rule.burnRateThreshold);
+    const longWindow = normalizeNumber(rule.longWindowInMinutes);
+    const shortWindow = normalizeNumber(rule.shortWindowInMinutes);
+    if (threshold === null || longWindow === null) {
+        return null;
+    }
+    const confirmation = shortWindow === null
+        ? ""
+        : `, confirmed over ${formatSloFeedMinutes(shortWindow)}`;
+    return `burn rate above ${formatSloFeedNumber(threshold)}x over ${formatSloFeedMinutes(longWindow)}${confirmation}`;
+};
+export const describeSloFeedWindow = (data) => {
+    if (data.windowType === SloWindowType.CalendarMonth) {
+        const timezone = formatSloFeedText(data.timezone) || "UTC";
+        return `Calendar month (${timezone})`;
+    }
+    const windowDays = normalizeNumber(data.windowDays);
+    // The worker measures a rolling window with no length as 30 days.
+    return `Rolling ${pluralize(formatSloFeedNumber(windowDays !== null && windowDays !== void 0 ? windowDays : 30), "day")}`;
+};
+export const getSloCreatedFeedMarkdown = (data) => {
+    const details = [
+        data.createdByUserMarkdown
+            ? `**Created by**: ${data.createdByUserMarkdown}`
+            : "**Created by**: No user - it was created through the OneUptime API or by an automation.",
+    ];
+    const target = normalizeNumber(data.targetPercentage);
+    if (target !== null) {
+        details.push(`**Target**: ${formatSloFeedPercent(target, 3)}`);
+    }
+    details.push(`**Compliance window**: ${describeSloFeedWindow(data)}`);
+    if (data.sliType) {
+        details.push(`**SLI**: ${formatSloFeedText(data.sliType)}`);
+    }
+    const atRisk = normalizeNumber(data.atRiskThresholdPercentage);
+    if (atRisk !== null) {
+        details.push(`**At-risk threshold**: ${formatSloFeedPercent(atRisk)} of the error budget remaining`);
+    }
+    /*
+     * The two default rules are part of what "creating an SLO" means, so they
+     * are described here rather than as two more items that would bury the
+     * creation under its own bookkeeping.
+     */
+    const rules = data.defaultBurnRateRules.map((rule) => {
+        const name = formatSloFeedText(rule.name) || "Unnamed rule";
+        const condition = describeBurnRateCondition(rule);
+        return condition ? `${name} (${condition})` : name;
+    });
+    if (rules.length > 0) {
+        details.push(`**Default burn rate rules**: ${rules.join("; ")}`);
+    }
+    const description = formatSloFeedText(data.description);
+    if (description) {
+        details.push(`**Description**: ${description}`);
+    }
+    return {
+        feedInfoInMarkdown: data.createdByUserMarkdown
+            ? `🎯 ${data.sloMarkdownLink} was created by **${data.createdByUserMarkdown}**.`
+            : `🎯 ${data.sloMarkdownLink} was created.`,
+        moreInformationInMarkdown: details.join("\n\n"),
+    };
+};
+export const getSloUpdatedFeedMarkdown = (data) => {
+    return {
+        feedInfoInMarkdown: `📝 ${data.sloMarkdownLink} was updated: ${formatChangeSummary(data.changes)}.`,
+        moreInformationInMarkdown: data.changes
+            .map(formatChangeLine)
+            .join("\n\n"),
+    };
+};
+export const getSloEnabledFeedMarkdown = (data) => {
+    if (data.isEnabled) {
+        return {
+            feedInfoInMarkdown: `▶️ ${data.sloMarkdownLink} was enabled.`,
+            moreInformationInMarkdown: data.isArchived
+                ? "The SLO is still archived, so it stays out of evaluation until it is restored from the archive."
+                : "Evaluation resumes on the next worker tick, which recalculates the SLI, error budget and status.",
+        };
+    }
+    return {
+        feedInfoInMarkdown: `⏸️ ${data.sloMarkdownLink} was disabled.`,
+        moreInformationInMarkdown: "A disabled SLO is not evaluated: its SLI, error budget and status stop updating and its burn rate rules do not fire. Any burn rate alerts and incidents its rules had open were resolved.",
+    };
+};
+export const getSloArchivedFeedMarkdown = (data) => {
+    if (data.isArchived) {
+        return {
+            feedInfoInMarkdown: `🗄️ ${data.sloMarkdownLink} was archived.`,
+            moreInformationInMarkdown: "Archived SLOs are hidden from the SLO list and are not evaluated. Any burn rate alerts and incidents its rules had open were resolved.",
+        };
+    }
+    return {
+        feedInfoInMarkdown: `♻️ ${data.sloMarkdownLink} was restored from the archive.`,
+        moreInformationInMarkdown: data.isEnabled
+            ? "The SLO is back on the SLO list and is evaluated again from the next worker tick."
+            : "The SLO is back on the SLO list. It is still disabled, so it is not evaluated until it is enabled.",
+    };
+};
+export const getSloMonitorsChangedFeedMarkdown = (data) => {
+    const sorted = [...data.monitors].sort((a, b) => {
+        return a.name.localeCompare(b.name);
+    });
+    const links = sorted.map((monitor) => {
+        const name = formatSloFeedText(monitor.name, 80) || "Unnamed monitor";
+        return `[${name}](${monitor.link})`;
+    });
+    const emoji = data.change === "attached" ? "🔗" : "✂️";
+    const preposition = data.change === "attached" ? "to" : "from";
+    let feedInfoInMarkdown;
+    if (links.length === 1) {
+        feedInfoInMarkdown = `${emoji} Monitor ${links[0]} was ${data.change} ${preposition} ${data.sloMarkdownLink}.`;
+    }
+    else {
+        const named = links.slice(0, MAX_SUMMARY_MONITORS);
+        const unnamed = links.length - named.length;
+        feedInfoInMarkdown = `${emoji} ${links.length} monitors were ${data.change} ${preposition} ${data.sloMarkdownLink}: ${named.join(", ")}${unnamed > 0 ? ` and ${unnamed} more` : ""}.`;
+    }
+    const listed = links.slice(0, MAX_DETAIL_MONITORS);
+    const remaining = links.length - listed.length;
+    const lines = [
+        `**Monitors ${data.change}**:`,
+        listed
+            .map((link) => {
+            return `- ${link}`;
+        })
+            .join("\n") + (remaining > 0 ? `\n- and ${remaining} more` : ""),
+        "The SLO is measured against its new monitor set from the next worker tick.",
+    ];
+    return {
+        feedInfoInMarkdown: feedInfoInMarkdown,
+        moreInformationInMarkdown: lines.join("\n\n"),
+    };
+};
+export const getSloStatusEmoji = (status) => {
+    switch (status) {
+        case SloStatus.Healthy:
+            return "🟢";
+        case SloStatus.AtRisk:
+            return "🟡";
+        case SloStatus.BudgetExhausted:
+            return "🔴";
+        case SloStatus.Paused:
+            return "⏸️";
+        default:
+            return "⚠️";
+    }
+};
+export const getSloStatusChangedFeedMarkdown = (data) => {
+    const details = [
+        `**Status**: ${data.previousStatus || "Not evaluated yet"} → ${data.newStatus}`,
+    ];
+    if (data.reason) {
+        details.push(`**Why**: ${data.reason}`);
+    }
+    if (data.measurement) {
+        const measurement = data.measurement;
+        /*
+         * Four decimals on the SLI: targets go to 99.999, and an SLI that rounds
+         * UP to its own target would read as healthy when it is not.
+         */
+        details.push(`**SLI**: ${formatSloFeedPercent(measurement.sliPercentage, 4)} against a ${formatSloFeedPercent(measurement.targetPercentage, 3)} target`);
+        const budgetDuration = formatSloFeedDuration(measurement.errorBudgetRemainingSeconds);
+        details.push(measurement.errorBudgetRemainingSeconds < 0
+            ? `**Error budget remaining**: ${formatSloFeedPercent(measurement.errorBudgetRemainingPercentage)} (over budget by ${budgetDuration})`
+            : `**Error budget remaining**: ${formatSloFeedPercent(measurement.errorBudgetRemainingPercentage)} (${budgetDuration})`);
+        details.push(`**Current burn rate**: ${formatSloFeedNumber(measurement.currentBurnRate)}x over the last ${formatSloFeedMinutes(measurement.currentBurnRateWindowInMinutes)}`);
+        details.push(`**At-risk threshold**: ${formatSloFeedPercent(measurement.atRiskThresholdPercentage)} of the error budget remaining`);
+    }
+    if (data.newStatus === SloStatus.Paused ||
+        data.newStatus === SloStatus.Misconfigured) {
+        details.push(`While the SLO is ${data.newStatus}, its SLI and error budget are not recalculated and its burn rate rules do not fire. Any burn rate alerts and incidents its rules had open were resolved.`);
+    }
+    const was = data.previousStatus
+        ? ` (was ${data.previousStatus})`
+        : "";
+    return {
+        feedInfoInMarkdown: `${getSloStatusEmoji(data.newStatus)} ${data.sloMarkdownLink} is now **${data.newStatus}**${was}.`,
+        moreInformationInMarkdown: details.join("\n\n"),
+    };
+};
+/*
+ * ---------------------------------------------------------------------------
+ * Burn rate rules
+ * ---------------------------------------------------------------------------
+ */
+const USER_RELATION_SELECT = {
+    _id: true,
+    name: true,
+    email: true,
+};
+/*
+ * The burn rate rule columns whose edit earns a "changed" item. A whitelist
+ * for the same reason as the SLO's: the evaluation worker stamps the rule's
+ * lifecycle columns (lastAlertCreatedAt and friends) through the hooked update
+ * path every time it fires or resolves.
+ */
+export const SLO_BURN_RATE_RULE_FEED_COLUMNS = [
+    { column: "name", title: "Name", kind: SloFeedValueKind.Text },
+    { column: "isEnabled", title: "Enabled", kind: SloFeedValueKind.Boolean },
+    {
+        column: "burnRateThreshold",
+        title: "Burn rate threshold",
+        kind: SloFeedValueKind.Multiplier,
+    },
+    {
+        column: "longWindowInMinutes",
+        title: "Long window",
+        kind: SloFeedValueKind.Minutes,
+    },
+    {
+        column: "shortWindowInMinutes",
+        title: "Short window",
+        kind: SloFeedValueKind.Minutes,
+    },
+    {
+        column: "refireSuppressionMinutes",
+        title: "Re-fire suppression",
+        kind: SloFeedValueKind.Minutes,
+        emptyText: "_default_",
+    },
+    {
+        column: "minimumSampleCount",
+        title: "Minimum sample count",
+        kind: SloFeedValueKind.Count,
+    },
+    {
+        column: "shouldCreateAlert",
+        title: "Create alert",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "alertSeverityId",
+        title: "Alert severity",
+        kind: SloFeedValueKind.EntityReference,
+        relationProperty: "alertSeverity",
+    },
+    {
+        column: "onCallDutyPolicies",
+        title: "Alert on-call policies",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "alertTitleTemplate",
+        title: "Alert title template",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "alertDescriptionTemplate",
+        title: "Alert description template",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "alertRemediationNotes",
+        title: "Alert remediation notes",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "isAlertPrivate",
+        title: "Private alert",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "autoResolveAlert",
+        title: "Auto-resolve alert",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "alertLabels",
+        title: "Alert labels",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "alertOwnerTeams",
+        title: "Alert owner teams",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "alertOwnerUsers",
+        title: "Alert owner users",
+        kind: SloFeedValueKind.EntityList,
+        relationSelect: USER_RELATION_SELECT,
+    },
+    {
+        column: "shouldCreateIncident",
+        title: "Declare incident",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "incidentSeverityId",
+        title: "Incident severity",
+        kind: SloFeedValueKind.EntityReference,
+        relationProperty: "incidentSeverity",
+    },
+    {
+        column: "incidentOnCallDutyPolicies",
+        title: "Incident on-call policies",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "incidentTitleTemplate",
+        title: "Incident title template",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "incidentDescriptionTemplate",
+        title: "Incident description template",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "incidentRemediationNotes",
+        title: "Incident remediation notes",
+        kind: SloFeedValueKind.Opaque,
+    },
+    {
+        column: "isIncidentPrivate",
+        title: "Private incident",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "autoResolveIncident",
+        title: "Auto-resolve incident",
+        kind: SloFeedValueKind.Boolean,
+    },
+    {
+        column: "incidentLabels",
+        title: "Incident labels",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "incidentOwnerTeams",
+        title: "Incident owner teams",
+        kind: SloFeedValueKind.EntityList,
+    },
+    {
+        column: "incidentOwnerUsers",
+        title: "Incident owner users",
+        kind: SloFeedValueKind.EntityList,
+        relationSelect: USER_RELATION_SELECT,
+    },
+    {
+        column: "addSloOwnersAsOwners",
+        title: "Add SLO owners as owners",
+        kind: SloFeedValueKind.Boolean,
+    },
+];
+const describeRuleOutputs = (rule) => {
+    const alert = normalizeSloFeedBoolean(rule.shouldCreateAlert);
+    const incident = normalizeSloFeedBoolean(rule.shouldCreateIncident);
+    if (alert === null && incident === null) {
+        return null;
+    }
+    // The column defaults: a rule raises an alert unless told otherwise.
+    const raisesAlert = alert !== false;
+    const declaresIncident = incident === true;
+    if (raisesAlert && declaresIncident) {
+        return "raises an alert and declares an incident";
+    }
+    if (declaresIncident) {
+        return "declares an incident";
+    }
+    return raisesAlert ? "raises an alert" : "raises nothing";
+};
+const getRuleDetails = (rule) => {
+    const details = [];
+    const condition = describeBurnRateCondition(rule);
+    if (condition) {
+        details.push(`**Fires on**: ${condition}`);
+    }
+    const outputs = describeRuleOutputs(rule);
+    if (outputs) {
+        details.push(`**When it fires**: it ${outputs}`);
+    }
+    const enabled = normalizeSloFeedBoolean(rule.isEnabled);
+    if (enabled !== null) {
+        details.push(`**Enabled**: ${enabled ? "Yes" : "No"}`);
+    }
+    return details;
+};
+const formatRuleName = (name) => {
+    return formatSloFeedText(name, 80) || "Unnamed rule";
+};
+export const getBurnRateRuleAddedFeedMarkdown = (data) => {
+    return {
+        feedInfoInMarkdown: `🔥 Burn rate rule **${formatRuleName(data.rule.name)}** was added to ${data.sloMarkdownLink}.`,
+        moreInformationInMarkdown: getRuleDetails(data.rule).join("\n\n"),
+    };
+};
+export const getBurnRateRuleChangedFeedMarkdown = (data) => {
+    const ruleName = formatRuleName(data.ruleName);
+    const onlyChange = data.changes.length === 1 ? data.changes[0] : undefined;
+    // Turning a rule on or off is the one change people scan the feed for.
+    if (onlyChange && onlyChange.column === "isEnabled") {
+        const isEnabled = onlyChange.to === "On";
+        return {
+            feedInfoInMarkdown: `🔥 Burn rate rule **${ruleName}** on ${data.sloMarkdownLink} was ${isEnabled ? "enabled" : "disabled"}.`,
+            moreInformationInMarkdown: isEnabled
+                ? "The rule is evaluated again on the next worker tick."
+                : "A disabled rule does not fire. Any alerts and incidents it had open were resolved.",
+        };
+    }
+    return {
+        feedInfoInMarkdown: `🔥 Burn rate rule **${ruleName}** on ${data.sloMarkdownLink} was updated: ${formatChangeSummary(data.changes)}.`,
+        moreInformationInMarkdown: data.changes
+            .map(formatChangeLine)
+            .join("\n\n"),
+    };
+};
+export const getBurnRateRuleRemovedFeedMarkdown = (data) => {
+    return {
+        feedInfoInMarkdown: `🔥 Burn rate rule **${formatRuleName(data.rule.name)}** was removed from ${data.sloMarkdownLink}.`,
+        moreInformationInMarkdown: [
+            ...getRuleDetails({
+                name: data.rule.name,
+                burnRateThreshold: data.rule.burnRateThreshold,
+                longWindowInMinutes: data.rule.longWindowInMinutes,
+                shortWindowInMinutes: data.rule.shortWindowInMinutes,
+            }),
+            "Any alerts and incidents the rule had open were resolved.",
+        ].join("\n\n"),
+    };
+};
+//# sourceMappingURL=SloFeedMarkdown.js.map