@oneuptime/common 13.0.8 → 14.0.1

package/Server/Utils/Monitor/MonitoringIntervalValidator.ts

@@ -0,0 +1,116 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import MonitoringIntervalUtil, {
+  MonitoringIntervalNormalization,
+  MonitoringIntervalNormalizationStatus,
+} from "../../../Utils/Monitor/MonitoringIntervalUtil";
+import CronTab from "../CronTab";
+
+/*
+ * Server-side policy for `Monitor.monitoringInterval`.
+ *
+ * MonitoringIntervalUtil says what a value MEANS and never throws.
+ * This says what we DO about it on a write: understood values are rewritten
+ * to canonical cron, and genuinely meaningless ones are refused with a
+ * message that names the cron to use instead.
+ *
+ * WHY THE RUNTIME PARSER GETS THE LAST WORD
+ *
+ * The isomorphic normalizer is a hand-rolled grammar; the scheduler runs on
+ * cron-parser. Where the two disagree, cron-parser wins, because it is what
+ * actually computes `nextPingAt`. Validation that rejected an expression the
+ * scheduler would happily honour ("@hourly", exotic step/range forms) would
+ * be this same bug in mirror image: the UI and the runtime disagreeing about
+ * a stored value, with the customer caught in between. So Unrecognized is
+ * re-checked against cron-parser before we refuse anything.
+ */
+
+/*
+ * The shortest cadence the probe fleet can honour.
+ *
+ * `claimMonitorProbesForProbing` is driven by a cron that ticks once a
+ * minute, so a sub-minute schedule is a promise we cannot keep. cron-parser
+ * accepts 6-field per-second expressions such as "* * * * * *" quite
+ * happily; without this floor an API client could ask for a per-second probe
+ * and silently get a per-minute one — the exact class of bug this file
+ * exists to close.
+ */
+export const MINIMUM_MONITORING_INTERVAL_IN_SECONDS: number = 60;
+
+export default class MonitoringIntervalValidator {
+  /**
+   * Validate and canonicalize an inbound monitoring interval.
+   *
+   * Returns the value to persist: null for "no schedule" (legitimate — a
+   * Manual monitor is never probed), otherwise a cron expression the
+   * scheduler can parse. Throws BadDataException when the value cannot be
+   * understood by either the normalizer or cron-parser.
+   */
+  public static validateAndNormalize(
+    value: string | null | undefined,
+  ): string | null {
+    const result: MonitoringIntervalNormalization =
+      MonitoringIntervalUtil.normalize(value);
+
+    if (result.status === MonitoringIntervalNormalizationStatus.Empty) {
+      return null;
+    }
+
+    if (result.cron) {
+      MonitoringIntervalValidator.assertMeetsFloor(result.cron, result.input);
+      return result.cron;
+    }
+
+    /*
+     * Unrecognized by the grammar. Before refusing, ask the parser that
+     * actually schedules the probe — if it can read the expression, the
+     * scheduler can honour it and there is nothing to refuse.
+     */
+    const trimmed: string = (result.input || "").trim();
+    const intervalInSeconds: number | null =
+      CronTab.getIntervalInSeconds(trimmed);
+
+    if (intervalInSeconds !== null) {
+      MonitoringIntervalValidator.assertMeetsFloor(trimmed, result.input);
+      return trimmed;
+    }
+
+    throw new BadDataException(
+      `Invalid Monitoring Interval "${trimmed}". Expected a cron expression - use "${MonitoringIntervalUtil.getSuggestedCronForMessage()}" for every 5 minutes.`,
+    );
+  }
+
+  /*
+   * Applied to every accepted value, normalized or passed through, because
+   * the floor is about what the probe fleet can deliver and not about which
+   * code path produced the expression.
+   */
+  private static assertMeetsFloor(
+    cron: string,
+    input: string | null | undefined,
+  ): void {
+    const intervalInSeconds: number | null = CronTab.getIntervalInSeconds(cron);
+
+    if (
+      intervalInSeconds !== null &&
+      intervalInSeconds < MINIMUM_MONITORING_INTERVAL_IN_SECONDS
+    ) {
+      throw new BadDataException(
+        `Monitoring Interval "${(input || cron).trim()}" is faster than once a minute, which probes cannot deliver. Use "* * * * *" for the fastest supported schedule.`,
+      );
+    }
+  }
+
+  /**
+   * The cron a stored value means, for READ paths.
+   *
+   * Read paths must stay total: a row written before this validator existed
+   * (or restored from a backup, or written through a hook-free path) is not
+   * an exception, it is just a row. Callers fall back to their own default
+   * when this returns null.
+   */
+  public static normalizeForRead(
+    value: string | null | undefined,
+  ): string | null {
+    return MonitoringIntervalUtil.toCronOrNull(value);
+  }
+}

package/Server/Utils/Monitor/RootCauseList.ts

@@ -0,0 +1,139 @@
+/*
+ * The numbered list a root cause uses for a per-item breakdown.
+ *
+ * Two blocks of an incident / alert root cause break a breach down item by
+ * item: a platform monitor's "Affected Resources" (see AffectedResourceList)
+ * and a metric monitor's "Breaching Samples". Both used to be
+ * GitHub-flavoured tables, and a table reads badly everywhere a root cause
+ * is shown — it wraps into fragments in the ~416px email card, reaches Slack
+ * as raw pipe rows (mrkdwn has no tables), and lets its widest column
+ * squeeze the rest on the dashboard. So each item is a numbered list item
+ * instead: a title and a value on its first line, and everything else
+ * about it as labelled bullets nested underneath.
+ *
+ *     1. **Pod** `checkout-7d9f` — **3**
+ *        - Namespace: `payments`
+ *
+ *     1. `2026-08-14T10:30:00.000Z` — **1.07 GB**
+ *        - `a`: 537 MB
+ *        - `k8s.pod.name`: `web-1`
+ *
+ * A detail with no value is simply left out, where a table had to print
+ * "-" in its cell.
+ *
+ * Plain markdown, deliberately: marked (email), react-markdown (dashboard),
+ * slackify-markdown (Slack), the dashboard editor's WYSIWYG converters and
+ * Markdown.convertToPlainText all understand a nested list, so nothing
+ * downstream needs to know these blocks exist.
+ */
+
+export interface RootCauseListDetail {
+  /*
+   * Markdown, rendered as-is — escape plain text, or wrap an identifier
+   * with RootCauseList.code(). An empty label leaves just the value.
+   */
+  label: string;
+  // Markdown, rendered as-is. An empty value drops the whole detail.
+  value: string;
+}
+
+export interface RootCauseListItem {
+  // Markdown, rendered as-is: what the item is.
+  title: string;
+  // Markdown, rendered as-is: how bad it is, normally a bold value.
+  value: string;
+  details: Array<RootCauseListDetail>;
+}
+
+export default class RootCauseList {
+  /*
+   * The items as one ordered list, numbered from 1 in the order given. The
+   * result is just the list: the caller puts its heading above it and any
+   * summary below it, each separated from the list by a blank line.
+   */
+  public static render(items: Array<RootCauseListItem>): string {
+    const lines: Array<string> = [];
+
+    items.forEach((item: RootCauseListItem, index: number): void => {
+      const marker: string = `${index + 1}.`;
+
+      /*
+       * A nested bullet belongs to its item only when it is indented to
+       * the item's content column, which is one past the marker — three
+       * spaces under "1.", four under "10.". A fixed three-space indent
+       * would push item 10's details out into a separate top-level list.
+       */
+      const indent: string = " ".repeat(marker.length + 1);
+
+      const head: string = [item.title.trim(), item.value.trim()]
+        .filter((part: string): boolean => {
+          return part.length > 0;
+        })
+        .join(" — ");
+
+      lines.push(`${marker} ${head}`);
+
+      for (const detail of item.details) {
+        const value: string = detail.value ? detail.value.trim() : "";
+
+        if (value.length === 0) {
+          continue;
+        }
+
+        const label: string = detail.label ? detail.label.trim() : "";
+
+        lines.push(`${indent}- ${label ? `${label}: ${value}` : value}`);
+      }
+    });
+
+    return lines.join("\n");
+  }
+
+  /*
+   * A value as an inline code span.
+   *
+   * What goes in here comes from telemetry — resource names, attribute keys
+   * and values — and can contain anything. Wrapping a value that contains a
+   * backtick in single backticks closes the span early and spills the rest
+   * of it — and whatever markdown it contains — into the list. So the fence
+   * is always one backtick longer than the longest run inside the value,
+   * and padded with a space on each side when the value has any backticks
+   * at all (CommonMark strips exactly one from each side, so the padding
+   * never shows). Line breaks become spaces: a newline inside a list item
+   * would end the item.
+   *
+   * A value without backticks is a plain single-backtick span, so an ISO
+   * timestamp still reaches the dashboard as the bare inline code the
+   * MarkdownViewer re-renders in the viewer's timezone.
+   */
+  public static code(value: string | undefined | null): string {
+    if (value === undefined || value === null) {
+      return "";
+    }
+
+    const text: string = String(value)
+      .replace(/\s*[\r\n]+\s*/g, " ")
+      .trim();
+
+    if (text.length === 0) {
+      return "";
+    }
+
+    const backtickRuns: Array<string> = text.match(/`+/g) || [];
+
+    const longestRun: number = backtickRuns.reduce(
+      (longest: number, run: string): number => {
+        return Math.max(longest, run.length);
+      },
+      0,
+    );
+
+    if (longestRun === 0) {
+      return `\`${text}\``;
+    }
+
+    const fence: string = "`".repeat(longestRun + 1);
+
+    return `${fence} ${text} ${fence}`;
+  }
+}

package/Server/Utils/Rules/RuleRun/RuleRunRegistry.ts

@@ -122,6 +122,11 @@ import ServerlessFunctionOwnerTeam from "../../../../Models/DatabaseModels/Serve
 import ServerlessFunctionOwnerUser from "../../../../Models/DatabaseModels/ServerlessFunctionOwnerUser";
 import Service from "../../../../Models/DatabaseModels/Service";
 import ServiceLabelRule from "../../../../Models/DatabaseModels/ServiceLabelRule";
+import ServiceLevelObjective from "../../../../Models/DatabaseModels/ServiceLevelObjective";
+import ServiceLevelObjectiveLabelRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveLabelRule";
+import ServiceLevelObjectiveOwnerRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerRule";
+import ServiceLevelObjectiveOwnerTeam from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerTeam";
+import ServiceLevelObjectiveOwnerUser from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerUser";
 import ServiceOwnerRule from "../../../../Models/DatabaseModels/ServiceOwnerRule";
 import ServiceOwnerTeam from "../../../../Models/DatabaseModels/ServiceOwnerTeam";
 import ServiceOwnerUser from "../../../../Models/DatabaseModels/ServiceOwnerUser";
@@ -265,6 +270,11 @@ import ServerlessFunctionLabelRuleService from "../../../Services/ServerlessFunc
 import ServerlessFunctionOwnerRuleEngineService from "../../../Services/ServerlessFunctionOwnerRuleEngineService";
 import ServerlessFunctionOwnerRuleService from "../../../Services/ServerlessFunctionOwnerRuleService";
 import ServerlessFunctionService from "../../../Services/ServerlessFunctionService";
+import ServiceLevelObjectiveLabelRuleEngineService from "../../../Services/ServiceLevelObjectiveLabelRuleEngineService";
+import ServiceLevelObjectiveLabelRuleService from "../../../Services/ServiceLevelObjectiveLabelRuleService";
+import ServiceLevelObjectiveOwnerRuleEngineService from "../../../Services/ServiceLevelObjectiveOwnerRuleEngineService";
+import ServiceLevelObjectiveOwnerRuleService from "../../../Services/ServiceLevelObjectiveOwnerRuleService";
+import ServiceLevelObjectiveService from "../../../Services/ServiceLevelObjectiveService";
 import ServiceLabelRuleEngineService from "../../../Services/ServiceLabelRuleEngineService";
 import ServiceLabelRuleService from "../../../Services/ServiceLabelRuleService";
 import ServiceOwnerRuleEngineService from "../../../Services/ServiceOwnerRuleEngineService";
@@ -727,6 +737,24 @@ const RULE_RUN_DEFINITIONS: Record<ResourceRuleRunType, RuleRunDefinition> = {
     resourceService: ServiceService,
     engine: ServiceLabelRuleEngineService,
   }),
+  [RuleRunType.ServiceLevelObjectiveLabelRule]: defineRuleRun({
+    ruleModelType: ServiceLevelObjectiveLabelRule,
+    resourceModelType: ServiceLevelObjective,
+    ruleService: ServiceLevelObjectiveLabelRuleService,
+    resourceService: ServiceLevelObjectiveService,
+    engine: ServiceLevelObjectiveLabelRuleEngineService,
+  }),
+  [RuleRunType.ServiceLevelObjectiveOwnerRule]: defineRuleRun({
+    ruleModelType: ServiceLevelObjectiveOwnerRule,
+    resourceModelType: ServiceLevelObjective,
+    ruleService: ServiceLevelObjectiveOwnerRuleService,
+    resourceService: ServiceLevelObjectiveService,
+    engine: ServiceLevelObjectiveOwnerRuleEngineService,
+    ownerModelTypes: [
+      ServiceLevelObjectiveOwnerUser,
+      ServiceLevelObjectiveOwnerTeam,
+    ],
+  }),
   [RuleRunType.ServiceOwnerRule]: defineRuleRun({
     ruleModelType: ServiceOwnerRule,
     resourceModelType: Service,

package/Server/Utils/Slo/SloRulePatternValidator.ts

@@ -0,0 +1,42 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import RulePatternMatchUtil from "../../../Utils/Rules/RulePatternMatchUtil";
+
+/*
+ * Write-time validation for the SLO name / description patterns on SLO label
+ * and owner rules.
+ *
+ * The rule engines accept a case-insensitive regex or a '*' wildcard glob, the
+ * same two syntaxes the SLO monitor rules take. Anything else - `api-(01`,
+ * `[unclosed` - compiles to nothing and matches nothing, and the engine can
+ * only log about it long after the user left the form. Reject it at the write
+ * instead, as NetworkDeviceRulePatternValidator does (OneUptime/oneuptime#2940).
+ */
+export default class SloRulePatternValidator {
+  public static validate(data: {
+    namePattern?: string | null | undefined;
+    descriptionPattern?: string | null | undefined;
+  }): void {
+    SloRulePatternValidator.validateOne("SLO Name Pattern", data.namePattern);
+    SloRulePatternValidator.validateOne(
+      "SLO Description Pattern",
+      data.descriptionPattern,
+    );
+  }
+
+  private static validateOne(
+    title: string,
+    pattern: string | null | undefined,
+  ): void {
+    if (!pattern) {
+      return;
+    }
+
+    if (RulePatternMatchUtil.isSupportedPattern(pattern)) {
+      return;
+    }
+
+    throw new BadDataException(
+      `${title} "${pattern}" is not a valid regular expression, and contains no '*' wildcard to fall back on, so it would never match an SLO. Use a regex such as checkout-.* or a wildcard such as *checkout*.`,
+    );
+  }
+}