@oneuptime/common 13.0.4 → 13.0.6

package/Server/Utils/StartServer.ts

@@ -9,6 +9,7 @@ import {
 } from "../EnvironmentConfig";
 import LocalCache from "../Infrastructure/LocalCache";
 import HttpMetricsMiddleware from "../Middleware/HttpMetricsMiddleware";
+import TraceContextPropagation from "./Telemetry/TraceContextPropagation";
 import GzipRequestBodyMiddleware from "../Middleware/GzipRequestBody";
 import CorsOptions, {
   CORS_EXPOSED_HEADERS,
@@ -80,6 +81,15 @@ app.set("view engine", "ejs");
  * getClientIp() agree.
  */
 app.set("trust proxy", TrustedProxyHops);
+/*
+ * First middleware, so the SERVER span that continues the caller's trace is
+ * active for everything the request does — see TraceContextPropagation. The
+ * outgoing half is installed here too, because every OneUptime process that
+ * talks to another one starts through this module. Both are no-ops unless
+ * span export is configured.
+ */
+app.use(TraceContextPropagation.incomingRequestMiddleware);
+TraceContextPropagation.installOutgoingRequestTracer();
 app.use(CookieParser());
 
 export type BodyParserVerify = (

package/Server/Utils/StatusPage/MonitorRulePatternValidator.ts

@@ -1,46 +1,9 @@
-import BadDataException from "../../../Types/Exception/BadDataException";
-import RulePatternMatchUtil from "../../../Utils/Rules/RulePatternMatchUtil";
+import MonitorRulePatternValidator from "../Rules/MonitorRulePatternValidator";
 
 /*
- * Write-time validation for the monitor name / description patterns on status
- * page monitor rules.
- *
- * The rule engine accepts a case-insensitive regex or a '*' wildcard glob, the
- * same two syntaxes the network device rules take. Anything else - `api-(01`,
- * `[unclosed` - compiles to nothing and matches nothing, and the engine can
- * only log about it long after the user left the form. Reject it at the write
- * instead, exactly as NetworkDeviceRulePatternValidator does
- * (OneUptime/oneuptime#2940).
+ * Status page monitor rules validate their patterns with the validator every
+ * monitor rule shares (SLO monitor rules use the same one). This name is kept
+ * so existing imports keep resolving; the behaviour lives in
+ * Server/Utils/Rules/MonitorRulePatternValidator.
  */
-export default class StatusPageMonitorRulePatternValidator {
-  public static validate(data: {
-    namePattern?: string | null | undefined;
-    descriptionPattern?: string | null | undefined;
-  }): void {
-    StatusPageMonitorRulePatternValidator.validateOne(
-      "Monitor Name Pattern",
-      data.namePattern,
-    );
-    StatusPageMonitorRulePatternValidator.validateOne(
-      "Monitor Description Pattern",
-      data.descriptionPattern,
-    );
-  }
-
-  private static validateOne(
-    title: string,
-    pattern: string | null | undefined,
-  ): void {
-    if (!pattern) {
-      return;
-    }
-
-    if (RulePatternMatchUtil.isSupportedPattern(pattern)) {
-      return;
-    }
-
-    throw new BadDataException(
-      `${title} "${pattern}" is not a valid regular expression, and contains no '*' wildcard to fall back on, so it would never match a monitor. Use a regex such as api-.* or a wildcard such as *api*.`,
-    );
-  }
-}
+export default MonitorRulePatternValidator;

package/Server/Utils/StatusPageResource.ts

@@ -6,21 +6,66 @@ export interface GetResourcesGroupedByGroupNameOptions {
   defaultValue?: string;
 }
 
+// Groups go on their own line in HTML emails.
+export const HTML_RESOURCE_GROUP_SEPARATOR: string = "<br/>";
+
+/*
+ * SMS, Slack, Teams, email subjects and webhooks show "<br/>" as literal
+ * text, so they get every group on one line. The names inside a group are
+ * already comma-separated, which is why groups are split with a semicolon.
+ */
+export const PLAIN_TEXT_RESOURCE_GROUP_SEPARATOR: string = "; ";
+
 export default class StatusPageResourceUtil {
   /**
-   * Formats an array of StatusPageResource items into a string grouped by their resource group.
+   * Formats an array of StatusPageResource items into an HTML string grouped by their resource group.
    *
    * If resources have no group or only one resource exists without a group, returns a simple comma-separated list.
-   * If resources are grouped, returns a formatted string like:
-   * "EU: Infrastructure, Website; UK: Infrastructure, API"
+   * If resources are grouped, returns one group per line, like:
+   * "EU: Infrastructure, Website<br/>UK: Infrastructure, API"
+   *
+   * Use this only where the value is rendered as HTML (email bodies). Use
+   * getResourcesGroupedByGroupNameAsPlainText everywhere else.
    *
    * @param resources - Array of StatusPageResource items with displayName, statusPageGroupId, and optionally statusPageGroup.name
-   * @param defaultValue - Value to return if no resources (defaults to "None")
+   * @param defaultValue - Value to return if no resources (defaults to "")
    * @returns Formatted string of resources grouped by their resource group
    */
   public static getResourcesGroupedByGroupName(
     resources: Array<StatusPageResource>,
     defaultValue: string = "",
+  ): string {
+    return StatusPageResourceUtil.formatResourcesGroupedByGroupName(
+      resources,
+      defaultValue,
+      HTML_RESOURCE_GROUP_SEPARATOR,
+    );
+  }
+
+  /**
+   * The plain-text form of getResourcesGroupedByGroupName, for channels that
+   * do not render HTML. Grouped resources come back on one line, like:
+   * "EU: Infrastructure, Website; UK: Infrastructure, API"
+   *
+   * @param resources - Array of StatusPageResource items with displayName, statusPageGroupId, and optionally statusPageGroup.name
+   * @param defaultValue - Value to return if no resources (defaults to "")
+   * @returns Formatted string of resources grouped by their resource group
+   */
+  public static getResourcesGroupedByGroupNameAsPlainText(
+    resources: Array<StatusPageResource>,
+    defaultValue: string = "",
+  ): string {
+    return StatusPageResourceUtil.formatResourcesGroupedByGroupName(
+      resources,
+      defaultValue,
+      PLAIN_TEXT_RESOURCE_GROUP_SEPARATOR,
+    );
+  }
+
+  private static formatResourcesGroupedByGroupName(
+    resources: Array<StatusPageResource>,
+    defaultValue: string,
+    groupSeparator: string,
   ): string {
     if (!resources || resources.length === 0) {
       return defaultValue;
@@ -84,6 +129,6 @@ export default class StatusPageResourceUtil {
       }
     }
 
-    return formattedGroups.join("<br/>") || defaultValue;
+    return formattedGroups.join(groupSeparator) || defaultValue;
   }
 }

package/Server/Utils/Telemetry/EntityRegistry.ts

@@ -76,6 +76,14 @@ export const DEFAULT_ENTITY_BUDGET: ReadonlyMap<EntityType, number> = new Map<
   [EntityType.VMwareHost, 2000],
   [EntityType.VMwareVirtualMachine, 10000],
   [EntityType.VMwareDatastore, 2000],
+  /*
+   * Dependency endpoints inferred from client spans. One row per database /
+   * remote host a project's services call, so the realistic count is small;
+   * the budget exists for the pathological producer that puts a per-request
+   * hostname in `server.address`.
+   */
+  [EntityType.Database, 2000],
+  [EntityType.RemoteService, 2000],
 ]);
 
 // For types not in the map (future promotions of high-churn types).

package/Server/Utils/Telemetry/KubernetesResourceAttributes.ts

@@ -0,0 +1,108 @@
+import Dictionary from "../../../Types/Dictionary";
+
+/*
+ * Kubernetes identity for OneUptime's own telemetry.
+ *
+ * The Node SDK's resource detectors report `host.name`, which inside a pod is
+ * the pod's hostname. With nothing else on the resource, every OneUptime pod
+ * that ever ran was catalogued as a *host* — a self-hosted estate with a few
+ * dozen live pods showed hundreds of "hosts", most of them replaced by
+ * redeploys weeks earlier and all of them kept for the 30-day host TTL.
+ *
+ * Reporting the pod's Kubernetes identity fixes the classification at the
+ * source: the entity model then registers a pod (24h TTL) in its namespace,
+ * on its node, as a replica of its deployment, and retires the legacy host
+ * row the same observation proves wrong.
+ *
+ * Values come from the downward API environment the Helm chart sets
+ * (POD_NAME, POD_NAMESPACE, NODE_NAME, POD_UID) plus the workload / cluster
+ * names only the chart knows. When the chart variables are absent but the
+ * process is plainly in a pod (the API server env var every pod gets), the
+ * hostname and the service account namespace file stand in for them.
+ */
+
+/*
+ * Kubernetes generates ReplicaSet hashes and pod suffixes from this alphabet
+ * (no vowels, no 0/1/3), which is what makes a Deployment's pod name
+ * recognisable: `<deployment>-<6..10 hash>-<5 suffix>`.
+ */
+const K8S_NAME_ALPHABET: string = "[bcdfghjklmnpqrstvwxz2456789]";
+const DEPLOYMENT_POD_NAME_REGEX: RegExp = new RegExp(
+  `^(.+)-${K8S_NAME_ALPHABET}{6,10}-${K8S_NAME_ALPHABET}{5}$`,
+);
+
+export interface KubernetesResourceInput {
+  env: Dictionary<string | undefined>;
+  hostname: string;
+  /** Reads the pod's namespace from the mounted service account, or null. */
+  readServiceAccountNamespace: () => string | null;
+}
+
+function value(input: string | undefined | null): string | null {
+  const trimmed: string = (input || "").trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+/** `oneuptime-app-6d4f8b9c7d-x2k9p` → `oneuptime-app`; null if not that shape. */
+export function deploymentNameFromPodName(podName: string): string | null {
+  const match: RegExpMatchArray | null = podName.match(
+    DEPLOYMENT_POD_NAME_REGEX,
+  );
+  return match && match[1] ? match[1] : null;
+}
+
+export function getKubernetesResourceAttributes(
+  input: KubernetesResourceInput,
+): Dictionary<string> {
+  const env: Dictionary<string | undefined> = input.env;
+  const explicitPodName: string | null = value(env["POD_NAME"]);
+  const inKubernetes: boolean =
+    Boolean(explicitPodName) || Boolean(value(env["KUBERNETES_SERVICE_HOST"]));
+
+  if (!inKubernetes) {
+    return {};
+  }
+
+  const attributes: Dictionary<string> = {};
+
+  const podName: string | null = explicitPodName || value(input.hostname);
+  if (podName) {
+    attributes["k8s.pod.name"] = podName;
+  }
+
+  let namespace: string | null = value(env["POD_NAMESPACE"]);
+  if (!namespace) {
+    try {
+      namespace = value(input.readServiceAccountNamespace());
+    } catch {
+      namespace = null;
+    }
+  }
+  if (namespace) {
+    attributes["k8s.namespace.name"] = namespace;
+  }
+
+  const nodeName: string | null = value(env["NODE_NAME"]);
+  if (nodeName) {
+    attributes["k8s.node.name"] = nodeName;
+  }
+
+  const podUid: string | null = value(env["POD_UID"]);
+  if (podUid) {
+    attributes["k8s.pod.uid"] = podUid;
+  }
+
+  const deploymentName: string | null =
+    value(env["K8S_DEPLOYMENT_NAME"]) ||
+    (podName ? deploymentNameFromPodName(podName) : null);
+  if (deploymentName) {
+    attributes["k8s.deployment.name"] = deploymentName;
+  }
+
+  const clusterName: string | null = value(env["K8S_CLUSTER_NAME"]);
+  if (clusterName) {
+    attributes["k8s.cluster.name"] = clusterName;
+  }
+
+  return attributes;
+}

package/Server/Utils/Telemetry/ResourceEntityFilter.ts

@@ -1,17 +1,24 @@
 import ObjectID from "../../../Types/ObjectID";
 import PositiveNumber from "../../../Types/PositiveNumber";
 import { JSONObject } from "../../../Types/JSON";
-import HostModel from "../../../Models/DatabaseModels/Host";
-import DockerHostModel from "../../../Models/DatabaseModels/DockerHost";
-import PodmanHostModel from "../../../Models/DatabaseModels/PodmanHost";
-import KubernetesClusterModel from "../../../Models/DatabaseModels/KubernetesCluster";
 import HostService from "../../Services/HostService";
 import DockerHostService from "../../Services/DockerHostService";
 import PodmanHostService from "../../Services/PodmanHostService";
 import KubernetesClusterService from "../../Services/KubernetesClusterService";
+import DockerSwarmClusterService from "../../Services/DockerSwarmClusterService";
+import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
+import VMwareVCenterService from "../../Services/VMwareVCenterService";
+import CephClusterService from "../../Services/CephClusterService";
+import ServerlessFunctionService from "../../Services/ServerlessFunctionService";
+import IoTFleetService from "../../Services/IoTFleetService";
+import FindBy from "../../Types/Database/FindBy";
 import {
+  keyForCephCluster,
+  keyForDockerSwarmCluster,
   keyForHost,
   keyForKubernetesCluster,
+  keyForProxmoxCluster,
+  keyForVMwareVCenter,
 } from "../../../Utils/Telemetry/EntityKey";
 import {
   ResourceEntityFacetSelections,
@@ -35,7 +42,9 @@ import CaptureSpan from "./CaptureSpan";
  *                     matches rows written before `entityKeys` existed.
  *  - `entityKeys`  -> `hasAny(entityKeys, [...])`. The general membership
  *                     read: OTLP telemetry primary-keyed on its Service
- *                     still carries the host / cluster key here.
+ *                     still carries the host / cluster key here. Empty for
+ *                     resource types no OTLP resource declares as an
+ *                     entity (Serverless function, IoT fleet).
  *  - `attribute*`  -> `attributes['resource.<attr>'] IN (...)`. The
  *                     pre-`entityKeys` fallback, mirroring the entityScope
  *                     contract the resource detail pages already use, so
@@ -52,14 +61,56 @@ export interface ResourceEntityScope {
 interface ResourceFacetDefinition {
   /** Signal attribute the identifying value is stamped under. */
   attributeKey: string;
-  /** Read-side entity-key helper, mirroring the ingest-side resolver. */
-  entityKeyFor: (projectId: string, identifier: string) => string;
+  /**
+   * Read-side entity-key helper, mirroring the ingest-side resolver. Absent
+   * for resource types that never reach a signal's `entityKeys` — the scope
+   * then matches on the id and the attribute only.
+   */
+  entityKeyFor?:
+    | ((projectId: string, identifier: string) => string)
+    | undefined;
   findIdentifiers: (data: {
     projectId: ObjectID;
     ids: Array<ObjectID>;
   }) => Promise<Array<string>>;
 }
 
+/*
+ * Only `findBy` is used, called through the service instance at lookup
+ * time so a mocked or spied service is honoured.
+ */
+interface IdentifierLookupService {
+  findBy: (findBy: FindBy<any>) => Promise<Array<any>>;
+}
+
+/*
+ * The project-scoped `id -> identifying column` lookup every definition
+ * shares. Scoping by `projectId` is load-bearing: an id from another tenant
+ * must resolve to nothing, never to that tenant's identifier.
+ */
+function findIdentifierColumn(
+  service: IdentifierLookupService,
+  column: string,
+): ResourceFacetDefinition["findIdentifiers"] {
+  return async (data: {
+    projectId: ObjectID;
+    ids: Array<ObjectID>;
+  }): Promise<Array<string>> => {
+    const rows: Array<Record<string, unknown>> = await service.findBy({
+      query: { projectId: data.projectId, _id: new Includes(data.ids) },
+      select: { [column]: true },
+      limit: new PositiveNumber(data.ids.length),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return rows.map((row: Record<string, unknown>): string => {
+      const value: unknown = row[column];
+      return typeof value === "string" ? value : "";
+    });
+  };
+}
+
 /*
  * `Host` / `DockerHost` / `PodmanHost` all key on the canonicalized
  * `host.name` (see `HostService.findOrCreateByHostIdentifier` and its
@@ -78,90 +129,114 @@ interface ResourceFacetDefinition {
  * honest reading — and it is the only identity an OTLP resource carries;
  * DockerHost / PodmanHost are inventory-mirrored types that no resource
  * ever declares (see EntityType).
+ *
+ * Docker Swarm / Proxmox / vCenter / Ceph clusters are root entities whose
+ * identity is their name alone (`<type>.name`, see the root identities in
+ * Utils/Telemetry/TelemetryEntity.ts), and
+ * that name is the Postgres row's `name` — the join key ingest writes with
+ * `findOrCreateByName`. Keys canonicalize (trim + lowercase) on both sides,
+ * so a row whose casing differs from the stamped attribute still matches
+ * through `entityKeys`; the attribute branch is an exact match. Docker
+ * Swarm leans on the entity-key branch most: a swarm cluster is rarely the
+ * primary entity (a container's synthesized service, or the Docker host,
+ * wins first).
+ *
+ * Serverless functions and IoT fleets have a resource attribute but no
+ * signal entity key (inventory-mirrored / no entity type at all), so they
+ * get the id + attribute branches only — the same `resource.faas.name` /
+ * `resource.iot.fleet.name` scope their detail pages use. The function
+ * identifier is `faas.name` (or `service.name` on a FaaS platform without
+ * one, which the attribute branch then simply does not match).
+ *
+ * Cloud resources and RUM applications intentionally have NO definition,
+ * so their selection stays `primaryEntityId IN (...)`:
+ *   - RUM telemetry is always primary-keyed on its application
+ *     (`getServiceNameFromAttributes` returns no service for RUM clients),
+ *     so the id already selects every row.
+ *   - A cloud resource's telemetry scope is a multi-attribute match
+ *     (platform + account + region, see CloudResourceTelemetryScope) that
+ *     the single-attribute branch cannot express; a partial match would
+ *     select other resources' rows.
+ * Id-only also keeps those selections consistent with their facet counts,
+ * which are `primaryEntityId`-based.
+ *
+ * Built on first use rather than at module load: the services pull in much
+ * of the server, and a module cycle that reached this file first would
+ * otherwise hand the table an `undefined` service — which the best-effort
+ * lookup below would silently turn into an id-only filter.
  */
-const FACET_DEFINITIONS: Record<string, ResourceFacetDefinition> = {
-  hostId: {
-    attributeKey: "resource.host.name",
-    entityKeyFor: keyForHost,
-    findIdentifiers: async (data: {
-      projectId: ObjectID;
-      ids: Array<ObjectID>;
-    }): Promise<Array<string>> => {
-      const rows: Array<HostModel> = await HostService.findBy({
-        query: { projectId: data.projectId, _id: new Includes(data.ids) },
-        select: { hostIdentifier: true },
-        limit: new PositiveNumber(data.ids.length),
-        skip: new PositiveNumber(0),
-        props: { isRoot: true },
-      });
+let facetDefinitions: Record<string, ResourceFacetDefinition> | null = null;
 
-      return rows.map((row: HostModel): string => {
-        return row.hostIdentifier || "";
-      });
-    },
-  },
-  dockerHostId: {
-    attributeKey: "resource.host.name",
-    entityKeyFor: keyForHost,
-    findIdentifiers: async (data: {
-      projectId: ObjectID;
-      ids: Array<ObjectID>;
-    }): Promise<Array<string>> => {
-      const rows: Array<DockerHostModel> = await DockerHostService.findBy({
-        query: { projectId: data.projectId, _id: new Includes(data.ids) },
-        select: { hostIdentifier: true },
-        limit: new PositiveNumber(data.ids.length),
-        skip: new PositiveNumber(0),
-        props: { isRoot: true },
-      });
+function getFacetDefinitions(): Record<string, ResourceFacetDefinition> {
+  if (facetDefinitions) {
+    return facetDefinitions;
+  }
 
-      return rows.map((row: DockerHostModel): string => {
-        return row.hostIdentifier || "";
-      });
+  facetDefinitions = {
+    hostId: {
+      attributeKey: "resource.host.name",
+      entityKeyFor: keyForHost,
+      findIdentifiers: findIdentifierColumn(HostService, "hostIdentifier"),
     },
-  },
-  podmanHostId: {
-    attributeKey: "resource.host.name",
-    entityKeyFor: keyForHost,
-    findIdentifiers: async (data: {
-      projectId: ObjectID;
-      ids: Array<ObjectID>;
-    }): Promise<Array<string>> => {
-      const rows: Array<PodmanHostModel> = await PodmanHostService.findBy({
-        query: { projectId: data.projectId, _id: new Includes(data.ids) },
-        select: { hostIdentifier: true },
-        limit: new PositiveNumber(data.ids.length),
-        skip: new PositiveNumber(0),
-        props: { isRoot: true },
-      });
-
-      return rows.map((row: PodmanHostModel): string => {
-        return row.hostIdentifier || "";
-      });
+    dockerHostId: {
+      attributeKey: "resource.host.name",
+      entityKeyFor: keyForHost,
+      findIdentifiers: findIdentifierColumn(
+        DockerHostService,
+        "hostIdentifier",
+      ),
     },
-  },
-  kubernetesClusterId: {
-    attributeKey: "resource.k8s.cluster.name",
-    entityKeyFor: keyForKubernetesCluster,
-    findIdentifiers: async (data: {
-      projectId: ObjectID;
-      ids: Array<ObjectID>;
-    }): Promise<Array<string>> => {
-      const rows: Array<KubernetesClusterModel> =
-        await KubernetesClusterService.findBy({
-          query: { projectId: data.projectId, _id: new Includes(data.ids) },
-          select: { clusterIdentifier: true },
-          limit: new PositiveNumber(data.ids.length),
-          skip: new PositiveNumber(0),
-          props: { isRoot: true },
-        });
-
-      return rows.map((row: KubernetesClusterModel): string => {
-        return row.clusterIdentifier || "";
-      });
+    podmanHostId: {
+      attributeKey: "resource.host.name",
+      entityKeyFor: keyForHost,
+      findIdentifiers: findIdentifierColumn(
+        PodmanHostService,
+        "hostIdentifier",
+      ),
+    },
+    kubernetesClusterId: {
+      attributeKey: "resource.k8s.cluster.name",
+      entityKeyFor: keyForKubernetesCluster,
+      findIdentifiers: findIdentifierColumn(
+        KubernetesClusterService,
+        "clusterIdentifier",
+      ),
+    },
+    dockerSwarmClusterId: {
+      attributeKey: "resource.docker.swarm.cluster.name",
+      entityKeyFor: keyForDockerSwarmCluster,
+      findIdentifiers: findIdentifierColumn(DockerSwarmClusterService, "name"),
+    },
+    proxmoxClusterId: {
+      attributeKey: "resource.proxmox.cluster.name",
+      entityKeyFor: keyForProxmoxCluster,
+      findIdentifiers: findIdentifierColumn(ProxmoxClusterService, "name"),
+    },
+    vmwareVCenterId: {
+      attributeKey: "resource.vmware.vcenter.name",
+      entityKeyFor: keyForVMwareVCenter,
+      findIdentifiers: findIdentifierColumn(VMwareVCenterService, "name"),
+    },
+    cephClusterId: {
+      attributeKey: "resource.ceph.cluster.name",
+      entityKeyFor: keyForCephCluster,
+      findIdentifiers: findIdentifierColumn(CephClusterService, "name"),
     },
-  },
-};
+    serverlessFunctionId: {
+      attributeKey: "resource.faas.name",
+      findIdentifiers: findIdentifierColumn(
+        ServerlessFunctionService,
+        "functionIdentifier",
+      ),
+    },
+    iotFleetId: {
+      attributeKey: "resource.iot.fleet.name",
+      findIdentifiers: findIdentifierColumn(IoTFleetService, "name"),
+    },
+  };
+
+  return facetDefinitions;
+}
 
 /**
  * Append the resolved resource scopes to a hand-written aggregation
@@ -390,7 +465,7 @@ export default class ResourceEntityFilter {
     };
 
     const definition: ResourceFacetDefinition | undefined =
-      FACET_DEFINITIONS[data.facetKey];
+      getFacetDefinitions()[data.facetKey];
 
     if (!definition) {
       return scope;
@@ -425,14 +500,20 @@ export default class ResourceEntityFilter {
     }
 
     const projectIdString: string = data.projectId.toString();
+    const entityKeyFor:
+      | ((projectId: string, identifier: string) => string)
+      | undefined = definition.entityKeyFor;
+
+    if (entityKeyFor) {
+      scope.entityKeys = Array.from(
+        new Set(
+          uniqueIdentifiers.map((identifier: string): string => {
+            return entityKeyFor(projectIdString, identifier);
+          }),
+        ),
+      );
+    }
 
-    scope.entityKeys = Array.from(
-      new Set(
-        uniqueIdentifiers.map((identifier: string): string => {
-          return definition.entityKeyFor(projectIdString, identifier);
-        }),
-      ),
-    );
     scope.attributeKey = definition.attributeKey;
     scope.attributeValues = uniqueIdentifiers;