@oneuptime/common 14.0.3 → 14.0.5

package/Tests/App/Dashboard/MetricsViewerEntityScopedRows.test.tsx

@@ -0,0 +1,495 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { act, cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * The metric list on a page pinned to entity keys alone (a Database's
+ * Metrics tab), against what the end-to-end run saw on pg16 (3df04aa4):
+ *
+ *   - the `db.client.operation.duration` row named "billing-api,
+ *     e2e-orders-app, reports-api, inventory-api +4 more" — every service
+ *     that ever reported the metric, project-wide — while ClickHouse had
+ *     only e2e-orders-app reporting it for pg16's endpoint. The row now
+ *     names the services the key-scoped query itself found;
+ *   - `postgresql.backends` read 4 (the average of its per-database series)
+ *     beside an Overview showing 8. A host that knows how a metric combines
+ *     supplies the row's value, and the list does not fetch its average.
+ *
+ * Every product without those props keeps its old rows.
+ */
+
+const rowProps: Array<Record<string, unknown>> = [];
+const metricTypeRows: Array<unknown> = [];
+const analyticsGetListMock: MockFunction = getJestMockFunction();
+const aggregateMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Components/TelemetryViewer/TelemetryViewer", () => {
+  return {
+    __esModule: true,
+    default: (props: {
+      items: Array<{ name: string }>;
+      renderRow: (metric: { name: string }) => React.ReactElement;
+    }) => {
+      return (
+        <div>
+          {props.items.map((item: { name: string }) => {
+            return (
+              <React.Fragment key={item.name}>
+                {props.renderRow(item)}
+              </React.Fragment>
+            );
+          })}
+        </div>
+      );
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: Record<string, unknown>) => {
+        rowProps.push(props);
+        return <div data-testid="row" />;
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: () => {
+        return Promise.resolve({
+          data: metricTypeRows,
+          count: metricTypeRows.length,
+        });
+      },
+      getCommonHeaders: () => {
+        return {};
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/AnalyticsModelAPI/AnalyticsModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<unknown>) => {
+        return analyticsGetListMock(...args);
+      },
+      aggregate: (...args: Array<unknown>) => {
+        return aggregateMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: () => {
+        return Promise.resolve({ data: { facets: {} } });
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        getTelemetryAttributes: () => {
+          return Promise.resolve([]);
+        },
+        fetchSparklineAggregates: () => {
+          return Promise.resolve(new Map());
+        },
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/Telemetry/UseTelemetryEntityNames", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {};
+    },
+  };
+});
+
+import MetricsViewer from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricsViewer";
+import { MetricRowProps } from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow";
+import {
+  MetricRowValueOverrideMap,
+  getMetricServiceIdsByName,
+  getMetricServicesWithin,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/MetricRowScope";
+import MetricType from "../../../Models/DatabaseModels/MetricType";
+import Service from "../../../Models/DatabaseModels/Service";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import ObjectID from "../../../Types/ObjectID";
+import ProjectUtil from "../../../UI/Utils/Project";
+import ValueFormatter from "../../../Utils/ValueFormatter";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "21075038-d9f1-4d3a-b878-f64ae861f7be",
+);
+const PG16_KEYS: Array<string> = ["35b0817780236296", "4368de1139c723fd"];
+const PG16_ID: string = "3df04aa4-a899-40bb-96f0-e487733aee03";
+const ORDERS_APP_ID: string = "fb098730-455f-43a3-8a70-29fcd09e0af5";
+
+const PROJECT_SERVICE_NAMES: Array<[string, string]> = [
+  ["11111111-1111-4111-8111-000000000001", "billing-api"],
+  [ORDERS_APP_ID, "e2e-orders-app"],
+  ["11111111-1111-4111-8111-000000000003", "reports-api"],
+  ["11111111-1111-4111-8111-000000000004", "inventory-api"],
+  ["11111111-1111-4111-8111-000000000005", "reports-worker"],
+  ["11111111-1111-4111-8111-000000000006", "valkey"],
+  ["11111111-1111-4111-8111-000000000007", "checkout"],
+  ["11111111-1111-4111-8111-000000000008", "payments"],
+];
+
+function service(id: string, name: string): Service {
+  const item: Service = new Service();
+  item.id = new ObjectID(id);
+  item.name = name;
+  return item;
+}
+
+function metricType(name: string, services: Array<Service>): MetricType {
+  const item: MetricType = new MetricType();
+  item.name = name;
+  item.services = services;
+  return item;
+}
+
+const RealMetricRow: React.FunctionComponent<MetricRowProps> = (
+  jest.requireActual(
+    "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow",
+  ) as { default: React.FunctionComponent<MetricRowProps> }
+).default;
+
+function lastRowFor(name: string): Record<string, unknown> {
+  const rows: Array<Record<string, unknown>> = rowProps.filter(
+    (props: Record<string, unknown>): boolean => {
+      return (props["metric"] as MetricType).name === name;
+    },
+  );
+  expect(rows.length).toBeGreaterThan(0);
+  return rows[rows.length - 1]!;
+}
+
+async function renderViewer(
+  props: React.ComponentProps<typeof MetricsViewer>,
+): Promise<void> {
+  await act(async () => {
+    render(<MetricsViewer {...props} disableUrlSync={true} />);
+  });
+  // Let the name lookup, the list and the sparklines settle.
+  await act(async () => {
+    await new Promise((resolve: (value: unknown) => void) => {
+      setTimeout(resolve, 0);
+    });
+  });
+}
+
+beforeEach(() => {
+  rowProps.length = 0;
+  metricTypeRows.length = 0;
+  analyticsGetListMock.mockReset();
+  aggregateMock.mockReset();
+  aggregateMock.mockResolvedValue({
+    data: [{ timestamp: new Date("2026-09-25T01:11:00.000Z"), value: 4 }],
+  });
+  jest.spyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(PROJECT_ID);
+
+  const everyService: Array<Service> = PROJECT_SERVICE_NAMES.map(
+    ([id, name]: [string, string]): Service => {
+      return service(id, name);
+    },
+  );
+  metricTypeRows.push(
+    metricType("db.client.operation.duration", everyService),
+    metricType("postgresql.backends", []),
+  );
+  // GROUP BY name, primaryEntityId under pg16's keys (ClickHouse, 6 h).
+  analyticsGetListMock.mockResolvedValue({
+    data: [
+      { name: "db.client.operation.duration", primaryEntityId: ORDERS_APP_ID },
+      { name: "postgresql.backends", primaryEntityId: PG16_ID },
+    ],
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("service chips on a list pinned to entity keys", () => {
+  test("a row names only the services that reported the metric under the keys", async () => {
+    await renderViewer({ entityKeysFilter: PG16_KEYS });
+
+    const request: Record<string, unknown> = analyticsGetListMock.mock
+      .calls[0]![0] as Record<string, unknown>;
+    expect(request["groupBy"]).toEqual({ name: true, primaryEntityId: true });
+
+    expect(
+      lastRowFor("db.client.operation.duration")["restrictServicesToIds"],
+    ).toEqual([ORDERS_APP_ID]);
+    // Engine metrics are the database's own: no service to name.
+    expect(lastRowFor("postgresql.backends")["restrictServicesToIds"]).toEqual([
+      PG16_ID,
+    ]);
+  });
+
+  test("a service-scoped list keeps its own chips and its name-only query", async () => {
+    await renderViewer({
+      entityKeysFilter: PG16_KEYS,
+      serviceIdsToDisplay: [new ObjectID(ORDERS_APP_ID)],
+    });
+
+    const request: Record<string, unknown> = analyticsGetListMock.mock
+      .calls[0]![0] as Record<string, unknown>;
+    expect(request["groupBy"]).toEqual({ name: true });
+    expect(
+      lastRowFor("db.client.operation.duration")["restrictServicesToIds"],
+    ).toBeUndefined();
+  });
+
+  test("the row renders only those services (was '+4 more' of the project's)", () => {
+    const services: Array<Service> = PROJECT_SERVICE_NAMES.map(
+      ([id, name]: [string, string]): Service => {
+        return service(id, name);
+      },
+    );
+    render(
+      <RealMetricRow
+        metric={metricType("db.client.operation.duration", services)}
+        restrictServicesToIds={[ORDERS_APP_ID]}
+      />,
+    );
+    expect(screen.getByText("e2e-orders-app")).toBeInTheDocument();
+    expect(screen.queryByText("billing-api")).not.toBeInTheDocument();
+    expect(screen.queryByText(/more/)).not.toBeInTheDocument();
+
+    expect(
+      getMetricServicesWithin({ services, allowedServiceIds: [] }),
+    ).toEqual([]);
+    expect(
+      getMetricServiceIdsByName([
+        { name: "a", primaryEntityId: ORDERS_APP_ID },
+        { name: "a", primaryEntityId: ORDERS_APP_ID },
+        { name: "b", primaryEntityId: null },
+      ]),
+    ).toEqual({ a: [ORDERS_APP_ID], b: [] });
+  });
+});
+
+describe("row values a host supplies", () => {
+  test("an overridden row shows the host's value and caption; its average is not fetched", async () => {
+    const fetchRowValueOverrides: MockFunction = getJestMockFunction();
+    fetchRowValueOverrides.mockImplementation(
+      (data: unknown): Promise<MetricRowValueOverrideMap> => {
+        const request: {
+          metricNames: Array<string>;
+          startAndEndDate: InBetween<Date>;
+        } = data as {
+          metricNames: Array<string>;
+          startAndEndDate: InBetween<Date>;
+        };
+        expect(request.startAndEndDate).toBeInstanceOf(InBetween);
+        const overrides: MetricRowValueOverrideMap = new Map();
+        if (request.metricNames.includes("postgresql.backends")) {
+          overrides.set("postgresql.backends", {
+            points: [{ time: "2026-09-25T01:11:00.000Z", value: 19 }],
+            caption: "total of series",
+          });
+        }
+        return Promise.resolve(overrides);
+      },
+    );
+
+    await renderViewer({
+      entityKeysFilter: PG16_KEYS,
+      fetchRowValueOverrides: fetchRowValueOverrides as unknown as (data: {
+        metricNames: Array<string>;
+        startAndEndDate: InBetween<Date>;
+      }) => Promise<MetricRowValueOverrideMap>,
+      defaultRowValueCaption: "average of series",
+    });
+
+    const backends: Record<string, unknown> = lastRowFor("postgresql.backends");
+    expect(backends["lastValue"]).toBe(19);
+    expect(backends["valueCaption"]).toBe("total of series");
+
+    const duration: Record<string, unknown> = lastRowFor(
+      "db.client.operation.duration",
+    );
+    expect(duration["lastValue"]).toBe(4);
+    expect(duration["valueCaption"]).toBe("average of series");
+
+    const averaged: Array<string> = aggregateMock.mock.calls.map(
+      (call: Array<unknown>): string => {
+        return (
+          (call[0] as { aggregateBy: { query: { name: string } } }).aggregateBy
+            .query.name || ""
+        );
+      },
+    );
+    expect(averaged).toContain("db.client.operation.duration");
+    expect(averaged).not.toContain("postgresql.backends");
+  });
+
+  test("a user's own attribute filter narrows the rows, so the host's whole-scope values step aside", async () => {
+    const fetchRowValueOverrides: MockFunction = getJestMockFunction();
+    fetchRowValueOverrides.mockResolvedValue(new Map());
+    window.history.pushState(
+      {},
+      "",
+      `/metrics?filters=${encodeURIComponent(
+        JSON.stringify([["attributes.db.namespace", "orders"]]),
+      )}`,
+    );
+
+    await act(async () => {
+      render(
+        <MetricsViewer
+          entityKeysFilter={PG16_KEYS}
+          fetchRowValueOverrides={
+            fetchRowValueOverrides as unknown as (data: {
+              metricNames: Array<string>;
+              startAndEndDate: InBetween<Date>;
+            }) => Promise<MetricRowValueOverrideMap>
+          }
+        />,
+      );
+    });
+    await act(async () => {
+      await new Promise((resolve: (value: unknown) => void) => {
+        setTimeout(resolve, 0);
+      });
+    });
+    window.history.pushState({}, "", "/");
+
+    expect(rowProps.length).toBeGreaterThan(0);
+    expect(fetchRowValueOverrides).not.toHaveBeenCalled();
+  });
+
+  test("without an override, rows read exactly as before (no caption, no suffix)", async () => {
+    await renderViewer({ entityKeysFilter: PG16_KEYS });
+
+    const backends: Record<string, unknown> = lastRowFor("postgresql.backends");
+    expect(backends["lastValue"]).toBe(4);
+    expect(backends["valueCaption"]).toBeUndefined();
+    expect(backends["valueSuffix"]).toBeUndefined();
+  });
+
+  test("the row shows a rate's suffix and the caption under the value", () => {
+    render(
+      <RealMetricRow
+        metric={metricType("postgresql.commits", [])}
+        lastValue={2.5}
+        valueSuffix="/s"
+        valueCaption="per second, all series"
+      />,
+    );
+    expect(screen.getByText(/2\.5.*\/s/)).toBeInTheDocument();
+    expect(screen.getByTestId("metric-row-value-caption")).toHaveTextContent(
+      "per second, all series",
+    );
+  });
+
+  /*
+   * e2e: MariaDB's mysql.buffer_pool.limit (8112, a page count) is declared
+   * in bytes, so its row read "7.9 KiB". The host's unit wins over the
+   * metric's own, for the value and the badge.
+   */
+  test("a host's unit replaces the metric's declared one", () => {
+    const limit: MetricType = metricType("mysql.buffer_pool.limit", []);
+    limit.unit = "By";
+
+    render(
+      <RealMetricRow
+        metric={limit}
+        lastValue={8112}
+        valueUnit="{pages}"
+        valueCaption="average of series"
+      />,
+    );
+    expect(screen.getByText("Pages")).toBeInTheDocument();
+    expect(screen.queryByText(/KiB|KB|Bytes/)).not.toBeInTheDocument();
+    expect(
+      screen.getByText(ValueFormatter.formatValue(8112, "{pages}")),
+    ).toBeInTheDocument();
+  });
+
+  test("the viewer asks the host for each row's unit, whoever computed its value", async () => {
+    const limit: MetricType = metricType("mysql.buffer_pool.limit", []);
+    limit.unit = "By";
+    metricTypeRows.push(limit);
+    const getRowValueUnit: (metricName: string) => string | undefined = (
+      metricName: string,
+    ): string | undefined => {
+      return metricName === "mysql.buffer_pool.limit" ? "{pages}" : undefined;
+    };
+
+    await renderViewer({
+      entityKeysFilter: PG16_KEYS,
+      getRowValueUnit: getRowValueUnit,
+      defaultRowValueCaption: "average of series",
+    });
+    const limitRow: Record<string, unknown> = lastRowFor(
+      "mysql.buffer_pool.limit",
+    );
+    expect(limitRow["valueUnit"]).toBe("{pages}");
+    // The list's own value, as for any row the host has no value for.
+    expect(limitRow["lastValue"]).toBe(4);
+    expect(limitRow["valueCaption"]).toBe("average of series");
+    expect(lastRowFor("postgresql.backends")["valueUnit"]).toBeUndefined();
+
+    // A user's own attribute filter sets the host's values aside, not its units.
+    cleanup();
+    rowProps.length = 0;
+    window.history.pushState(
+      {},
+      "",
+      `/metrics?filters=${encodeURIComponent(
+        JSON.stringify([["attributes.db.namespace", "orders"]]),
+      )}`,
+    );
+    await act(async () => {
+      render(
+        <MetricsViewer
+          entityKeysFilter={PG16_KEYS}
+          getRowValueUnit={getRowValueUnit}
+        />,
+      );
+    });
+    await act(async () => {
+      await new Promise((resolve: (value: unknown) => void) => {
+        setTimeout(resolve, 0);
+      });
+    });
+    window.history.pushState({}, "", "/");
+    expect(lastRowFor("mysql.buffer_pool.limit")["valueUnit"]).toBe("{pages}");
+  });
+});

package/Tests/App/Dashboard/MonitorCreateFromMonitorBackedDevice.test.tsx

@@ -207,7 +207,15 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
   };
 });
 
-import MonitorCreate from "../../../../App/FeatureSet/Dashboard/src/Pages/Monitor/Create";
+import MonitorCreate, {
+  MAX_REQUESTED_MONITOR_DESCRIPTION_LENGTH,
+  MONITOR_DESCRIPTION_QUERY_PARAM,
+  getMetricViewMonitorDescription,
+} from "../../../../App/FeatureSet/Dashboard/src/Pages/Monitor/Create";
+import {
+  DATABASE_METRIC_MONITOR_DESCRIPTION_PARAM,
+  getDatabaseMetricMonitorDescription,
+} from "../../../../App/FeatureSet/Dashboard/src/Pages/Database/Utils/DatabaseMetricMonitorLink";
 import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
@@ -630,3 +638,126 @@ describe("the monitor create page opened from a network device", () => {
     });
   });
 });
+
+/*
+ * The other deep link that pre-seeds a Metrics monitor: "Create monitor" on
+ * a chart. The Database metric chart sends `monitorDescription` ("Created
+ * from database <name>."), which the page used to ignore, so every such
+ * monitor read "Created from the Metric Explorer view for …" — a view the
+ * person never opened.
+ */
+describe("the monitor create page opened from a metric chart", () => {
+  const METRIC_QUERIES: string = JSON.stringify([
+    { metricName: "postgresql.backends" },
+  ]);
+
+  function openWithParams(
+    params: Record<string, string>,
+  ): Promise<CapturedFormProps> {
+    jest
+      .spyOn(Navigation, "getQueryStringByName")
+      .mockImplementation((paramName: string): string | null => {
+        return params[paramName] ?? null;
+      });
+    return openForm();
+  }
+
+  beforeEach(() => {
+    capturedForm = null;
+    probeListResult = (): Promise<Array<Record<string, unknown>>> => {
+      return Promise.resolve([BRANCH_PROBE_ROW, GLOBAL_PROBE_ROW]);
+    };
+    monitorStatusRows = [
+      monitorStatus({
+        id: ONLINE_STATUS_ID,
+        isOperationalState: true,
+        isOfflineState: false,
+      }),
+    ];
+    jest.spyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(PROJECT_ID);
+    getJestSpyOn(UiAnalytics, "captureRevenueEvent").mockImplementation(
+      (): void => {},
+    );
+  });
+
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+  });
+
+  test("a database chart's link names the database in the description", async () => {
+    const form: CapturedFormProps = await openWithParams({
+      metricQueries: METRIC_QUERIES,
+      [DATABASE_METRIC_MONITOR_DESCRIPTION_PARAM]:
+        getDatabaseMetricMonitorDescription("orders-db"),
+    });
+
+    expect(form.initialValues["monitorType"]).toBe(MonitorType.Metrics);
+    expect(form.initialValues["name"]).toBe("postgresql.backends Monitor");
+    expect(form.initialValues["description"]).toBe(
+      "Created from database orders-db.",
+    );
+  });
+
+  test("a link that asks for no description keeps the Metric Explorer wording", async () => {
+    const form: CapturedFormProps = await openWithParams({
+      metricQueries: METRIC_QUERIES,
+    });
+
+    expect(form.initialValues["description"]).toBe(
+      "Created from the Metric Explorer view for postgresql.backends.",
+    );
+  });
+
+  test("a blank description is no description", async () => {
+    const form: CapturedFormProps = await openWithParams({
+      metricQueries: METRIC_QUERIES,
+      [MONITOR_DESCRIPTION_QUERY_PARAM]: "   \n ",
+    });
+
+    expect(form.initialValues["description"]).toBe(
+      "Created from the Metric Explorer view for postgresql.backends.",
+    );
+  });
+
+  test("the database link sends the parameter the page reads", () => {
+    expect(DATABASE_METRIC_MONITOR_DESCRIPTION_PARAM).toBe(
+      MONITOR_DESCRIPTION_QUERY_PARAM,
+    );
+  });
+
+  test("a requested description is trimmed and capped", () => {
+    expect(
+      getMetricViewMonitorDescription({
+        metricDisplayName: "Connections",
+        requestedDescription: "  Created from database orders-db.  ",
+      }),
+    ).toBe("Created from database orders-db.");
+
+    const capped: string = getMetricViewMonitorDescription({
+      metricDisplayName: "Connections",
+      requestedDescription: `  ${"x".repeat(
+        MAX_REQUESTED_MONITOR_DESCRIPTION_LENGTH + 100,
+      )}`,
+    });
+    expect(capped).toBe("x".repeat(MAX_REQUESTED_MONITOR_DESCRIPTION_LENGTH));
+
+    // Counted in characters: a character at the cap is never cut in half.
+    const emoji: string = getMetricViewMonitorDescription({
+      metricDisplayName: "Connections",
+      requestedDescription: "\u{1F418}".repeat(
+        MAX_REQUESTED_MONITOR_DESCRIPTION_LENGTH + 1,
+      ),
+    });
+    expect(emoji).toBe(
+      "\u{1F418}".repeat(MAX_REQUESTED_MONITOR_DESCRIPTION_LENGTH),
+    );
+
+    expect(
+      getMetricViewMonitorDescription({
+        metricDisplayName: "Connections",
+        requestedDescription: null,
+      }),
+    ).toBe("Created from the Metric Explorer view for Connections.");
+  });
+});

package/Tests/App/Dashboard/NavigationSearchKeywords.test.tsx

@@ -101,6 +101,11 @@ const SEARCH_CASES: Array<[string, string, string]> = [
   ["oncall", "On-Call Duty", PageMap.ON_CALL_DUTY],
   ["escalation", "On-Call Duty", PageMap.ON_CALL_DUTY],
   ["rca", "Insights", PageMap.AI_INSIGHTS],
+  ["postgres", "Databases", PageMap.DATABASE_SERVERS],
+  ["mysql", "Databases", PageMap.DATABASE_SERVERS],
+  ["redis", "Databases", PageMap.DATABASE_SERVERS],
+  ["mongodb", "Databases", PageMap.DATABASE_SERVERS],
+  ["sql server", "Databases", PageMap.DATABASE_SERVERS],
 ];
 
 function navbar(): React.ReactElement {

package/Tests/App/Dashboard/ProductOrientation.test.tsx

@@ -347,11 +347,12 @@ describe("Products menu sections", () => {
     expect(resources.items).toEqual([
       "Inventory",
       "Services",
+      "Databases",
       "Real User Monitoring",
     ]);
   });
 
-  test("regrouping lost no product: all 40 are still listed exactly once", () => {
+  test("regrouping lost no product: all 41 are still listed exactly once", () => {
     openProductsMenu();
 
     const titles: Array<string> = readMenuSections().flatMap(
@@ -359,8 +360,8 @@ describe("Products menu sections", () => {
         return section.items;
       },
     );
-    expect(titles).toHaveLength(40);
-    expect(new Set(titles).size).toBe(40);
+    expect(titles).toHaveLength(41);
+    expect(new Set(titles).size).toBe(41);
   });
 });