@oneuptime/common 12.0.34 → 13.0.1

package/Tests/Server/Utils/Telemetry/TelemetryEntity.test.ts

@@ -12,6 +12,7 @@ import {
   keyForKubernetesCluster,
   keyForProxmoxCluster,
   keyForCephCluster,
+  keyForVMwareVCenter,
 } from "../../../../Utils/Telemetry/EntityKey";
 import logger from "../../../../Server/Utils/Logger";
 import { describe, expect, test } from "@jest/globals";
@@ -395,6 +396,324 @@ describe("InventoryItem.extractEntities — per type", () => {
     expect(afterMigration!.entityKey).toBe(beforeMigration!.entityKey);
   });
 
+  test("vmware.vcenter: keyed on vmware.vcenter.name", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      { "vmware.vcenter.name": "vcsa-prod" },
+      EntityType.VMwareVCenter,
+    );
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+    });
+    expect(e!.entityKey).toBe(
+      expectedKey(PROJECT, EntityType.VMwareVCenter, {
+        "vmware.vcenter.name": "vcsa-prod",
+      }),
+    );
+  });
+
+  test("vmware: nothing resolves without the agent-stamped vmware.vcenter.name", () => {
+    /*
+     * The vcenter receiver's own attributes never say which vCenter they
+     * came from, so a resource missing the agent-stamped root attribute
+     * must resolve to NO VMware entity — a vCenter-less key would collide
+     * across every vCenter in the project that has a cluster called "Prod".
+     */
+    expect(
+      typesFor({
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+        "vcenter.datastore.name": "vsanDatastore",
+      }),
+    ).toEqual([]);
+  });
+
+  test("vmware: descriptive-only attributes yield no vmware entities", () => {
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.name": "web-01",
+        "vcenter.resource_pool.name": "Resources",
+      }),
+    ).toEqual([EntityType.VMwareVCenter]);
+    expect(typesFor({ "vcenter.vm.name": "web-01" })).toEqual([]);
+  });
+
+  test("vmware.cluster: composes vcenter + datacenter + cluster identity", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+      },
+      EntityType.VMwareCluster,
+    );
+    // Identity values are canonicalized (trimmed + lowercased) like every type.
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "dc1",
+      "vcenter.cluster.name": "prod",
+    });
+    expect(e!.entityKey).toBe(
+      expectedKey(PROJECT, EntityType.VMwareCluster, {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+      }),
+    );
+  });
+
+  test("vmware.cluster / host / datastore require the datacenter (part of identity)", () => {
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.cluster.name": "Prod",
+      }),
+    ).toEqual([EntityType.VMwareVCenter]);
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.host.name": "esxi-01.example.com",
+      }),
+    ).toEqual([EntityType.VMwareVCenter]);
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datastore.name": "vsanDatastore",
+      }),
+    ).toEqual([EntityType.VMwareVCenter]);
+  });
+
+  test("vmware.host: composes vcenter + datacenter + host identity", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "dc1",
+      "vcenter.host.name": "esxi-01.example.com",
+    });
+  });
+
+  test("vmware.host: cluster is not identity (moving a host between clusters keeps the key)", () => {
+    const inClusterA: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    const inClusterB: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Staging",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    const standalone: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    expect(inClusterB!.entityKey).toBe(inClusterA!.entityKey);
+    expect(standalone!.entityKey).toBe(inClusterA!.entityKey);
+    expect(inClusterA!.identifyingAttributes).not.toHaveProperty(
+      "vcenter.cluster.name",
+    );
+  });
+
+  test("vmware.vm: keyed on vcenter + vcenter.vm.id (instance UUID), never the name", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+    });
+    expect(e!.entityKey).toBe(
+      expectedKey(PROJECT, EntityType.VMwareVirtualMachine, {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      }),
+    );
+  });
+
+  test("vmware.vm: host name is not identity (vMotion keeps the key)", () => {
+    const beforeVMotion: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    const afterVMotion: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-02.example.com",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(afterVMotion!.entityKey).toBe(beforeVMotion!.entityKey);
+  });
+
+  test("vmware.vm: renaming the VM keeps the key", () => {
+    const before: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    const after: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.name": "web-01-renamed",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(after!.entityKey).toBe(before!.entityKey);
+  });
+
+  test("vmware.vm: a template is a VM keyed on vcenter.vm_template.id; converting keeps the key", () => {
+    const template: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm_template.name": "ubuntu-22.04-golden",
+        "vcenter.vm_template.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(template).toBeDefined();
+    expect(template!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+    });
+
+    // Convert-to-template keeps the instance UUID, so the key survives.
+    const asVm: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.name": "ubuntu-22.04-golden",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(asVm!.entityKey).toBe(template!.entityKey);
+
+    // A template resource yields exactly one VM entity, not two.
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm_template.id": "5029abcd-1234-5678-9abc-def012345678",
+      }).filter((t: EntityType) => {
+        return t === EntityType.VMwareVirtualMachine;
+      }),
+    ).toHaveLength(1);
+  });
+
+  test("vmware.vm: vcenter.vm.id wins when both id attributes are present", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.id": "id-vm",
+        "vcenter.vm_template.id": "id-template",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.vm.id": "id-vm",
+    });
+  });
+
+  test("vmware.vm: falls back to nothing when only a name is present (no id → no entity)", () => {
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.name": "web-01",
+      }),
+    ).not.toContain(EntityType.VMwareVirtualMachine);
+  });
+
+  test("vmware.datastore: composes vcenter + datacenter + datastore identity", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.datastore.name": "vsanDatastore",
+      },
+      EntityType.VMwareDatastore,
+    );
+    expect(e!.identifyingAttributes).toEqual({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "dc1",
+      "vcenter.datastore.name": "vsandatastore",
+    });
+    expect(e!.entityKey).toBe(
+      expectedKey(PROJECT, EntityType.VMwareDatastore, {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.datastore.name": "vsanDatastore",
+      }),
+    );
+  });
+
+  test("vmware: every child identity spreads the vcenter identity", () => {
+    const attrs: EntityAttributes = {
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.cluster.name": "Prod",
+      "vcenter.host.name": "esxi-01.example.com",
+      "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      "vcenter.datastore.name": "vsanDatastore",
+    };
+    for (const type of [
+      EntityType.VMwareCluster,
+      EntityType.VMwareHost,
+      EntityType.VMwareVirtualMachine,
+      EntityType.VMwareDatastore,
+    ]) {
+      const e: ExtractedEntity | undefined = entityOfType(attrs, type);
+      expect(e).toBeDefined();
+      expect(e!.identifyingAttributes["vmware.vcenter.name"]).toBe("vcsa-prod");
+    }
+  });
+
   test("ceph.cluster: keyed on name only, ignoring fsid (read side is name-based)", () => {
     const e: ExtractedEntity | undefined = entityOfType(
       { "ceph.cluster.fsid": "f-1", "ceph.cluster.name": "ceph-prod" },
@@ -501,6 +820,77 @@ describe("InventoryItem.extractEntities — composition & safety", () => {
     );
   });
 
+  test("a full vmware VM resource yields vcenter + cluster + host + vm", () => {
+    // The vcenter receiver's resource for a VM inside a cluster.
+    const types: Array<EntityType> = typesFor({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.cluster.name": "Prod",
+      "vcenter.host.name": "esxi-01.example.com",
+      "vcenter.vm.name": "web-01",
+      "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      "vcenter.resource_pool.name": "Resources",
+      "vcenter.resource_pool.inventory_path": "/DC1/host/Prod/Resources",
+    });
+    expect(new Set(types)).toEqual(
+      new Set([
+        EntityType.VMwareVCenter,
+        EntityType.VMwareCluster,
+        EntityType.VMwareHost,
+        EntityType.VMwareVirtualMachine,
+      ]),
+    );
+  });
+
+  test("a vmware VM resource on a standalone host yields no cluster entity", () => {
+    const types: Array<EntityType> = typesFor({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.host.name": "esxi-01.example.com",
+      "vcenter.vm.name": "web-01",
+      "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+    });
+    expect(new Set(types)).toEqual(
+      new Set([
+        EntityType.VMwareVCenter,
+        EntityType.VMwareHost,
+        EntityType.VMwareVirtualMachine,
+      ]),
+    );
+  });
+
+  test("a vmware datastore resource yields vcenter + datastore only", () => {
+    const types: Array<EntityType> = typesFor({
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.datastore.name": "vsanDatastore",
+    });
+    expect(new Set(types)).toEqual(
+      new Set([EntityType.VMwareVCenter, EntityType.VMwareDatastore]),
+    );
+  });
+
+  test("vmware datacenter / resource pool resources yield only the vcenter entity", () => {
+    // Datacenters and resource pools are inventory rows, not entities.
+    expect(
+      typesFor({
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+      }),
+    ).toEqual([EntityType.VMwareVCenter]);
+    expect(
+      new Set(
+        typesFor({
+          "vmware.vcenter.name": "vcsa-prod",
+          "vcenter.datacenter.name": "DC1",
+          "vcenter.cluster.name": "Prod",
+          "vcenter.resource_pool.name": "Resources",
+          "vcenter.resource_pool.inventory_path": "/DC1/host/Prod/Resources",
+        }),
+      ),
+    ).toEqual(new Set([EntityType.VMwareVCenter, EntityType.VMwareCluster]));
+  });
+
   test("extractEntityKeys is sorted, deduped, and a superset of the primary", () => {
     const attrs: EntityAttributes = {
       "service.name": "checkout",
@@ -559,6 +949,66 @@ describe("InventoryItem.extractEntities — composition & safety", () => {
     });
     expect(clusterA).not.toBe(clusterB);
   });
+
+  test("same cluster name in two vcenters does not collide", () => {
+    const a: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-us",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+      },
+      EntityType.VMwareCluster,
+    );
+    const b: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-eu",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+      },
+      EntityType.VMwareCluster,
+    );
+    expect(a!.entityKey).not.toBe(b!.entityKey);
+  });
+
+  test("same cluster name in two datacenters of one vcenter does not collide", () => {
+    const a: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+      },
+      EntityType.VMwareCluster,
+    );
+    const b: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC2",
+        "vcenter.cluster.name": "Prod",
+      },
+      EntityType.VMwareCluster,
+    );
+    expect(a!.entityKey).not.toBe(b!.entityKey);
+  });
+
+  test("same VM instance UUID in two vcenters does not collide", () => {
+    const a: string = InventoryItem.computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.VMwareVirtualMachine,
+      identifyingAttributes: {
+        "vmware.vcenter.name": "vcsa-us",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+    });
+    const b: string = InventoryItem.computeEntityKey({
+      projectId: PROJECT,
+      entityType: EntityType.VMwareVirtualMachine,
+      identifyingAttributes: {
+        "vmware.vcenter.name": "vcsa-eu",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+    });
+    expect(a).not.toBe(b);
+  });
 });
 
 describe("read-side keyFor* helpers match ingest-side extraction", () => {
@@ -643,6 +1093,41 @@ describe("read-side keyFor* helpers match ingest-side extraction", () => {
     );
   });
 
+  test("keyForVMwareVCenter matches the vcenter entity stamped from vmware.vcenter.name", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      { "vmware.vcenter.name": "vcsa-prod" },
+      EntityType.VMwareVCenter,
+    );
+    expect(stamped).toBeDefined();
+    expect(keyForVMwareVCenter(PROJECT, "vcsa-prod")).toBe(stamped!.entityKey);
+  });
+
+  test("keyForVMwareVCenter canonicalizes casing/whitespace like ingest", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      { "vmware.vcenter.name": "VCSA-Prod" },
+      EntityType.VMwareVCenter,
+    );
+    expect(keyForVMwareVCenter(PROJECT, "vcsa-prod")).toBe(stamped!.entityKey);
+    expect(keyForVMwareVCenter(PROJECT, "  VCSA-PROD ")).toBe(
+      stamped!.entityKey,
+    );
+  });
+
+  test("keyForVMwareVCenter still matches when the resource carries vcenter.* child attributes", () => {
+    // The vcenter entity is name-only; child attributes must not leak in.
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVCenter,
+    );
+    expect(keyForVMwareVCenter(PROJECT, "vcsa-prod")).toBe(stamped!.entityKey);
+  });
+
   test("keyForCephCluster matches the cluster entity stamped from ceph.cluster.name", () => {
     const stamped: ExtractedEntity | undefined = entityOfType(
       { "ceph.cluster.name": "ceph-prod" },
@@ -750,7 +1235,7 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
       name: "worker-1",
     },
   ])(
-    "k8s.$label: keeps the stable UID identity and carries the name descriptively",
+    "k8s.$label: keys on the name and carries the UID descriptively",
     ({
       type,
       uidKey,
@@ -765,19 +1250,122 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
       nameKey: string;
       name: string;
     }) => {
-      const uidOnly: ExtractedEntity | undefined = entityOfType(
-        { [uidKey]: uid },
-        type,
-      );
       const named: ExtractedEntity | undefined = entityOfType(
         { [uidKey]: uid, [nameKey]: name },
         type,
       );
 
       expect(named).toBeDefined();
-      expect(named!.entityKey).toBe(uidOnly!.entityKey);
-      expect(named!.identifyingAttributes).toEqual({ [uidKey]: uid });
-      expect(named!.descriptiveAttributes).toEqual({ [nameKey]: name });
+      expect(named!.identifyingAttributes).toEqual({ [nameKey]: name });
+      /*
+       * The name is carried descriptively as well as identifying it. That is
+       * deliberate: `buildDescriptiveUpdate` reads the display name out of
+       * the descriptive bag first, so a row whose identity later changes
+       * shape still has a name to show.
+       */
+      expect(named!.descriptiveAttributes).toEqual({
+        [nameKey]: name,
+        [uidKey]: uid,
+      });
+    },
+  );
+
+  /*
+   * The regression test for duplicate Inventory rows.
+   *
+   * The shipped Kubernetes agent runs two collectors over the same nodes and
+   * pods. The Deployment's `k8s_cluster` receiver resolves uids; the
+   * DaemonSet's kubeletstats / hostmetrics / cAdvisor / filelog receivers
+   * never do. Identity must not depend on which of them is talking.
+   */
+  test.each([
+    {
+      label: "node",
+      type: EntityType.KubernetesNode,
+      withUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.node.name": "worker-1",
+        "k8s.node.uid": "node-uid-1",
+      },
+      withoutUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.node.name": "worker-1",
+      },
+    },
+    {
+      label: "pod",
+      type: EntityType.KubernetesPod,
+      withUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-7d9f",
+        "k8s.pod.uid": "pod-uid-1",
+      },
+      withoutUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-7d9f",
+      },
+    },
+  ])(
+    "k8s.$label: a producer that resolves the UID and one that does not agree on identity",
+    ({
+      type,
+      withUid,
+      withoutUid,
+    }: {
+      label: string;
+      type: EntityType;
+      withUid: EntityAttributes;
+      withoutUid: EntityAttributes;
+    }) => {
+      const resolved: ExtractedEntity | undefined = entityOfType(withUid, type);
+      const unresolved: ExtractedEntity | undefined = entityOfType(
+        withoutUid,
+        type,
+      );
+
+      expect(resolved).toBeDefined();
+      expect(unresolved).toBeDefined();
+      expect(resolved!.entityKey).toBe(unresolved!.entityKey);
+      expect(resolved!.identifyingAttributes).toEqual(
+        unresolved!.identifyingAttributes,
+      );
+    },
+  );
+
+  test.each([
+    {
+      label: "node",
+      type: EntityType.KubernetesNode,
+      uidKey: "k8s.node.uid",
+      uid: "node-uid-1",
+    },
+    {
+      label: "pod",
+      type: EntityType.KubernetesPod,
+      uidKey: "k8s.pod.uid",
+      uid: "pod-uid-1",
+    },
+  ])(
+    "k8s.$label: falls back to the UID when the resource carries no name",
+    ({
+      type,
+      uidKey,
+      uid,
+    }: {
+      label: string;
+      type: EntityType;
+      uidKey: string;
+      uid: string;
+    }) => {
+      const entity: ExtractedEntity | undefined = entityOfType(
+        { [uidKey]: uid },
+        type,
+      );
+
+      expect(entity).toBeDefined();
+      expect(entity!.identifyingAttributes).toEqual({ [uidKey]: uid });
     },
   );
 
@@ -823,6 +1411,101 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
     expect(bare!.descriptiveAttributes).toBeUndefined();
   });
 
+  test("vmware.vm: name/host/cluster/pool descriptive attributes are emitted, key unchanged", () => {
+    const bare: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    const decorated: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm.name": "web-01",
+        "vcenter.vm.id": "5029abcd-1234-5678-9abc-def012345678",
+        "vcenter.resource_pool.name": "Resources",
+        "vcenter.resource_pool.inventory_path": "/DC1/host/Prod/Resources",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+
+    expect(decorated!.entityKey).toBe(bare!.entityKey);
+    expect(decorated!.identifyingAttributes).toEqual(
+      bare!.identifyingAttributes,
+    );
+    expect(decorated!.descriptiveAttributes).toEqual({
+      "vcenter.vm.name": "web-01",
+      "vcenter.host.name": "esxi-01.example.com",
+      "vcenter.cluster.name": "Prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.resource_pool.name": "Resources",
+    });
+    expect(bare!.descriptiveAttributes).toBeUndefined();
+  });
+
+  test("vmware.vm: a template carries its template name as descriptive metadata", () => {
+    const e: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+        "vcenter.vm_template.name": "ubuntu-22.04-golden",
+        "vcenter.vm_template.id": "5029abcd-1234-5678-9abc-def012345678",
+      },
+      EntityType.VMwareVirtualMachine,
+    );
+    expect(e!.descriptiveAttributes).toEqual({
+      "vcenter.vm_template.name": "ubuntu-22.04-golden",
+      "vcenter.host.name": "esxi-01.example.com",
+      "vcenter.datacenter.name": "DC1",
+    });
+  });
+
+  test("vmware.host: cluster descriptive when present, key unchanged", () => {
+    const bare: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    const decorated: ExtractedEntity | undefined = entityOfType(
+      {
+        "vmware.vcenter.name": "vcsa-prod",
+        "vcenter.datacenter.name": "DC1",
+        "vcenter.cluster.name": "Prod",
+        "vcenter.host.name": "esxi-01.example.com",
+      },
+      EntityType.VMwareHost,
+    );
+    expect(decorated!.entityKey).toBe(bare!.entityKey);
+    expect(decorated!.descriptiveAttributes).toEqual({
+      "vcenter.cluster.name": "Prod",
+    });
+    expect(bare!.descriptiveAttributes).toBeUndefined();
+  });
+
+  test("vmware.vcenter / cluster / datastore emit no descriptive attributes", () => {
+    const attrs: EntityAttributes = {
+      "vmware.vcenter.name": "vcsa-prod",
+      "vcenter.datacenter.name": "DC1",
+      "vcenter.cluster.name": "Prod",
+      "vcenter.datastore.name": "vsanDatastore",
+    };
+    for (const type of [
+      EntityType.VMwareVCenter,
+      EntityType.VMwareCluster,
+      EntityType.VMwareDatastore,
+    ]) {
+      expect(entityOfType(attrs, type)!.descriptiveAttributes).toBeUndefined();
+    }
+  });
+
   test("ceph.cluster: fsid descriptive when present, key unchanged", () => {
     const bare: ExtractedEntity | undefined = entityOfType(
       { "ceph.cluster.name": "ceph-prod" },