@oneuptime/common 14.0.5 → 14.0.6

package/Tests/App/Dashboard/TelemetryMetricsSignals.test.ts

@@ -72,6 +72,7 @@ import {
   fetchLogAndExceptionSignals,
   fetchSpanMetrics,
   fetchSpanNameStats,
+  fetchWebVitalByRoute,
   fetchWebVitals,
   formatBytes as reexportedFormatBytes,
   formatCompact as reexportedFormatCompact,
@@ -84,7 +85,9 @@ import {
   spanNameStatsFromTableRows,
   summarizeLogAndExceptionBuckets,
   TimePoint,
+  WEB_VITAL_ROUTE_LIMIT,
   WebVital,
+  WebVitalByRoute,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/TelemetryResource/telemetryMetrics";
 import {
   formatBytes,
@@ -98,11 +101,13 @@ import URL from "../../../Types/API/URL";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import { SpanStatus } from "../../../Models/AnalyticsModels/Span";
 import {
   WebVitalDefinition,
   WebVitalDefinitions,
+  WebVitalRouteAttributeKeys,
 } from "../../../Types/Rum/WebVitals";
 import { APP_API_URL } from "../../../UI/Config";
 
@@ -126,10 +131,13 @@ interface AggregateRequest {
   aggregateBy: {
     query: Record<string, unknown>;
     aggregationType: AggregationType;
+    aggregationInterval?: AggregationInterval;
     aggregateColumnName: string;
     aggregationTimestampColumnName: string;
     startTimestamp: Date;
     endTimestamp: Date;
+    groupByAttributeKeys?: Array<string>;
+    topK?: { count: number; rankBy: string };
   };
 }
 
@@ -1072,6 +1080,7 @@ describe("fetchWebVitals", () => {
         value: null,
         unit: d.unit,
         thresholds: d.thresholds,
+        metricName: null,
       });
       expect(v.description.length).toBeGreaterThan(20);
     });
@@ -1086,12 +1095,7 @@ describe("fetchWebVitals", () => {
       ];
 
       if (name === second) {
-        return {
-          data: [
-            { time: T0, value: 1000 },
-            { time: T1, value: 3000 },
-          ],
-        };
+        return { data: [{ time: T0, value: 2000 }] };
       }
 
       return { data: [] };
@@ -1107,8 +1111,9 @@ describe("fetchWebVitals", () => {
       return v.key === "lcp";
     })!;
 
-    // The average of the per-interval averages.
+    // The one whole-range mean, and the name it was found under.
     expect(lcp.value).toBe(2000);
+    expect(lcp.metricName).toBe(second);
     expect(lcp.description).toBe(LCP.description);
 
     const asked: Array<string> = metricNames();
@@ -1119,7 +1124,13 @@ describe("fetchWebVitals", () => {
     }
   });
 
-  test("averages, scoped to the entity and window", async () => {
+  /*
+   * A mean of the whole range at once - not a mean of per-interval means,
+   * which let a quiet interval count as much as a busy one. A mean rather
+   * than a p75 because a histogram's percentile comes from its buckets,
+   * and the OpenTelemetry defaults put every CLS value in (0, 5].
+   */
+  test("asks for one mean over the whole window, scoped to the entity", async () => {
     aggregateMock.mockResolvedValue({ data: [] });
 
     await fetchWebVitals({
@@ -1130,6 +1141,7 @@ describe("fetchWebVitals", () => {
 
     for (const r of aggregateRequests()) {
       expect(r.aggregateBy.aggregationType).toBe(AggregationType.Avg);
+      expect(r.aggregateBy.aggregationInterval).toBe(AggregationInterval.Total);
       expect(String(r.aggregateBy.query["primaryEntityId"])).toBe(ENTITY_ID);
       expect(r.aggregateBy.startTimestamp).toBe(START);
       expect(r.aggregateBy.endTimestamp).toBe(END);
@@ -1137,6 +1149,154 @@ describe("fetchWebVitals", () => {
   });
 });
 
+describe("fetchWebVitalByRoute", () => {
+  const INP_NAME: string = "web_vital.inp";
+
+  function ask(): Promise<WebVitalByRoute> {
+    return fetchWebVitalByRoute({
+      primaryEntityId: new ObjectID(ENTITY_ID),
+      metricName: INP_NAME,
+      start: START,
+      end: END,
+    });
+  }
+
+  function routeRow(
+    key: string,
+    route: string | undefined,
+    value: number,
+  ): Record<string, unknown> {
+    return {
+      time: T0,
+      value: value,
+      attributes: route === undefined ? {} : { [key]: route },
+    };
+  }
+
+  test("asks for the mean of this metric per route over the whole window, top routes only", async () => {
+    aggregateMock.mockResolvedValue({ data: [] });
+
+    await ask();
+
+    const [first] = aggregateRequests();
+
+    expect(first?.aggregateBy.query["name"]).toBe(INP_NAME);
+    expect(String(first?.aggregateBy.query["primaryEntityId"])).toBe(ENTITY_ID);
+    expect(String(first?.aggregateBy.query["projectId"])).toBe(PROJECT_ID);
+    expect(first?.aggregateBy.aggregationType).toBe(AggregationType.Avg);
+    expect(first?.aggregateBy.aggregationInterval).toBe(
+      AggregationInterval.Total,
+    );
+    expect(first?.aggregateBy.groupByAttributeKeys).toEqual(["app.route"]);
+    // One spare slot for the pooled rows that carry no route at all.
+    expect(first?.aggregateBy.topK).toEqual({
+      count: WEB_VITAL_ROUTE_LIMIT + 1,
+      rankBy: "max",
+    });
+  });
+
+  test("returns the routes slowest first, leaving out rows without a route", async () => {
+    aggregateMock.mockResolvedValue({
+      data: [
+        routeRow("app.route", "/cart", 240),
+        routeRow("app.route", undefined, 900),
+        routeRow("app.route", "  ", 800),
+        routeRow("app.route", "/products/:id", 620),
+      ],
+      totalGroups: 5,
+    });
+
+    const result: WebVitalByRoute = await ask();
+
+    expect(result).toEqual({
+      routeAttribute: "app.route",
+      routes: [
+        { route: "/products/:id", value: 620 },
+        { route: "/cart", value: 240 },
+      ],
+      // Five groups, one of them the blank no-route group.
+      totalRoutes: 4,
+      failed: false,
+    });
+  });
+
+  test("falls back to url.template, OpenTelemetry's name for the route", async () => {
+    aggregateMock.mockImplementation(async (...args: Array<unknown>) => {
+      const keys: Array<string> =
+        (args[0] as AggregateRequest).aggregateBy.groupByAttributeKeys || [];
+
+      if (keys[0] === "url.template") {
+        return { data: [routeRow("url.template", "/orders/{id}", 310)] };
+      }
+
+      return { data: [routeRow("app.route", undefined, 310)] };
+    });
+
+    const result: WebVitalByRoute = await ask();
+
+    expect(
+      aggregateRequests().map((r: AggregateRequest): unknown => {
+        return r.aggregateBy.groupByAttributeKeys;
+      }),
+    ).toEqual(
+      WebVitalRouteAttributeKeys.map((key: string): Array<string> => {
+        return [key];
+      }),
+    );
+    expect(result.routeAttribute).toBe("url.template");
+    expect(result.routes).toEqual([{ route: "/orders/{id}", value: 310 }]);
+    expect(result.totalRoutes).toBeNull();
+  });
+
+  test("keeps at most the route limit", async () => {
+    aggregateMock.mockResolvedValue({
+      data: Array.from(
+        { length: WEB_VITAL_ROUTE_LIMIT + 1 },
+        (_: unknown, i: number) => {
+          return routeRow("app.route", `/r${i}`, 100 + i);
+        },
+      ),
+    });
+
+    const result: WebVitalByRoute = await ask();
+
+    expect(result.routes).toHaveLength(WEB_VITAL_ROUTE_LIMIT);
+    expect(result.routes[0]?.value).toBe(100 + WEB_VITAL_ROUTE_LIMIT);
+  });
+
+  test("no route under any attribute is an empty answer, not a failure", async () => {
+    aggregateMock.mockResolvedValue({ data: [] });
+
+    expect(await ask()).toEqual({
+      routeAttribute: null,
+      routes: [],
+      totalRoutes: null,
+      failed: false,
+    });
+    expect(aggregateMock).toHaveBeenCalledTimes(
+      WebVitalRouteAttributeKeys.length,
+    );
+  });
+
+  test("a failed lookup is marked failed rather than read as no routes", async () => {
+    aggregateMock.mockRejectedValue(new Error("403"));
+
+    const result: WebVitalByRoute = await ask();
+
+    expect(result.failed).toBe(true);
+    expect(result.routes).toEqual([]);
+  });
+
+  test("no current project: returns empty without asking", async () => {
+    projectIdMock.mockReturnValue(null);
+
+    const result: WebVitalByRoute = await ask();
+
+    expect(result.failed).toBe(false);
+    expect(aggregateMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("telemetryFormat", () => {
   test.each([
     [null, "—"],

package/Tests/Server/Services/MetricServiceAggregate.test.ts

@@ -203,6 +203,18 @@ describe("MetricService aggregate statement generation", () => {
       expect(query).not.toContain("__attr_grp_0");
       expect(query).toContain("GROUP BY time");
     });
+
+    it("computes P75 - the Core Web Vitals level - over the histogram buckets", () => {
+      const query: string = getQuery(
+        buildAggregateBy({
+          aggregationType: AggregationType.P75,
+          groupByAttributeKeys: ["app.route"],
+        }),
+      );
+
+      expect(query).toContain("quantileExactWeighted(0.75)");
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+    });
   });
 
   /*

package/Tests/Server/Services/SavedViewDefaults.test.ts

@@ -0,0 +1,325 @@
+import LogSavedViewService from "../../../Server/Services/LogSavedViewService";
+import MetricSavedViewService from "../../../Server/Services/MetricSavedViewService";
+import TraceSavedViewService from "../../../Server/Services/TraceSavedViewService";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../../../Server/Types/Database/Hooks";
+import LogSavedView from "../../../Models/DatabaseModels/LogSavedView";
+import MetricSavedView from "../../../Models/DatabaseModels/MetricSavedView";
+import TraceSavedView from "../../../Models/DatabaseModels/TraceSavedView";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Telemetry saved views (logs, traces and metrics) each promise a project
+ * exactly one default: the first view a project saves becomes its default, and
+ * marking another one default clears whichever view held it. Three services
+ * carry the same hooks, so the suite runs against all three -- a change made
+ * to one of them and not the others shows up here rather than as a project
+ * whose telemetry page opens two default views, or none.
+ */
+
+type SavedViewModel = LogSavedView | MetricSavedView | TraceSavedView;
+
+/*
+ * The two hooks under test, reached past `protected`. Typed over the union of
+ * the three models so one set of cases can drive all three services.
+ */
+type SavedViewService = {
+  onBeforeCreate: (
+    createBy: CreateBy<SavedViewModel>,
+  ) => Promise<OnCreate<SavedViewModel>>;
+  onBeforeUpdate: (
+    updateBy: UpdateBy<SavedViewModel>,
+  ) => Promise<OnUpdate<SavedViewModel>>;
+};
+
+type ServiceCase = {
+  label: string;
+  service: SavedViewService;
+  buildModel: () => SavedViewModel;
+};
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const VIEW_ID: ObjectID = new ObjectID("22222222-2222-4222-8222-222222222222");
+
+const cases: Array<ServiceCase> = [
+  {
+    label: "LogSavedViewService",
+    service: LogSavedViewService as unknown as SavedViewService,
+    buildModel: (): SavedViewModel => {
+      return new LogSavedView();
+    },
+  },
+  {
+    label: "TraceSavedViewService",
+    service: TraceSavedViewService as unknown as SavedViewService,
+    buildModel: (): SavedViewModel => {
+      return new TraceSavedView();
+    },
+  },
+  {
+    label: "MetricSavedViewService",
+    service: MetricSavedViewService as unknown as SavedViewService,
+    buildModel: (): SavedViewModel => {
+      return new MetricSavedView();
+    },
+  },
+];
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe.each(cases)(
+  "$label default-view hooks",
+  ({ service, buildModel }: ServiceCase) => {
+    function mockFindOneBy(existing: SavedViewModel | null): jest.SpyInstance {
+      return jest
+        .spyOn(service as never, "findOneBy")
+        .mockResolvedValue(existing as never);
+    }
+
+    function mockFindBy(items: Array<SavedViewModel>): jest.SpyInstance {
+      return jest
+        .spyOn(service as never, "findBy")
+        .mockResolvedValue(items as never);
+    }
+
+    function mockUpdateBy(): jest.SpyInstance {
+      return jest
+        .spyOn(service as never, "updateBy")
+        .mockResolvedValue(undefined as never);
+    }
+
+    describe("onBeforeCreate", () => {
+      test("the first view a project saves becomes its default", async () => {
+        mockFindOneBy(null);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+        view.projectId = PROJECT_ID;
+
+        const result: OnCreate<SavedViewModel> = await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        expect(result.createBy.data.isDefault).toBe(true);
+        /*
+         * Nothing else held the default, but the sweep still runs and is a no-op
+         * against an empty project.
+         */
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+      });
+
+      test("a later view is not made default while one already exists", async () => {
+        const existing: SavedViewModel = buildModel();
+        existing._id = VIEW_ID.toString();
+        mockFindOneBy(existing);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+        view.projectId = PROJECT_ID;
+
+        const result: OnCreate<SavedViewModel> = await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        expect(result.createBy.data.isDefault).toBe(false);
+        // Not default, so nothing is unset.
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+
+      test("an explicit isDefault=true clears whichever view held it", async () => {
+        const findOneSpy: jest.SpyInstance = mockFindOneBy(null);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+        view.projectId = PROJECT_ID;
+        view.isDefault = true;
+
+        await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        // The caller said so, so the service does not go looking.
+        expect(findOneSpy).not.toHaveBeenCalled();
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        const updateArgs: Record<string, unknown> = updateSpy.mock
+          .calls[0]?.[0] as Record<string, unknown>;
+        const query: Record<string, unknown> = updateArgs["query"] as Record<
+          string,
+          unknown
+        >;
+        expect(query["projectId"]).toBe(PROJECT_ID);
+        expect(query["isDefault"]).toBe(true);
+        expect(updateArgs["data"]).toEqual({ isDefault: false });
+        /*
+         * The sweep runs as root: a member may only see their own views, and
+         * leaving the others default would break the one-default promise.
+         */
+        expect(updateArgs["props"]).toEqual({ isRoot: true });
+      });
+
+      test("an explicit isDefault=false is kept, and unsets nothing", async () => {
+        const findOneSpy: jest.SpyInstance = mockFindOneBy(null);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+        view.projectId = PROJECT_ID;
+        view.isDefault = false;
+
+        const result: OnCreate<SavedViewModel> = await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        expect(result.createBy.data.isDefault).toBe(false);
+        expect(findOneSpy).not.toHaveBeenCalled();
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+
+      test("a view with no project is left alone", async () => {
+        const findOneSpy: jest.SpyInstance = mockFindOneBy(null);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+
+        const result: OnCreate<SavedViewModel> = await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        expect(result.createBy.data.isDefault).toBeUndefined();
+        expect(findOneSpy).not.toHaveBeenCalled();
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+
+      test("the lookup for an existing default is scoped to the same project", async () => {
+        const findOneSpy: jest.SpyInstance = mockFindOneBy(null);
+        mockUpdateBy();
+
+        const view: SavedViewModel = buildModel();
+        view.projectId = PROJECT_ID;
+
+        await service.onBeforeCreate({
+          data: view,
+        } as CreateBy<SavedViewModel>);
+
+        const findArgs: Record<string, unknown> = findOneSpy.mock
+          .calls[0]?.[0] as Record<string, unknown>;
+        expect(findArgs["query"]).toEqual({
+          projectId: PROJECT_ID,
+          isDefault: true,
+        });
+      });
+    });
+
+    describe("onBeforeUpdate", () => {
+      test("promoting a view to default demotes the others, but not itself", async () => {
+        const item: SavedViewModel = buildModel();
+        item._id = VIEW_ID.toString();
+        item.projectId = PROJECT_ID;
+        mockFindBy([item]);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        await service.onBeforeUpdate({
+          query: { _id: VIEW_ID.toString() },
+          data: { isDefault: true },
+        } as unknown as UpdateBy<SavedViewModel>);
+
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        const query: Record<string, unknown> = (
+          updateSpy.mock.calls[0]?.[0] as Record<string, unknown>
+        )["query"] as Record<string, unknown>;
+        expect(query["projectId"]).toBe(PROJECT_ID);
+        expect(query["isDefault"]).toBe(true);
+        /*
+         * The view being promoted is excluded, so the same statement cannot
+         * demote it again.
+         */
+        expect(query["_id"]).toBeDefined();
+      });
+
+      test("an update that does not set isDefault=true touches nothing", async () => {
+        const findSpy: jest.SpyInstance = mockFindBy([]);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        for (const data of [{ name: "Renamed" }, { isDefault: false }] as Array<
+          Partial<SavedViewModel>
+        >) {
+          await service.onBeforeUpdate({
+            query: { _id: VIEW_ID.toString() },
+            data: data,
+          } as unknown as UpdateBy<SavedViewModel>);
+        }
+
+        expect(findSpy).not.toHaveBeenCalled();
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+
+      test("a bulk promotion demotes the others in each affected project", async () => {
+        const otherProjectId: ObjectID = new ObjectID(
+          "33333333-3333-4333-8333-333333333333",
+        );
+        const first: SavedViewModel = buildModel();
+        first._id = VIEW_ID.toString();
+        first.projectId = PROJECT_ID;
+        const second: SavedViewModel = buildModel();
+        second._id = "44444444-4444-4444-8444-444444444444";
+        second.projectId = otherProjectId;
+        mockFindBy([first, second]);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        await service.onBeforeUpdate({
+          query: { isDefault: false },
+          data: { isDefault: true },
+        } as unknown as UpdateBy<SavedViewModel>);
+
+        expect(updateSpy).toHaveBeenCalledTimes(2);
+        const projectIds: Array<unknown> = updateSpy.mock.calls.map(
+          (call: Array<unknown>) => {
+            return (
+              (call[0] as Record<string, unknown>)["query"] as Record<
+                string,
+                unknown
+              >
+            )["projectId"];
+          },
+        );
+        expect(projectIds).toEqual([PROJECT_ID, otherProjectId]);
+      });
+
+      test("a matched view with no project is skipped rather than swept globally", async () => {
+        const orphan: SavedViewModel = buildModel();
+        orphan._id = VIEW_ID.toString();
+        mockFindBy([orphan]);
+        const updateSpy: jest.SpyInstance = mockUpdateBy();
+
+        await service.onBeforeUpdate({
+          query: { _id: VIEW_ID.toString() },
+          data: { isDefault: true },
+        } as unknown as UpdateBy<SavedViewModel>);
+
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+    });
+  },
+);
+
+describe("the three saved-view services", () => {
+  test("are distinct services over distinct models", () => {
+    const models: Array<string> = cases.map(({ buildModel }: ServiceCase) => {
+      return (buildModel() as BaseModel).tableName as string;
+    });
+    expect(new Set(models).size).toBe(3);
+    expect(
+      new Set([
+        LogSavedViewService,
+        TraceSavedViewService,
+        MetricSavedViewService,
+      ]).size,
+    ).toBe(3);
+  });
+});