@oneuptime/common 14.0.5 → 14.0.7

package/Tests/Utils/Incident/IncidentFromAlerts.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "@jest/globals";
 import IncidentFromAlerts, {
+  AlertForAcknowledgement,
   AlertForIncidentPrefill,
+  AlertsToAcknowledge,
+  AlertStateForAcknowledgement,
   INCIDENT_PREFILL_RESOURCE_KEYS,
   IncidentPrefillFromAlerts,
   NamedResource,
@@ -694,3 +697,302 @@ describe("IncidentFromAlerts", () => {
     });
   });
 });
+
+/*
+ * Which alerts the create page offers to acknowledge as the incident is
+ * declared. States are compared by order, as the server does: anything at or
+ * after the project's Acknowledged state (Resolved, or a custom state in
+ * between) has been acknowledged already. An alert whose state cannot be
+ * placed is offered - the server skips it if it turns out to be acknowledged.
+ */
+describe("IncidentFromAlerts.getAlertsToAcknowledge", () => {
+  const CREATED: AlertStateForAcknowledgement = {
+    id: "state-created",
+    order: 1,
+    isAcknowledgedState: false,
+  };
+  const ACKNOWLEDGED: AlertStateForAcknowledgement = {
+    id: "state-acknowledged",
+    order: 2,
+    isAcknowledgedState: true,
+  };
+  const RESOLVED: AlertStateForAcknowledgement = {
+    id: "state-resolved",
+    order: 3,
+    isAcknowledgedState: false,
+  };
+
+  const DEFAULT_ALERT_STATES: Array<AlertStateForAcknowledgement> = [
+    CREATED,
+    ACKNOWLEDGED,
+    RESOLVED,
+  ];
+
+  type AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ) => AlertForAcknowledgement;
+
+  const alertIn: AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ): AlertForAcknowledgement => {
+    return { id: id, currentAlertStateId: currentAlertStateId };
+  };
+
+  type GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ) => AlertsToAcknowledge | null;
+
+  const get: GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ): AlertsToAcknowledge | null => {
+    return IncidentFromAlerts.getAlertsToAcknowledge({
+      alerts: alerts,
+      alertStates: alertStates || DEFAULT_ALERT_STATES,
+    });
+  };
+
+  describe("when nothing could be acknowledged", () => {
+    test("is null when the project has no alert states at all", () => {
+      expect(get([alertIn("a1", CREATED.id)], [])).toBeNull();
+    });
+
+    test("is null when no state is the Acknowledged state", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, isAcknowledgedState: false }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged flag is missing rather than false", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [
+            CREATED,
+            { id: ACKNOWLEDGED.id, order: ACKNOWLEDGED.order },
+            RESOLVED,
+          ],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged state has no order to compare by", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, order: undefined }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null without an Acknowledged state even when there are no alerts", () => {
+      expect(get([], [CREATED, RESOLVED])).toBeNull();
+    });
+  });
+
+  describe("comparing by order", () => {
+    test("offers an alert whose state comes before Acknowledged", () => {
+      expect(get([alertIn("a1", CREATED.id)])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("leaves out an alert that is in the Acknowledged state itself", () => {
+      expect(get([alertIn("a1", ACKNOWLEDGED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("leaves out an alert that is resolved", () => {
+      expect(get([alertIn("a1", RESOLVED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("treats a custom state between Acknowledged and Resolved as acknowledged already", () => {
+      const investigating: AlertStateForAcknowledgement = {
+        id: "state-investigating",
+        order: 3,
+      };
+      const resolved: AlertStateForAcknowledgement = {
+        id: "state-resolved",
+        order: 4,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", investigating.id), alertIn("a2", resolved.id)],
+          [CREATED, ACKNOWLEDGED, investigating, resolved],
+        ),
+      ).toEqual({ alertIds: [], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("offers an alert in a custom state before Acknowledged", () => {
+      const triaged: AlertStateForAcknowledgement = {
+        id: "state-triaged",
+        order: 2,
+      };
+      const acknowledged: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 3,
+        isAcknowledgedState: true,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", triaged.id), alertIn("a2", CREATED.id)],
+          [CREATED, triaged, acknowledged, { ...RESOLVED, order: 4 }],
+        ),
+      ).toEqual({ alertIds: ["a1", "a2"], alreadyAcknowledgedCount: 0 });
+    });
+
+    test("compares by order, not by where the state sits in the list", () => {
+      // Listed newest-first: the list position must not decide anything.
+      const reversed: Array<AlertStateForAcknowledgement> = [
+        RESOLVED,
+        ACKNOWLEDGED,
+        CREATED,
+      ];
+
+      expect(
+        get(
+          [
+            alertIn("a1", RESOLVED.id),
+            alertIn("a2", CREATED.id),
+            alertIn("a3", ACKNOWLEDGED.id),
+          ],
+          reversed,
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("an Acknowledged order of 0 is still an order", () => {
+      const acknowledgedAtZero: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 0,
+        isAcknowledgedState: true,
+      };
+      const before: AlertStateForAcknowledgement = {
+        id: "state-before",
+        order: -1,
+      };
+
+      expect(
+        get(
+          [
+            alertIn("a1", acknowledgedAtZero.id),
+            alertIn("a2", before.id),
+            alertIn("a3", RESOLVED.id),
+          ],
+          [before, acknowledgedAtZero, RESOLVED],
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+  });
+
+  describe("alerts whose state cannot be placed", () => {
+    test("offers an alert whose current state is not one of the project's states", () => {
+      expect(get([alertIn("a1", "state-from-another-project")])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert with no current state id", () => {
+      expect(get([alertIn("a1", undefined), alertIn("a2", "")])).toEqual({
+        alertIds: ["a1", "a2"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert whose current state has no order", () => {
+      const unordered: AlertStateForAcknowledgement = {
+        id: "state-unordered",
+      };
+
+      expect(
+        get(
+          [alertIn("a1", unordered.id)],
+          [CREATED, ACKNOWLEDGED, RESOLVED, unordered],
+        ),
+      ).toEqual({ alertIds: ["a1"], alreadyAcknowledgedCount: 0 });
+    });
+  });
+
+  test("matches state ids case-insensitively and ignoring surrounding spaces", () => {
+    const upperAcknowledged: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000002",
+      order: 2,
+      isAcknowledgedState: true,
+    };
+    const upperCreated: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000001",
+      order: 1,
+    };
+
+    expect(
+      get(
+        [
+          alertIn("a1", " aaaaaaaa-aaaa-4aaa-8aaa-000000000002 "),
+          alertIn("a2", "aaaaaaaa-aaaa-4aaa-8aaa-000000000001"),
+        ],
+        [upperCreated, upperAcknowledged],
+      ),
+    ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 1 });
+  });
+
+  test("keeps the alerts in the order they were given and counts the rest", () => {
+    const result: AlertsToAcknowledge | null = get([
+      alertIn("a5", CREATED.id),
+      alertIn("a1", ACKNOWLEDGED.id),
+      alertIn("a4", undefined),
+      alertIn("a2", RESOLVED.id),
+      alertIn("a3", CREATED.id),
+      alertIn("a6", RESOLVED.id),
+    ]);
+
+    expect(result).toEqual({
+      alertIds: ["a5", "a4", "a3"],
+      alreadyAcknowledgedCount: 3,
+    });
+  });
+
+  test("returns the alert ids exactly as given", () => {
+    expect(get([alertIn("ALERT-One", CREATED.id)])!.alertIds).toEqual([
+      "ALERT-One",
+    ]);
+  });
+
+  test("is empty, not null, when there are no alerts", () => {
+    expect(get([])).toEqual({ alertIds: [], alreadyAcknowledgedCount: 0 });
+  });
+
+  test("does not change its input", () => {
+    const alerts: Array<AlertForAcknowledgement> = [
+      alertIn("a1", CREATED.id),
+      alertIn("a2", ACKNOWLEDGED.id),
+    ];
+    const alertStates: Array<AlertStateForAcknowledgement> = [
+      RESOLVED,
+      CREATED,
+      ACKNOWLEDGED,
+    ];
+
+    get(alerts, alertStates);
+
+    expect(alerts).toEqual([
+      { id: "a1", currentAlertStateId: CREATED.id },
+      { id: "a2", currentAlertStateId: ACKNOWLEDGED.id },
+    ]);
+    expect(alertStates).toEqual([RESOLVED, CREATED, ACKNOWLEDGED]);
+  });
+});

package/Tests/Utils/Rules/MonitorTypeRuleCriteria.test.ts

@@ -0,0 +1,181 @@
+import {
+  getMonitorTypeCriteriaValidationError,
+  isMonitorTypeCriteriaValue,
+} from "../../../Utils/Rules/MonitorTypeRuleCriteria";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+  RuleCriteriaValue,
+} from "../../../Types/Rules/RuleCriteria";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The gate that decides whether a rule's `monitorType` criterion may be saved.
+ * DatabaseService runs it on every write and the SLO monitor-rule engine runs
+ * it again when it matches monitors, so a criterion this lets through has to
+ * be one the engine can actually evaluate: a monitor type is an enum choice,
+ * which means an exact match either way and nothing else. A text operator
+ * slipping past here is a rule that silently matches nothing.
+ */
+
+function buildFilter(
+  operator: RuleCriteriaOperator,
+  value: RuleCriteriaValue,
+): RuleCriteriaFilter {
+  return { field: "monitorType", operator: operator, value: value };
+}
+
+const OPERATOR_ERROR: string =
+  "Monitor type criteria only support Equals and Does not equal operators.";
+const VALUE_ERROR: string =
+  "Monitor type criteria require a valid monitor type.";
+
+describe("isMonitorTypeCriteriaValue", () => {
+  test("accepts every monitor type the product defines", () => {
+    const allTypes: Array<string> = Object.values(MonitorType);
+    expect(allTypes.length).toBeGreaterThan(0);
+    for (const monitorType of allTypes) {
+      expect(isMonitorTypeCriteriaValue(monitorType)).toBe(true);
+    }
+  });
+
+  test("rejects a string that is not a monitor type", () => {
+    expect(isMonitorTypeCriteriaValue("Website")).toBe(
+      Object.values(MonitorType).includes("Website" as MonitorType),
+    );
+    expect(isMonitorTypeCriteriaValue("NotAMonitorType")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("")).toBe(false);
+  });
+
+  test("is case- and whitespace-sensitive, as an enum comparison must be", () => {
+    const [first] = Object.values(MonitorType) as Array<string>;
+    expect(isMonitorTypeCriteriaValue(first!)).toBe(true);
+    expect(isMonitorTypeCriteriaValue(first!.toLowerCase())).toBe(
+      first === first!.toLowerCase(),
+    );
+    expect(isMonitorTypeCriteriaValue(` ${first!}`)).toBe(false);
+    expect(isMonitorTypeCriteriaValue(`${first!} `)).toBe(false);
+  });
+
+  test("rejects every non-string value a criterion can carry", () => {
+    const nonStrings: Array<unknown> = [
+      undefined,
+      null,
+      0,
+      1,
+      true,
+      false,
+      [],
+      [Object.values(MonitorType)[0]],
+      {},
+      { value: Object.values(MonitorType)[0] },
+    ];
+    for (const value of nonStrings) {
+      expect(isMonitorTypeCriteriaValue(value)).toBe(false);
+    }
+  });
+
+  test("does not accept an inherited Object property as a monitor type", () => {
+    // The lookup is a Set, not a plain object, so "toString" is not a member.
+    expect(isMonitorTypeCriteriaValue("toString")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("constructor")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("__proto__")).toBe(false);
+  });
+});
+
+describe("getMonitorTypeCriteriaValidationError", () => {
+  const validType: MonitorType = Object.values(MonitorType)[0] as MonitorType;
+
+  test("passes Equals and NotEquals against a real monitor type", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBeNull();
+    }
+  });
+
+  test("passes every monitor type under Equals", () => {
+    for (const monitorType of Object.values(MonitorType)) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(RuleCriteriaOperator.Equals, monitorType),
+        ),
+      ).toBeNull();
+    }
+  });
+
+  test("rejects every operator other than Equals and NotEquals", () => {
+    const rejected: Array<RuleCriteriaOperator> = Object.values(
+      RuleCriteriaOperator,
+    ).filter((operator: RuleCriteriaOperator) => {
+      return (
+        operator !== RuleCriteriaOperator.Equals &&
+        operator !== RuleCriteriaOperator.NotEquals
+      );
+    });
+    expect(rejected.length).toBeGreaterThan(0);
+
+    for (const operator of rejected) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBe(OPERATOR_ERROR);
+    }
+  });
+
+  test("reports the operator first when both the operator and the value are wrong", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError(
+        buildFilter(RuleCriteriaOperator.Contains, "NotAMonitorType"),
+      ),
+    ).toBe(OPERATOR_ERROR);
+  });
+
+  test("rejects a value that is not a monitor type under a supported operator", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, "NotAMonitorType"),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, "")),
+      ).toBe(VALUE_ERROR);
+      /*
+       * An array is what the HasAnyOf-style operators carry; it is not a
+       * monitor type even when every member of it is one.
+       */
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, [validType]),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, true)),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, 0)),
+      ).toBe(VALUE_ERROR);
+    }
+  });
+
+  test("ignores the filter's field: the caller decides which field this applies to", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError({
+        field: "somethingElse",
+        operator: RuleCriteriaOperator.Equals,
+        value: validType,
+      }),
+    ).toBeNull();
+  });
+
+  test("the two errors are distinct, so a form can say which one it is", () => {
+    expect(OPERATOR_ERROR).not.toBe(VALUE_ERROR);
+  });
+});

package/Types/BaseDatabase/AggregationType.ts

@@ -15,6 +15,12 @@ enum AggregationType {
    * over the raw column, which is the right thing for scalar columns.
    */
   P50 = "P50",
+  /*
+   * The level Core Web Vitals are judged at: Google's good / poor
+   * thresholds for LCP, INP and CLS apply to the 75th percentile of page
+   * views, so a web-vital chart or monitor wants exactly this one.
+   */
+  P75 = "P75",
   P90 = "P90",
   P95 = "P95",
   P99 = "P99",
@@ -24,6 +30,7 @@ export default AggregationType;
 
 export const PercentileAggregationLevels: Record<string, number> = {
   [AggregationType.P50]: 0.5,
+  [AggregationType.P75]: 0.75,
   [AggregationType.P90]: 0.9,
   [AggregationType.P95]: 0.95,
   [AggregationType.P99]: 0.99,

package/Types/Dashboard/DashboardTemplates.ts

@@ -1742,6 +1742,18 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
    *   metrics and label them in cores ("2.3 cores"). The Kubernetes
    *   cluster overview page — which fetches `k8s.node.allocatable_cpu` —
    *   is where CPU is shown as a real "% of capacity".
+   *
+   * - "Cluster CPU (cores in use)" used to be a Value widget over
+   *   k8s.node.cpu.usage with `Sum` — the same trap as Pod Count. The
+   *   server sums every node's reading in each bucket and the Value widget
+   *   then sums the buckets, so a one-hour window of minute buckets and
+   *   30s kubelet scrapes read 540 for three nodes on 1.5 cores each,
+   *   instead of 4.5. A Value widget can't express "sum across nodes at one
+   *   instant", so the tile is now the busiest node's peak (`Max`), which
+   *   is honest at any window and complements the per-node average in
+   *   row 1. Cluster-wide CPU against capacity lives on the cluster
+   *   overview page. Dashboards already created from this template are
+   *   repaired by the RepairKubernetesDashboardClusterCpuTile migration.
    */
   const components: Array<DashboardBaseComponent> = [
     // Row 0: Title
@@ -1875,22 +1887,23 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     }),
 
     /*
-     * Row 11-13: cluster CPU cores tile and the network throughput
-     * chart. This was a 0-100 CPU gauge, but the cores-valued
+     * Row 11-13: busiest-node CPU tile and the network throughput chart.
+     * This was a 0-100 CPU gauge, but the cores-valued
      * `k8s.node.cpu.utilization` pinned it to nonsense (e.g. 711%) and
      * the templated renderer can't divide by allocatable CPU to make a
-     * real percentage — so we show total cores in use instead. The old
-     * "Memory Utilization" gauge over raw bytes is gone — see
-     * top-of-function comment.
+     * real percentage. It then became a `Sum` of cores, which multiplied
+     * by the scrape count — see top-of-function comment. `Max` is the
+     * highest reading any single node reported in the window. The old
+     * "Memory Utilization" gauge over raw bytes is gone too.
      */
     createValueComponent({
-      title: "Cluster CPU (cores in use)",
+      title: "Busiest Node CPU (cores, peak)",
       top: 11,
       left: 0,
       width: 4,
       metricConfig: {
         metricName: "k8s.node.cpu.usage",
-        aggregationType: MetricsAggregationType.Sum,
+        aggregationType: MetricsAggregationType.Max,
       },
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),

package/Types/Incident/IncidentAlertLink.ts

@@ -12,6 +12,25 @@
  */
 export const INCIDENT_ALERT_IDS_TO_LINK_KEY: string = "alertIdsToLink";
 
+/*
+ * Declaring an incident from alerts does not, on its own, change the alerts:
+ * they keep escalating until somebody acknowledges them. Sending
+ * `miscDataProps[INCIDENT_ACKNOWLEDGE_ALERTS_TO_LINK_KEY] = true` along with
+ * INCIDENT_ALERT_IDS_TO_LINK_KEY also acknowledges them, as the declaring
+ * user, once they are linked - which is what stops their on-call escalation.
+ * Alerts already acknowledged (or past it) are left as they are, and the
+ * caller must be allowed to change the state of every alert that is not.
+ * Off unless asked for.
+ *
+ * One exception: when the incident is declared straight into an
+ * acknowledged or resolved state and the project's linked-alert switches
+ * already move linked alerts along with it, those alerts are left to the
+ * switches (one writer per alert) - acknowledged or resolved as the switch
+ * does it, not credited to the declaring user.
+ */
+export const INCIDENT_ACKNOWLEDGE_ALERTS_TO_LINK_KEY: string =
+  "acknowledgeAlertsToLink";
+
 /*
  * The create-incident page reads the alerts to declare an incident from out of
  * this query string parameter, as a comma separated list of alert ids.

package/Types/Rum/SessionReplayCustomEvents.ts

@@ -215,15 +215,27 @@ export type SessionReplayWebVitalMetric =
 export type SessionReplayWebVitalRating = "good" | "needs-improvement" | "poor";
 
 /*
- * A web vital observed once per metric per page. Informational only:
- * vitals never trigger an upload, and CLS's value is unitless while the
- * others are milliseconds.
+ * How the view an INP describes began: the document load ("hard") or a
+ * single-page-app route change ("soft").
+ */
+export type SessionReplayNavigationType = "hard" | "soft";
+
+/* The input that produced an INP, as the browser classes it. */
+export type SessionReplayInteractionType = "pointer" | "keyboard";
+
+/*
+ * A web vital. LCP, FCP, CLS and TTFB are observed once per page load;
+ * INP once per VIEW (newer recorders), so a single-page app reports one
+ * INP for each route the user interacted on instead of one for the whole
+ * visit. Informational only: vitals never trigger an upload, and CLS's
+ * value is unitless while the others are milliseconds.
  */
 export interface SessionReplayWebVitalPayload {
   kind: "web-vital";
   metric: SessionReplayWebVitalMetric;
   value: number;
   rating: SessionReplayWebVitalRating;
+  /* INP: the scrubbed URL of the view the interaction happened on. */
   url?: string;
   /*
    * As on SessionReplayPerformanceBudgetPayload: when the measured entry
@@ -232,6 +244,20 @@ export interface SessionReplayWebVitalPayload {
    * after the moment the number describes. Optional for older recorders.
    */
   occurredAtUnixMs?: number;
+
+  /*
+   * INP attribution, all optional (older recorders and engines without
+   * the timing fields omit them). The three phases add up to roughly the
+   * value: waiting for the main thread, running the page's handlers, and
+   * rendering the next frame. The target is a structural selector built
+   * exactly as a click's is - never an attribute value or text.
+   */
+  navigationType?: SessionReplayNavigationType;
+  interactionType?: SessionReplayInteractionType;
+  interactionTarget?: string;
+  inputDelayMs?: number;
+  processingDurationMs?: number;
+  presentationDelayMs?: number;
 }
 
 export type SessionReplayPerformancePayload =

package/Types/Rum/WebVitals.ts

@@ -86,6 +86,19 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   },
 ];
 
+/*
+ * The metric attribute that names the route a web vital was measured on,
+ * tried in order for the RUM overview's per-route breakdown. `app.route`
+ * is what the Core Web Vitals docs tell instrumentation to set;
+ * `url.template` is OpenTelemetry's semantic-convention name for the same
+ * thing. Either must hold the route PATTERN ("/products/:id"), never the
+ * concrete URL - one series per product page is a cardinality problem.
+ */
+export const WebVitalRouteAttributeKeys: Array<string> = [
+  "app.route",
+  "url.template",
+];
+
 // A threshold the way a person would say it: "2.5 s", "800 ms", "0.1".
 export function formatWebVitalThreshold(
   value: number,

package/Types/Telemetry/InventoryLiveness.ts

@@ -54,3 +54,29 @@ export const getInventoryLivenessState: (
 
   return InventoryLiveness.Stale;
 };
+
+/**
+ * `getInventoryLivenessState` as a Postgres expression over the row aliased
+ * `tableAlias`, which must already be quoted (`"InventoryItem"`).
+ *
+ * The one SQL definition of the rule: the `inventoryStatus` virtual column
+ * selects and filters with it, and the Inventory Overview counts "Gone
+ * Quiet" with it, so the number on that tile and the rows the Stale facet
+ * returns cannot disagree about what stale means.
+ *
+ * Measured against the database clock. The function above floors elapsed
+ * minutes before applying inclusive thresholds — 30m59s is still Live and
+ * 24h00m59s is still Recent — and strict comparisons against the following
+ * minute preserve exactly those boundaries.
+ */
+export const getInventoryLivenessSql: (tableAlias: string) => string = (
+  tableAlias: string,
+): string => {
+  return `CASE
+        WHEN ${tableAlias}."source" IS DISTINCT FROM '${EntitySource.Discovered}' THEN '${InventoryLiveness.NotTracked}'
+        WHEN ${tableAlias}."lastSeenAt" IS NULL THEN '${InventoryLiveness.Never}'
+        WHEN ${tableAlias}."lastSeenAt" > CURRENT_TIMESTAMP - INTERVAL '${INVENTORY_LIVE_WINDOW_MINUTES + 1} minutes' THEN '${InventoryLiveness.Live}'
+        WHEN ${tableAlias}."lastSeenAt" > CURRENT_TIMESTAMP - INTERVAL '${INVENTORY_STALE_AFTER_MINUTES + 1} minutes' THEN '${InventoryLiveness.Recent}'
+        ELSE '${InventoryLiveness.Stale}'
+      END`;
+};