@oneuptime/common 13.0.3 → 13.0.5

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

@@ -528,6 +528,47 @@ describe("TelemetryIngestionKeyService.onBeforeCreate - what must keep working",
     ]);
   });
 
+  test("a Browser key accepts and canonicalises exact app:// mobile identities", async () => {
+    const { internals }: Harness = buildService();
+
+    const createBy: CreateBy<Model> = createByModel({
+      keyType: TelemetryIngestionKeyType.Browser,
+      allowedOrigins: [
+        "  APP://COM.Example.Checkout/  ",
+        "app://com.example.checkout",
+        "app://com.example.checkout-beta_native",
+      ],
+    });
+
+    await expect(internals.onBeforeCreate(createBy)).resolves.toBeDefined();
+    expect(writtenValues(createBy)["allowedOrigins"]).toEqual([
+      "app://com.example.checkout",
+      "app://com.example.checkout-beta_native",
+    ]);
+  });
+
+  test.each([
+    "app://*.example.checkout",
+    "app://com.example.checkout:443",
+    "app://com.example.checkout/screen",
+    "app://checkout",
+    "app://com..checkout",
+  ])(
+    "a Browser key refuses unsafe mobile origin %s",
+    async (origin: string) => {
+      const { internals }: Harness = buildService();
+
+      await expect(
+        internals.onBeforeCreate(
+          createByModel({
+            keyType: TelemetryIngestionKeyType.Browser,
+            allowedOrigins: [origin],
+          }),
+        ),
+      ).rejects.toThrow();
+    },
+  );
+
   /*
    * Stored in the form the matcher compares against, so what the dashboard
    * lists is exactly what will be matched at ingest time. A pasted
@@ -831,6 +872,18 @@ describe("TelemetryIngestionKeyService.onBeforeUpdate - the other constrained co
     ).rejects.toThrow("https://exa_mple.com");
   });
 
+  test("accepts an exact app:// mobile identity on update", async () => {
+    const { internals }: Harness = buildService();
+    const updateBy: UpdateBy<Model> = updateByBag({
+      allowedOrigins: [" APP://COM.Example.Checkout/ "],
+    });
+
+    await expect(internals.onBeforeUpdate(updateBy)).resolves.toBeDefined();
+    expect(
+      (updateBy.data as unknown as Record<string, unknown>)["allowedOrigins"],
+    ).toEqual(["app://com.example.checkout"]);
+  });
+
   test("refuses a pinned service name longer than the column can hold", async () => {
     const { internals }: Harness = buildService();
 

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

@@ -0,0 +1,218 @@
+import LogAggregationService from "../../../Server/Services/LogAggregationService";
+import TraceAggregationService, {
+  FacetValue as TraceFacetValue,
+} from "../../../Server/Services/TraceAggregationService";
+import ExceptionAggregationService from "../../../Server/Services/ExceptionAggregationService";
+import MetricAggregationService from "../../../Server/Services/MetricAggregationService";
+import SpanService from "../../../Server/Services/SpanService";
+import { Results } from "../../../Server/Services/AnalyticsDatabaseService";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import {
+  RESOURCE_FACET_CATALOG,
+  ResourceFacetDefinition,
+} from "../../../Types/Telemetry/ResourceFacetCatalog";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * Every resource facet the explorers offer is counted by the aggregation
+ * services as `toString(primaryEntityId)` restricted to that resource's
+ * `primaryEntityType`. The four services each kept a hand-copied
+ * facetKey -> ServiceType map, and two resource types (Docker Swarm, IoT
+ * fleet) were missing from all of them — so their facet keys fell through
+ * to the ATTRIBUTE path, `attributes['dockerSwarmClusterId']`, which no row
+ * ever has, and silently counted nothing.
+ *
+ * The maps are now derived from ResourceFacetCatalog. These tests build the
+ * real (private, pure) facet statements for every catalog entry in every
+ * service, so a resource type cannot again be offered in the sidebar but
+ * counted as an attribute.
+ */
+
+type BuildFacetStatement = (request: JSONObject) => Statement;
+
+interface ServiceUnderTest {
+  name: string;
+  build: BuildFacetStatement;
+}
+
+const projectId: ObjectID = ObjectID.generate();
+const startTime: Date = new Date("2026-09-01T00:00:00.000Z");
+const endTime: Date = new Date("2026-09-01T01:00:00.000Z");
+
+function builderFor(service: unknown): BuildFacetStatement {
+  return (request: JSONObject): Statement => {
+    return (
+      service as { buildFacetStatement: BuildFacetStatement }
+    ).buildFacetStatement({
+      projectId,
+      startTime,
+      endTime,
+      limit: 25,
+      ...request,
+    });
+  };
+}
+
+const SERVICES: Array<ServiceUnderTest> = [
+  { name: "LogAggregationService", build: builderFor(LogAggregationService) },
+  {
+    name: "ExceptionAggregationService",
+    build: builderFor(ExceptionAggregationService),
+  },
+  {
+    name: "MetricAggregationService",
+    build: builderFor(MetricAggregationService),
+  },
+  {
+    name: "TraceAggregationService",
+    build: builderFor(TraceAggregationService),
+  },
+];
+
+function paramValues(statement: Statement): Array<unknown> {
+  return Object.values(statement.query_params);
+}
+
+describe("resource facet counting covers the whole catalog", () => {
+  for (const service of SERVICES) {
+    describe(service.name, () => {
+      for (const definition of RESOURCE_FACET_CATALOG) {
+        test(`${definition.facetKey} counts primaryEntityId rows typed ${definition.serviceType}`, () => {
+          const statement: Statement = service.build({
+            facetKey: definition.facetKey,
+          });
+
+          expect(statement.query).toContain(
+            "SELECT toString(primaryEntityId) AS val, count() AS cnt",
+          );
+          expect(statement.query).toMatch(
+            / AND primaryEntityType = \{p\d+:String\}/,
+          );
+          expect(paramValues(statement)).toContain(definition.serviceType);
+
+          // Never the attribute path, which would silently count nothing.
+          expect(statement.query).not.toContain("mapContains(attributes");
+          expect(paramValues(statement)).not.toContain(definition.facetKey);
+        });
+      }
+
+      test("dockerSwarmClusterId is counted under DockerSwarmCluster", () => {
+        const statement: Statement = service.build({
+          facetKey: "dockerSwarmClusterId",
+        });
+
+        expect(paramValues(statement)).toContain(
+          ServiceType.DockerSwarmCluster,
+        );
+      });
+
+      test("iotFleetId is counted under IoTDevice — ingest stamps the fleet id with that type", () => {
+        const statement: Statement = service.build({ facetKey: "iotFleetId" });
+
+        expect(paramValues(statement)).toContain(ServiceType.IoTDevice);
+        expect(paramValues(statement)).not.toContain("IoTFleet");
+      });
+
+      test("the Services facet stays restricted to Service-typed rows", () => {
+        const statement: Statement = service.build({
+          facetKey: "primaryEntityId",
+        });
+
+        expect(statement.query).toContain(
+          " AND (primaryEntityType = '' OR primaryEntityType = ",
+        );
+        expect(paramValues(statement)).toContain(ServiceType.OpenTelemetry);
+        for (const definition of RESOURCE_FACET_CATALOG) {
+          expect(paramValues(statement)).not.toContain(definition.serviceType);
+        }
+      });
+
+      test("a look-alike key that is not in the catalog is still an attribute facet", () => {
+        const statement: Statement = service.build({
+          facetKey: "iotDeviceId",
+        });
+
+        expect(statement.query).toContain("mapContains(attributes");
+        expect(statement.query).not.toMatch(/ AND primaryEntityType = /);
+      });
+
+      test("each resource facet key counts under a different type", () => {
+        const types: Array<unknown> = RESOURCE_FACET_CATALOG.map(
+          (definition: ResourceFacetDefinition): unknown => {
+            const statement: Statement = service.build({
+              facetKey: definition.facetKey,
+            });
+
+            return paramValues(statement).find((value: unknown): boolean => {
+              return (Object.values(ServiceType) as Array<unknown>).includes(
+                value,
+              );
+            });
+          },
+        );
+
+        expect(new Set(types).size).toBe(RESOURCE_FACET_CATALOG.length);
+      });
+    });
+  }
+});
+
+describe("TraceAggregationService.getFacetValuesFromSample (resource keys)", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function stubSpans(rows: Array<JSONObject>): Array<Statement> {
+    const captured: Array<Statement> = [];
+
+    jest.spyOn(SpanService, "executeQuery").mockImplementation(((
+      statement: Statement,
+    ): Promise<Results> => {
+      captured.push(statement);
+
+      return Promise.resolve({
+        json: (): Promise<unknown> => {
+          return Promise.resolve({ data: rows });
+        },
+      } as unknown as Results);
+    }) as never);
+
+    return captured;
+  }
+
+  test("counts Docker Swarm and IoT fleet rows by their primaryEntityType, not as attributes", async () => {
+    const swarmId: string = ObjectID.generate().toString();
+    const fleetId: string = ObjectID.generate().toString();
+    const hostId: string = ObjectID.generate().toString();
+
+    const captured: Array<Statement> = stubSpans([
+      { primaryEntityId: swarmId, primaryEntityType: "DockerSwarmCluster" },
+      { primaryEntityId: swarmId, primaryEntityType: "DockerSwarmCluster" },
+      { primaryEntityId: fleetId, primaryEntityType: "IoTDevice" },
+      { primaryEntityId: hostId, primaryEntityType: "Host" },
+    ]);
+
+    const facets: Record<
+      string,
+      Array<TraceFacetValue>
+    > = await TraceAggregationService.getFacetValuesFromSample({
+      projectId,
+      startTime,
+      endTime,
+      facetKeys: ["dockerSwarmClusterId", "iotFleetId", "hostId"],
+    });
+
+    expect(facets["dockerSwarmClusterId"]).toEqual([
+      { value: swarmId, count: 2 },
+    ]);
+    expect(facets["iotFleetId"]).toEqual([{ value: fleetId, count: 1 }]);
+    expect(facets["hostId"]).toEqual([{ value: hostId, count: 1 }]);
+
+    // The sample reads the typed slot, not the attribute map.
+    expect(captured[0]!.query).toContain("primaryEntityType");
+    expect(captured[0]!.query).not.toContain("attributes");
+  });
+});

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

@@ -4,10 +4,22 @@
  * on a reachable Postgres.
  */
 const kubernetesClusterFindBy: jest.Mock = jest.fn();
+const proxmoxClusterFindBy: jest.Mock = jest.fn();
+const serverlessFunctionFindBy: jest.Mock = jest.fn();
+const rumApplicationFindBy: jest.Mock = jest.fn();
 
 jest.mock("../../../Server/Services/KubernetesClusterService", () => {
   return { __esModule: true, default: { findBy: kubernetesClusterFindBy } };
 });
+jest.mock("../../../Server/Services/ProxmoxClusterService", () => {
+  return { __esModule: true, default: { findBy: proxmoxClusterFindBy } };
+});
+jest.mock("../../../Server/Services/ServerlessFunctionService", () => {
+  return { __esModule: true, default: { findBy: serverlessFunctionFindBy } };
+});
+jest.mock("../../../Server/Services/RumApplicationService", () => {
+  return { __esModule: true, default: { findBy: rumApplicationFindBy } };
+});
 
 import LogAggregationService from "../../../Server/Services/LogAggregationService";
 import TraceAggregationService from "../../../Server/Services/TraceAggregationService";
@@ -18,7 +30,10 @@ import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
 import { ResourceEntityScope } from "../../../Server/Utils/Telemetry/ResourceEntityFilter";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
-import { keyForKubernetesCluster } from "../../../Utils/Telemetry/EntityKey";
+import {
+  keyForKubernetesCluster,
+  keyForProxmoxCluster,
+} from "../../../Utils/Telemetry/EntityKey";
 import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
 
 /*
@@ -53,6 +68,18 @@ const clusterScope: ResourceEntityScope = {
   attributeValues: ["prod-eu"],
 };
 
+/*
+ * A resource type with a resource attribute but no signal entity key
+ * (Serverless function / IoT fleet): the scope carries no `entityKeys`.
+ */
+const functionId: string = ObjectID.generate().toString();
+const functionScope: ResourceEntityScope = {
+  entityIds: [functionId],
+  entityKeys: [],
+  attributeKey: "resource.faas.name",
+  attributeValues: ["checkout-handler"],
+};
+
 /*
  * Capture the statements a service builds instead of running them. The
  * assertions are about the SQL shape (which branches, how they are combined),
@@ -85,6 +112,14 @@ describe("resource facet filters reach the telemetry read path", () => {
     kubernetesClusterFindBy.mockResolvedValue([
       { clusterIdentifier: "prod-eu" },
     ]);
+    proxmoxClusterFindBy.mockReset();
+    proxmoxClusterFindBy.mockResolvedValue([{ name: "pve-lab" }]);
+    serverlessFunctionFindBy.mockReset();
+    serverlessFunctionFindBy.mockResolvedValue([
+      { functionIdentifier: "checkout-handler" },
+    ]);
+    rumApplicationFindBy.mockReset();
+    rumApplicationFindBy.mockResolvedValue([]);
   });
 
   afterEach(() => {
@@ -151,6 +186,49 @@ describe("resource facet filters reach the telemetry read path", () => {
       expect(captured[0]!.query).toContain("hasAny(entityKeys,");
     });
 
+    test("an attribute-only scope matches by id or attribute and never emits hasAny", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+        resourceScopes: [functionScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      expect(query).toContain("AND (primaryEntityId IN");
+      expect(query).toContain("attributes[");
+      expect(query).not.toContain("hasAny(entityKeys,");
+      expect(Object.values(captured[0]!.query_params)).toContainEqual([
+        "checkout-handler",
+      ]);
+    });
+
+    test("facet counts for a newly counted resource type carry the other facets' scopes", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getFacetValues({
+        projectId,
+        startTime,
+        endTime,
+        facetKey: "dockerSwarmClusterId",
+        resourceScopes: [clusterScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      expect(query).toContain("toString(primaryEntityId) AS val");
+      expect(query).toContain("AND primaryEntityType = ");
+      expect(query).not.toContain("mapContains(attributes");
+      expect(Object.values(captured[0]!.query_params)).toContain(
+        "DockerSwarmCluster",
+      );
+      expect(query).toContain("hasAny(entityKeys,");
+    });
+
     test("no resource scope leaves the statement exactly as it was", async () => {
       const captured: Array<Statement> = captureStatements(LogService);
 
@@ -184,6 +262,24 @@ describe("resource facet filters reach the telemetry read path", () => {
       expect(query).toContain("hasAny(entityKeys,");
     });
 
+    test("the span histogram honours an attribute-only scope without hasAny", async () => {
+      const captured: Array<Statement> = captureStatements(SpanService);
+
+      await TraceAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+        resourceScopes: [functionScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      expect(query).toContain("primaryEntityId IN");
+      expect(query).toContain("attributes[");
+      expect(query).not.toContain("hasAny(entityKeys,");
+    });
+
     test("no resource scope leaves the span statement unchanged", async () => {
       const captured: Array<Statement> = captureStatements(SpanService);
 
@@ -249,6 +345,64 @@ describe("resource facet filters reach the telemetry read path", () => {
       expect(findBy.query["resourceEntityScopes"]).toBeDefined();
     });
 
+    test("LogService resolves a Proxmox cluster selection to its entity key and attribute", async () => {
+      const proxmoxId: string = ObjectID.generate().toString();
+      const findBy: FindByShape = {
+        query: { resourceFilters: { proxmoxClusterId: [proxmoxId] } },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        LogService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query["resourceFilters"]).toBeUndefined();
+      expect(findBy.query["resourceEntityScopes"]).toEqual([
+        {
+          entityIds: [proxmoxId],
+          entityKeys: [keyForProxmoxCluster(projectId.toString(), "pve-lab")],
+          attributeKey: "resource.proxmox.cluster.name",
+          attributeValues: ["pve-lab"],
+        },
+      ]);
+    });
+
+    test("SpanService resolves a serverless function selection to an attribute-only scope", async () => {
+      const findBy: FindByShape = {
+        query: { resourceFilters: { serverlessFunctionId: [functionId] } },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        SpanService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query["resourceEntityScopes"]).toEqual([functionScope]);
+    });
+
+    test("a RUM application selection stays primaryEntityId-only with no Postgres lookup", async () => {
+      const appId: string = ObjectID.generate().toString();
+      const findBy: FindByShape = {
+        query: { resourceFilters: { rumApplicationId: [appId] } },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        SpanService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query["resourceEntityScopes"]).toEqual([
+        { entityIds: [appId], entityKeys: [] },
+      ]);
+      expect(rumApplicationFindBy).not.toHaveBeenCalled();
+    });
+
     test("a query without resource filters is handed through untouched", async () => {
       const findBy: FindByShape = {
         query: { severityText: "Error" },

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

@@ -0,0 +1,142 @@
+import TraceAggregationService, {
+  FacetRequest,
+  HistogramRequest,
+} from "../../../Server/Services/TraceAggregationService";
+import {
+  SQL,
+  Statement,
+} from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AnalyticsTableName from "../../../Types/AnalyticsDatabase/AnalyticsTableName";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The exception page's span list scopes the histogram and the facets with the
+ * same exceptionScope the list query carries. If the aggregations ignored it,
+ * the chart above an exception's spans would count every span in the project.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "10000000-0000-4000-8000-000000000001",
+);
+const SERVICE_ID: string = "60000000-0000-4000-8000-000000000001";
+const FINGERPRINT: string = "fp-9f86d081884c7d65";
+
+const normalized: (statement: Statement) => string = (
+  statement: Statement,
+): string => {
+  return statement.query.replace(/\s+/g, " ");
+};
+
+const params: (statement: Statement) => Array<string> = (
+  statement: Statement,
+): Array<string> => {
+  return Object.values(statement.query_params).map((value: unknown) => {
+    return String(value);
+  });
+};
+
+describe("TraceAggregationService exceptionScope", () => {
+  const histogramRequest: HistogramRequest = {
+    projectId: PROJECT_ID,
+    startTime: new Date("2026-09-13T12:00:00.000Z"),
+    endTime: new Date("2026-09-14T12:00:00.000Z"),
+    bucketSizeInMinutes: 30,
+  };
+
+  const buildHistogram: (overrides?: Partial<HistogramRequest>) => Statement = (
+    overrides: Partial<HistogramRequest> = {},
+  ): Statement => {
+    return (TraceAggregationService as any).buildHistogramStatement({
+      ...histogramRequest,
+      ...overrides,
+    });
+  };
+
+  test("the histogram narrows to the exception's spans, pinned to the project", () => {
+    const statement: Statement = buildHistogram({
+      exceptionScope: { fingerprint: FINGERPRINT },
+    });
+
+    expect(normalized(statement)).toContain(
+      "AND (traceId, spanId) GLOBAL IN (SELECT traceId, spanId FROM",
+    );
+    expect(params(statement)).toEqual(
+      expect.arrayContaining([
+        AnalyticsTableName.ExceptionInstance,
+        PROJECT_ID.toString(),
+        FINGERPRINT,
+      ]),
+    );
+    expect(normalized(statement)).not.toContain("primaryEntityId = ");
+  });
+
+  test("adds the service when the scope names one", () => {
+    const statement: Statement = buildHistogram({
+      exceptionScope: { fingerprint: FINGERPRINT, primaryEntityId: SERVICE_ID },
+    });
+
+    expect(normalized(statement)).toMatch(
+      /AND fingerprint = \{p\d+:String\} AND primaryEntityId = \{p\d+:String\}\)/,
+    );
+    expect(params(statement)).toContain(SERVICE_ID);
+  });
+
+  test("emits nothing when no exception scope is requested", () => {
+    expect(normalized(buildHistogram())).not.toContain("IN (SELECT traceId");
+  });
+
+  test("the facets carry the same scope", () => {
+    const facetRequest: FacetRequest = {
+      ...histogramRequest,
+      facetKey: "statusCode",
+      exceptionScope: { fingerprint: FINGERPRINT },
+    } as FacetRequest;
+
+    const statement: Statement = (
+      TraceAggregationService as any
+    ).buildFacetStatement(facetRequest);
+
+    expect(normalized(statement)).toContain(
+      "AND (traceId, spanId) GLOBAL IN (SELECT traceId, spanId FROM",
+    );
+    expect(params(statement)).toContain(FINGERPRINT);
+  });
+
+  describe("appendExceptionScopeFilter", () => {
+    test("matches nothing without a project", () => {
+      const statement: Statement = SQL`SELECT 1 WHERE TRUE`;
+
+      TraceAggregationService.appendExceptionScopeFilter(statement, {
+        exceptionScope: { fingerprint: FINGERPRINT },
+      });
+
+      expect(normalized(statement)).toBe("SELECT 1 WHERE TRUE AND 0");
+    });
+
+    test("is a no-op without a scope", () => {
+      const statement: Statement = SQL`SELECT 1 WHERE TRUE`;
+
+      TraceAggregationService.appendExceptionScopeFilter(statement, {
+        projectId: PROJECT_ID,
+      });
+
+      expect(normalized(statement)).toBe("SELECT 1 WHERE TRUE");
+    });
+
+    test("binds every value as a parameter", () => {
+      const statement: Statement = SQL`SELECT 1 WHERE TRUE`;
+
+      TraceAggregationService.appendExceptionScopeFilter(statement, {
+        projectId: PROJECT_ID,
+        exceptionScope: {
+          fingerprint: "'); DROP TABLE Span; --",
+          primaryEntityId: SERVICE_ID,
+        },
+      });
+
+      expect(normalized(statement)).not.toContain("DROP TABLE");
+      expect(params(statement)).toContain("'); DROP TABLE Span; --");
+    });
+  });
+});