@oneuptime/common 12.0.34 → 13.0.0

package/Server/Types/Markdown.ts

@@ -119,7 +119,15 @@ export default class Markdown {
     return htmlBody;
   }
 
-  private static escapeHtml(text: string): string {
+  /**
+   * Escape the five characters that can break out of HTML text or an
+   * attribute value.
+   *
+   * Public because it is not only marked's business: code that hand-builds
+   * an email fragment by string interpolation needs the same escaping, and
+   * a second implementation is a second thing to get wrong.
+   */
+  public static escapeHtml(text: string): string {
     return text
       .replace(/&/g, "&")
       .replace(/</g, "&lt;")
@@ -128,6 +136,31 @@ export default class Markdown {
       .replace(/'/g, "&#39;");
   }
 
+  /*
+   * The email renderer.
+   *
+   * Everything here is an INLINE style, and that is not a preference.
+   * MailService compiles the Handlebars template and sends it — there is no
+   * CSS inlining step anywhere in the pipeline — and Gmail strips <style>
+   * blocks from the document head, so a class name emitted here reaches the
+   * reader as nothing at all. That is why the Docs/Blog renderers' Tailwind
+   * classes cannot be copied even though the override shape can.
+   *
+   * Until this existed the renderer was a bare `new Renderer()`. Alert and
+   * incident root causes carry a GitHub-flavoured table of breaching
+   * samples, and marked emitted it as a naked <table> with no borders, no
+   * padding and no alignment: every row ran into the next, which is
+   * precisely the part of the email an on-call engineer reads first.
+   *
+   * Outlook renders through Word, which ignores border-radius, box-shadow
+   * and — importantly — overflow, so the scrolling wrapper the Docs and
+   * Blog renderers use does not transfer. The table has to FIT instead:
+   * the DetailBox card is 472px wide with 28px of padding either side,
+   * leaving roughly 416px for a root-cause table that routinely runs to
+   * four or more columns. Hence `width:100%` with `table-layout:auto` and
+   * `word-break:break-word` on the cells — a long metric name wraps inside
+   * its column rather than pushing the table past the body width.
+   */
   private static getEmailRenderer(): Renderer {
     if (this.emailRenderer !== null) {
       return this.emailRenderer;
@@ -135,6 +168,65 @@ export default class Markdown {
 
     const renderer: Renderer = new Renderer();
 
+    const cellFont: string =
+      "font-family:'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', sans-serif;font-size:13px;line-height:20px;";
+
+    renderer.table = function (header: string, body: string): string {
+      return (
+        `<table cellpadding="0" cellspacing="0" border="0" width="100%" ` +
+        `style="border-collapse:collapse;width:100%;table-layout:auto;` +
+        `margin:12px 0;border:1px solid #e2e8f0;">` +
+        `<thead>${header}</thead><tbody>${body}</tbody></table>`
+      );
+    };
+
+    renderer.tablerow = function (content: string): string {
+      return `<tr>${content}</tr>`;
+    };
+
+    renderer.tablecell = function (
+      content: string,
+      flags: { header?: boolean; align?: string | null },
+    ): string {
+      const tag: string = flags.header ? "th" : "td";
+      const align: string = flags.align ? `text-align:${flags.align};` : "";
+
+      /*
+       * A header cell gets the tinted band and the heavier bottom rule; a
+       * body cell gets a hairline so consecutive rows stay separable. Both
+       * keep the same padding so the columns line up.
+       */
+      const tone: string = flags.header
+        ? "background-color:#f8fafc;color:#475569;font-weight:600;border-bottom:1px solid #cbd5e1;"
+        : "color:#1e293b;font-weight:400;border-bottom:1px solid #f1f5f9;";
+
+      return (
+        `<${tag} style="padding:8px 10px;${cellFont}${tone}` +
+        `word-break:break-word;${align || "text-align:left;"}">` +
+        `${content}</${tag}>`
+      );
+    };
+
+    /*
+     * The root cause backticks metric names, aliases and timestamps. Left
+     * bare they were indistinguishable from the prose around them.
+     *
+     * `code` arrives ALREADY escaped — marked escapes codespan text before
+     * it reaches the renderer — so escaping again here would turn a typed
+     * "<img>" into the literal "&lt;img&gt;" on screen rather than the
+     * "<img>" the author wrote. (The Docs and BlogValidation renderers do
+     * escape a second time; that is a separate defect in those surfaces,
+     * not a pattern to copy.)
+     */
+    renderer.codespan = function (code: string): string {
+      return (
+        `<code style="background-color:#f1f5f9;color:#0f172a;` +
+        `padding:1px 5px;border-radius:4px;` +
+        `font-family:'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;` +
+        `font-size:12px;">${code}</code>`
+      );
+    };
+
     this.emailRenderer = renderer;
 
     return renderer;

package/Server/Utils/Dashboard/PublicDashboardResourceListPolicy.ts

@@ -21,6 +21,7 @@ import DashboardModelQueryInterpolation, {
   AttributeToColumnMap,
 } from "../../../Utils/Dashboard/ModelQueryVariableInterpolation";
 import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
+import DashboardLabelVariable from "../../../Utils/Dashboard/LabelVariable";
 
 export interface PublicDashboardResourceListPolicyResult {
   resourceType: string;
@@ -180,6 +181,7 @@ export default class PublicDashboardResourceListPolicy {
       componentType: componentType as DashboardComponentType,
       argumentsObject,
       requestedQuery: data.requestedQuery,
+      variables,
     });
 
     let query: Record<string, unknown> = draft.query;
@@ -505,8 +507,9 @@ export default class PublicDashboardResourceListPolicy {
     componentType: DashboardComponentType;
     argumentsObject: Record<string, unknown>;
     requestedQuery: unknown;
+    variables: Array<DashboardVariable>;
   }): PolicyDraft {
-    const { componentType, argumentsObject, requestedQuery } = data;
+    const { componentType, argumentsObject, requestedQuery, variables } = data;
 
     switch (componentType) {
       case DashboardComponentType.IncidentList:
@@ -520,6 +523,7 @@ export default class PublicDashboardResourceListPolicy {
       case DashboardComponentType.MonitorList:
         return PublicDashboardResourceListPolicy.buildMonitorPolicy(
           argumentsObject,
+          variables,
         );
       case DashboardComponentType.NetworkMap:
         return PublicDashboardResourceListPolicy.buildNetworkMapPolicy(
@@ -814,6 +818,7 @@ export default class PublicDashboardResourceListPolicy {
 
   private static buildMonitorPolicy(
     argumentsObject: Record<string, unknown>,
+    variables: Array<DashboardVariable>,
   ): PolicyDraft {
     const query: Record<string, unknown> = {};
     const statusFilter: string | undefined =
@@ -841,12 +846,22 @@ export default class PublicDashboardResourceListPolicy {
       argumentsObject,
       argumentKey: "monitorTypes",
     });
-    PublicDashboardResourceListPolicy.addIncludesFromArgument({
-      query,
-      queryKey: "labels",
-      argumentsObject,
-      argumentKey: "labelIds",
-    });
+    const labels: ReturnType<typeof DashboardLabelVariable.getFilter> =
+      DashboardLabelVariable.getFilter({
+        labelIds: PublicDashboardResourceListPolicy.optionalStringArray(
+          argumentsObject,
+          "labelIds",
+        ),
+        labelVariableId: PublicDashboardResourceListPolicy.optionalString(
+          argumentsObject,
+          "labelVariableId",
+          false,
+        ),
+        variables,
+      });
+    if (labels) {
+      query["labels"] = labels;
+    }
 
     return PublicDashboardResourceListPolicy.listDraft({
       resourceType: "monitor",
@@ -1653,19 +1668,19 @@ export default class PublicDashboardResourceListPolicy {
           storedValue,
           "Stored dashboard variable",
         );
-      if (stored["type"] !== DashboardVariableType.TelemetryAttribute) {
+      const type: unknown = stored["type"];
+      if (
+        type !== DashboardVariableType.TelemetryAttribute &&
+        type !== DashboardVariableType.ProjectLabel
+      ) {
         continue;
       }
 
       const id: unknown = stored["id"];
-      const attributeKey: unknown = stored["attributeKey"];
       if (
         typeof id !== "string" ||
         id.length === 0 ||
-        id.length > MAX_VARIABLE_ID_LENGTH ||
-        typeof attributeKey !== "string" ||
-        attributeKey.trim().length === 0 ||
-        attributeKey.length > MAX_VARIABLE_VALUE_LENGTH
+        id.length > MAX_VARIABLE_ID_LENGTH
       ) {
         throw new BadDataException("Stored dashboard variable is malformed.");
       }
@@ -1700,11 +1715,10 @@ export default class PublicDashboardResourceListPolicy {
       const name: unknown = stored["name"];
       const storedIsMultiSelect: boolean = isMultiSelect === true;
 
-      variables.push({
+      const variable: DashboardVariable = {
         id,
         name: typeof name === "string" ? name : "",
-        type: DashboardVariableType.TelemetryAttribute,
-        attributeKey: attributeKey.trim(),
+        type,
         isMultiSelect: storedIsMultiSelect,
         defaultValue:
           typeof defaultValue === "string" ? defaultValue : undefined,
@@ -1716,12 +1730,63 @@ export default class PublicDashboardResourceListPolicy {
           storedIsMultiSelect && Array.isArray(selectedValues)
             ? (selectedValues as Array<string>)
             : undefined,
-      });
+      };
+
+      if (type === DashboardVariableType.ProjectLabel) {
+        variable.labelOptions =
+          PublicDashboardResourceListPolicy.readLabelOptions(stored);
+      } else {
+        const attributeKey: unknown = stored["attributeKey"];
+        if (
+          typeof attributeKey !== "string" ||
+          attributeKey.trim().length === 0 ||
+          attributeKey.length > MAX_VARIABLE_VALUE_LENGTH
+        ) {
+          throw new BadDataException("Stored dashboard variable is malformed.");
+        }
+        variable.attributeKey = attributeKey.trim();
+      }
+
+      variables.push(variable);
     }
 
     return variables;
   }
 
+  private static readLabelOptions(
+    stored: Record<string, unknown>,
+  ): NonNullable<DashboardVariable["labelOptions"]> {
+    const value: unknown = stored["labelOptions"];
+    if (!Array.isArray(value)) {
+      throw new BadDataException(
+        "Stored dashboard label options are malformed.",
+      );
+    }
+
+    return value.map((entry: unknown): { label: string; value: string } => {
+      const option: Record<string, unknown> =
+        PublicDashboardResourceListPolicy.requireObject(
+          entry,
+          "Stored dashboard label option",
+        );
+      const label: unknown = option["label"];
+      const labelId: unknown = option["value"];
+      if (
+        typeof label !== "string" ||
+        label.length === 0 ||
+        label.length > MAX_VARIABLE_VALUE_LENGTH ||
+        typeof labelId !== "string" ||
+        labelId.length === 0 ||
+        labelId.length > MAX_VARIABLE_VALUE_LENGTH
+      ) {
+        throw new BadDataException(
+          "Stored dashboard label options are malformed.",
+        );
+      }
+      return { label, value: labelId };
+    });
+  }
+
   private static validateRequestedVariableSelections(
     requestedVariables: unknown,
   ): Map<string, Record<string, unknown>> {

package/Server/Utils/EmailRollup/EmailRollupFlushRunner.ts

@@ -751,9 +751,18 @@ export default class EmailRollupFlushRunner {
     const projectHomeLink: string = URL.fromString(dashboardUrl.toString())
       .addRoute(`/${bucket.projectId.toString()}/home`)
       .toString();
+    /*
+     * Email Preferences, not Notification Settings: this footer exists to
+     * offer the reader a way out of BATCHING, and the rollup switch lives on
+     * Email Preferences. Notification Settings is one link further on, from
+     * the page this lands on. The segment is duplicated from the Dashboard's
+     * UserSettingsRoutePath for the reason OnCallSetupReminderService gives -
+     * Common/Server cannot import App sources - so a route rename there has
+     * to be repeated here.
+     */
     const preferencesLink: string = URL.fromString(dashboardUrl.toString())
       .addRoute(
-        `/${bucket.projectId.toString()}/user-settings/notification-settings`,
+        `/${bucket.projectId.toString()}/user-settings/email-preferences`,
       )
       .toString();
 

package/Server/Utils/EmailRollup/EmailRollupRenderer.ts

@@ -629,8 +629,8 @@ export const buildRollupEmail: BuildRollupEmailFunction = (
    */
   const preferencesText: string =
     "OneUptime groups owner notifications into a single email when several arrive at once for the same project. " +
-    "To go back to one email per notification, sent the moment it happens, turn off email rollup for this project in your notification settings. " +
-    "The same page is where you choose which notifications you receive, or turn email off entirely:";
+    "To go back to one email per notification, sent the moment it happens, turn off email rollup for this project in your email preferences. " +
+    "The same page can also switch off routine emails in bulk, and it links on to the per-event settings:";
 
   /*
    * ONE FLAT ARRAY, WITH THE SECTION HEADING CARRIED ON ITS FIRST ROW.

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -7,6 +7,7 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import Typeof from "../../../../Types/Typeof";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
+import MetricValueFormatter from "../../../../Utils/Monitor/MetricValueFormatter";
 
 export default class CompareCriteria {
   /*
@@ -474,6 +475,15 @@ export default class CompareCriteria {
     criteriaFilter: CriteriaFilter;
     metricDisplayName?: string | undefined;
     unit?: string | undefined;
+    /**
+     * The metric NAME, when there is a real one. Distinct from
+     * metricDisplayName, which is the formula expression for a formula
+     * criteria and is only ever used as a label: this one feeds
+     * ValueFormatter.isFractionMetric, which would read the trailing
+     * `_ratio` of a formula like `a / b_ratio` as a signal to multiply
+     * the value by 100. Callers pass it only for plain metric criteria.
+     */
+    metricName?: string | undefined;
   }): string | null {
     if (data.value === null || data.value === undefined) {
       return null;
@@ -499,6 +509,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -521,6 +532,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -543,6 +555,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -565,6 +578,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -587,6 +601,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -609,6 +624,7 @@ export default class CompareCriteria {
           criteriaFilter: data.criteriaFilter,
           metricDisplayName: data.metricDisplayName,
           unit: data.unit,
+          metricName: data.metricName,
         });
       }
 
@@ -625,6 +641,15 @@ export default class CompareCriteria {
     criteriaFilter: CriteriaFilter;
     metricDisplayName?: string | undefined;
     unit?: string | undefined;
+    /**
+     * The metric NAME, when there is a real one. Distinct from
+     * metricDisplayName, which is the formula expression for a formula
+     * criteria and is only ever used as a label: this one feeds
+     * ValueFormatter.isFractionMetric, which would read the trailing
+     * `_ratio` of a formula like `a / b_ratio` as a signal to multiply
+     * the value by 100. Callers pass it only for plain metric criteria.
+     */
+    metricName?: string | undefined;
   }): string {
     // CPU Percent over the last 5 minutes is 10 which is less than the threshold of 20
     let message: string = "";
@@ -695,30 +720,36 @@ export default class CompareCriteria {
     }
 
     /*
-     * Suppress the units that read as noise — or as a wrong number —
-     * next to a value. OTel's dimensionless "1" marks ratio metrics
-     * whose samples are fractions in [0, 1]; rendering "0.06 1" is both
-     * ugly and misleading (it is not 1% — it is 6%), and a CLS breach
-     * read "is 0.31 1 which is greater than or equal to 0.25 1". UCUM
-     * annotation-only units ("{cpu}", "{packets}", "{errors}") are
-     * descriptive braces, not a unit a reader should be shown. Every
-     * real unit passes through unchanged, so "%" stays "%" and "ms"
-     * stays "ms".
+     * A metric value is written the way the dashboard writes it —
+     * "1.07 GB", "1.5 sec", "25.34%" — rather than as raw digits with a
+     * raw UCUM code glued on. Only two of the ~35 callers pass a unit at
+     * all (MetricMonitorCriteria and DatabaseMonitorCriteria); everything
+     * else carries its unit inside the CheckOn label ("Response Time (in
+     * ms)") and must keep its exact digits, so an absent unit leaves this
+     * sentence byte-for-byte as it was.
      *
-     * The dashboard side already applies the "1" half of this rule in
-     * MonitorCriteriaObservationBuilder.normalizeDisplayUnit, and
-     * ValueFormatter applies both halves when it formats a value. The
-     * email path never picked either up, so the same evaluation rendered
-     * worse in the alert than on the dashboard.
+     * MetricValueFormatter also subsumes the unit-suppression rules this
+     * block used to spell out by hand: OTel's dimensionless "1" (which
+     * made a CLS breach read "is 0.31 1 which is greater than or equal to
+     * 0.25 1") and UCUM's annotation-only "{cpu}" / "{packets}" both
+     * disappear, and a fraction metric still carrying "1" is rendered as
+     * the percentage it means.
+     *
+     * The unit rides each NUMBER instead of the sentence, because
+     * auto-scaling can land two samples in the same sentence on different
+     * scales — "is 900 KB, 1.2 MB" — which one trailing suffix cannot
+     * express.
      */
-    const trimmedUnit: string = (data.unit || "").trim();
-    const annotationOnlyUnitPattern: RegExp = /^\{[^{}]*\}$/;
-    const unitSuffix: string =
-      trimmedUnit &&
-      trimmedUnit !== "1" &&
-      !annotationOnlyUnitPattern.test(trimmedUnit)
-        ? ` ${trimmedUnit}`
-        : "";
+    const withUnit: ((value: number) => string) | undefined =
+      MetricValueFormatter.hasDisplayableUnit(data.unit, data.metricName)
+        ? (value: number): string => {
+            return MetricValueFormatter.format({
+              value: value,
+              unit: data.unit,
+              metricName: data.metricName,
+            });
+          }
+        : undefined;
 
     if (
       data.criteriaFilter.filterType !== FilterType.True &&
@@ -750,10 +781,12 @@ export default class CompareCriteria {
         evaluationType: evaluationType,
       });
 
-      const formattedValues: string =
-        CompareCriteria.formatCriteriaValues(reportedValues);
+      const formattedValues: string = CompareCriteria.formatCriteriaValues(
+        reportedValues,
+        withUnit,
+      );
 
-      message += ` is ${formattedValues}${unitSuffix}`;
+      message += ` is ${formattedValues}`;
 
       message += " which is";
 
@@ -778,22 +811,22 @@ export default class CompareCriteria {
 
     switch (data.criteriaFilter.filterType) {
       case FilterType.GreaterThan:
-        message += ` greater than ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` greater than ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.GreaterThanOrEqualTo:
-        message += ` greater than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` greater than or equal to ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.LessThan:
-        message += ` less than ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` less than ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.LessThanOrEqualTo:
-        message += ` less than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` less than or equal to ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.NotEqualTo:
-        message += ` not equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` not equal to ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.EqualTo:
-        message += ` equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
+        message += ` equal to ${CompareCriteria.formatSingleValue(data.threshold, withUnit)}. `;
         break;
       case FilterType.Contains:
         message += ` contains ${CompareCriteria.formatSingleValue(data.threshold)}. `;
@@ -918,8 +951,16 @@ export default class CompareCriteria {
     }
   }
 
+  /*
+   * `withUnit`, when supplied, is how a NUMBER is rendered — unit
+   * included. It is threaded down rather than applied to the finished
+   * string because the string is not always one number: a large window
+   * collapses to "N samples between X and Y", and both X and Y need the
+   * unit of their own scale.
+   */
   private static formatCriteriaValues(
     values: Array<number | boolean> | number | boolean | string,
+    withUnit?: ((value: number) => string) | undefined,
   ): string {
     if (Array.isArray(values)) {
       /*
@@ -934,7 +975,7 @@ export default class CompareCriteria {
       if (values.length <= MAX_INLINE) {
         return values
           .map((value: number | boolean) => {
-            return CompareCriteria.formatSingleValue(value);
+            return CompareCriteria.formatSingleValue(value, withUnit);
           })
           .join(", ");
       }
@@ -950,24 +991,26 @@ export default class CompareCriteria {
         const max: number = Math.max(...numericValues);
         return `${numericValues.length} samples between ${CompareCriteria.formatSingleValue(
           min,
-        )} and ${CompareCriteria.formatSingleValue(max)}`;
+          withUnit,
+        )} and ${CompareCriteria.formatSingleValue(max, withUnit)}`;
       }
 
       // Fall back to a truncated list when not all values are numeric
       const head: string = values
         .slice(0, MAX_INLINE)
         .map((value: number | boolean) => {
-          return CompareCriteria.formatSingleValue(value);
+          return CompareCriteria.formatSingleValue(value, withUnit);
         })
         .join(", ");
       return `${head}, … (${values.length} values total)`;
     }
 
-    return CompareCriteria.formatSingleValue(values);
+    return CompareCriteria.formatSingleValue(values, withUnit);
   }
 
   private static formatSingleValue(
     value: number | boolean | string | null | undefined,
+    withUnit?: ((value: number) => string) | undefined,
   ): string {
     if (value === null || value === undefined) {
       return "unknown";
@@ -976,6 +1019,10 @@ export default class CompareCriteria {
     if (typeof value === Typeof.Number) {
       const numericValue: number = value as number;
 
+      if (withUnit) {
+        return withUnit(numericValue);
+      }
+
       if (Number.isInteger(numericValue)) {
         return numericValue.toString();
       }

package/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.ts

@@ -26,6 +26,7 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
 import MetricUnitUtil from "../../../../Utils/MetricUnitUtil";
+import MetricValueFormatter from "../../../../Utils/Monitor/MetricValueFormatter";
 import MetricFormulaEvaluator from "../../../../Utils/Metrics/MetricFormulaEvaluator";
 import MetricBaselineService, {
   BaselineSummary,
@@ -369,6 +370,15 @@ export default class MetricMonitorCriteria {
         criteriaFilter: input.criteriaFilter,
         metricDisplayName: metricContext.metricName,
         unit: displayUnit,
+        /*
+         * Only a plain metric criteria has a real metric NAME —
+         * metricContext.metricName is the formula expression when the
+         * criteria targets a formula, and a formula ending in `_ratio`
+         * would trip the fraction heuristic into a 100× render.
+         */
+        metricName: metricContext.isFormula
+          ? undefined
+          : metricContext.metricName,
       });
 
     if (!comparisonMessage) {
@@ -989,13 +999,29 @@ export default class MetricMonitorCriteria {
             : "below";
 
     const sigmaAbs: number = Math.abs(firstBreach.sigma);
-    const unitSuffix: string = metricContext.unit
-      ? ` ${metricContext.unit}`
-      : "";
+
+    /*
+     * Same rendering as the breaching-samples table and the comparison
+     * sentence — an anomaly on a memory metric reads "1.07 GB", not
+     * "1073741824.000 By". σ is a count of standard deviations, not a
+     * quantity in the metric's unit, so it stays a bare number; the
+     * standard deviation itself is in the metric's unit and does not.
+     */
+    const inMetricUnit: (value: number) => string = (value: number): string => {
+      return MetricValueFormatter.format({
+        value: value,
+        unit: metricContext.unit,
+        // Formula expressions are not metric names — see the guard above.
+        metricName: metricContext.isFormula
+          ? undefined
+          : metricContext.metricName,
+      });
+    };
+
     const rootCause: string =
-      `${metricContext.metricName} value ${firstBreach.sample.value.toFixed(3)}${unitSuffix} ` +
+      `${metricContext.metricName} value ${inMetricUnit(firstBreach.sample.value)} ` +
       `is ${sigmaAbs.toFixed(2)}σ ${direction} the same-hour baseline ` +
-      `(mean ${baseline.mean.toFixed(3)}${unitSuffix}, σ ${baseline.stddev.toFixed(3)}${unitSuffix}, ` +
+      `(mean ${inMetricUnit(baseline.mean)}, σ ${inMetricUnit(baseline.stddev)}, ` +
       `${baseline.sampleCount} samples over ${baseline.windowDays} days, sensitivity ${sensitivity}).`;
 
     return {