[nutanix] Warn and skip entities missing extId or name (DataDog#23612)

* fix(nutanix): normalize all ntnx_* tags to lowercase with $unknown fallback

Route every enum-backed ntnx_* tag (host_type, hypervisor_type,
node_status, plus the previously-handled state tags) through a single
_norm_state helper so they all follow one rule: lowercase the API
value, fall back to "\$unknown" when the source is missing.

Picks "\$unknown" (the API spec's own sentinel) as the fallback so
there's no mismatch between "value present but says \$UNKNOWN" and
"value missing" — both surface as ntnx_X:\$unknown.

ntnx_disk_status's "unknown" fallback is updated to "\$unknown" for
the same reason.

* docs(nutanix): add changelog for tag normalization

* docs(nutanix): shorten changelog to one customer-facing line

* refactor(nutanix): extract tag values into named variables

Hoist _norm_state and get_nested calls out of f-strings in the
tag-extraction helpers. Each tag computation now binds to a named
local first, making the read top-down and easier to step through.

* refactor(nutanix): rename _norm_state to _normalize_tag_value

The helper is used for type, state, mode, and status tags — not just
state — so the broader name better describes what it does.

* refactor(nutanix): collapse node_status to one variable, restore tags = []

Lowercase the node-status comparison sets so the normalized tag value
serves both the status_value lookup and the tag emission, removing the
need for a separate node_status_tag local.

Restore the tags = [] preamble in the tag-extraction helpers since it
makes the building intent obvious.

* fix(nutanix): normalize powerState in vm.status gauge

Match what _report_host_status_metrics does: route the powerState
lookup through _normalize_tag_value and lowercase the comparison
literals. Removes the asymmetry where vm.status was the only metric
still relying on raw uppercase API values.

Addresses review feedback on PR DataDog#23609.

* fix(nutanix): warn and skip entities missing the main id or name

Hosts now warn-and-skip when hostName is missing (previously they
emitted metrics with hostname=None, useless for correlation), VMs
upgrade their existing missing-id/name skip from debug to warning,
and clusters now warn-and-skip when name is missing (previously they
were processed with no ntnx_cluster_name tag and weren't cached for
VM/host cluster-name tagging).

* docs(nutanix): add changelog for entity-validation skip

* docs(nutanix): shorten changelog to one customer-facing line

* refactor(nutanix): rename VM hostname locals/params to vm_name

The variable was named after how it's consumed downstream (the
hostname= kwarg to gauge calls), not what it actually is — the VM's
"name" field from the API. Rename to vm_name for symmetry with
host_name on the host side; the gauge call still passes it as
hostname=vm_name.

* refactor(nutanix): hoist cluster log label to a variable

* Delete nutanix/changelog.d/23609.fixed

* Keep collecting VMs for unnamed hosts

* test(nutanix): add tests for skip behavior on missing entity fields

Cover the three new skip paths added in this PR:
- VM missing extId: verify vm_count decrements and metric absent
- VM missing name: same invariant
- Cluster missing name: verify cluster_count unchanged and warning logged

Each VM test is parametrized for both batch and non-batch collection modes.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: NouemanKHAL

nutanix/changelog.d/23612.fixed

@@ -0,0 +1 @@
+Skip hosts, VMs, and clusters missing an `extId` or name, and log a warning.

nutanix/datadog_checks/nutanix/infrastructure_monitor.py

@@ -152,10 +152,12 @@ def collect_cluster_metrics(self) -> None:
         # Process each cluster
         processed, skipped = 0, 0
         for cluster in clusters:
-            cluster_name = cluster.get("name", "unknown")
+            cluster_id = cluster.get("extId")
+            cluster_name = cluster.get("name")
+            cluster_label = cluster_name or "unknown"
 
             if self._is_prism_central_cluster(cluster):
-                self.check.log.info("[%s] Skipping Prism Central cluster: %s", self._pc_label, cluster_name)
+                self.check.log.info("[%s] Skipping Prism Central cluster: %s", self._pc_label, cluster_label)
                 self._collect_pc_version_metadata(cluster)
                 skipped += 1
                 continue
@@ -164,9 +166,13 @@ def collect_cluster_metrics(self) -> None:
                 skipped += 1
                 continue
 
-            cluster_id = cluster.get("extId")
             if not cluster_id:
-                self.check.log.warning("[%s][%s] Cluster has no extId, skipping", self._pc_label, cluster_name)
+                self.check.log.warning("[%s] Cluster %s has no extId, skipping", self._pc_label, cluster_label)
+                skipped += 1
+                continue
+
+            if not cluster_name:
+                self.check.log.warning("[%s] Cluster %s has no name, skipping", self._pc_label, cluster_id)
                 skipped += 1
                 continue
 
@@ -220,29 +226,32 @@ def _report_cluster_metrics(
     def _process_vm(self, vm: dict, vm_stats_dict: dict[str, list[dict]], cluster_name: str) -> bool:
         """Report metrics for a single VM if it passes filters."""
         vm_id = vm.get("extId")
-        hostname = vm.get("name")
-        if not vm_id or not hostname:
-            self.check.log.debug("[%s][%s] Skipping VM missing extId or name: %r", self._pc_label, cluster_name, vm)
+        vm_name = vm.get("name")
+        if not vm_id:
+            self.check.log.warning("[%s][%s] VM %s has no extId, skipping", self._pc_label, cluster_name, vm_name)
+            return False
+        if not vm_name:
+            self.check.log.warning("[%s][%s] VM %s has no name, skipping", self._pc_label, cluster_name, vm_id)
             return False
 
         if not self._should_collect_vm(vm):
             return False
 
         vm_tags = self.check.base_tags + self._extract_vm_tags(vm)
-        self._set_external_tags_for_host(hostname, vm_tags)
-        self._report_vm_basic_metrics(vm, hostname, vm_tags)
-        self._report_vm_stats(vm_id, hostname, vm_tags, vm_stats_dict, cluster_name)
+        self._set_external_tags_for_host(vm_name, vm_tags)
+        self._report_vm_basic_metrics(vm, vm_name, vm_tags)
+        self._report_vm_stats(vm_id, vm_name, vm_tags, vm_stats_dict, cluster_name)
         return True
 
-    def _report_vm_basic_metrics(self, vm: dict, hostname: str, vm_tags: list[str]) -> None:
+    def _report_vm_basic_metrics(self, vm: dict, vm_name: str, vm_tags: list[str]) -> None:
         """Report basic VM metrics (counts and status)."""
-        self.check.gauge("vm.count", 1, hostname=hostname, tags=vm_tags)
+        self.check.gauge("vm.count", 1, hostname=vm_name, tags=vm_tags)
 
         power_state = _normalize_tag_value(vm.get("powerState"))
         status_value = 0 if power_state == "on" else 1 if power_state == "paused" else 2
-        self.check.gauge("vm.status", status_value, hostname=hostname, tags=vm_tags)
+        self.check.gauge("vm.status", status_value, hostname=vm_name, tags=vm_tags)
 
-        self._report_vm_capacity_metrics(vm, hostname, vm_tags)
+        self._report_vm_capacity_metrics(vm, vm_name, vm_tags)
 
     def _extract_vm_capacity(self, vm: dict) -> tuple[int, int, int, int, int]:
         """Return (sockets, cores_per_socket, threads_per_core, vcpus_allocated, memory_bytes) for a VM."""
@@ -258,19 +267,19 @@ def _extract_vm_disk_capacity_bytes(self, vm: dict) -> int:
             int(get_nested(d, "backingInfo/diskSizeBytes") or 0) for d in vm.get("disks") or [] if isinstance(d, dict)
         )
 
-    def _report_vm_capacity_metrics(self, vm: dict, hostname: str, vm_tags: list[str]) -> None:
+    def _report_vm_capacity_metrics(self, vm: dict, vm_name: str, vm_tags: list[str]) -> None:
         """Report VM capacity metrics (CPU, memory, and disk allocation)."""
         num_sockets, num_cores_per_socket, num_threads_per_core, vcpus_allocated, memory_bytes = (
             self._extract_vm_capacity(vm)
         )
 
-        self.check.gauge("vm.cpu.sockets", num_sockets, hostname=hostname, tags=vm_tags)
-        self.check.gauge("vm.cpu.cores_per_socket", num_cores_per_socket, hostname=hostname, tags=vm_tags)
-        self.check.gauge("vm.cpu.threads_per_core", num_threads_per_core, hostname=hostname, tags=vm_tags)
-        self.check.gauge("vm.cpu.vcpus_allocated", vcpus_allocated, hostname=hostname, tags=vm_tags)
-        self.check.gauge("vm.memory.allocated_bytes", memory_bytes, hostname=hostname, tags=vm_tags)
+        self.check.gauge("vm.cpu.sockets", num_sockets, hostname=vm_name, tags=vm_tags)
+        self.check.gauge("vm.cpu.cores_per_socket", num_cores_per_socket, hostname=vm_name, tags=vm_tags)
+        self.check.gauge("vm.cpu.threads_per_core", num_threads_per_core, hostname=vm_name, tags=vm_tags)
+        self.check.gauge("vm.cpu.vcpus_allocated", vcpus_allocated, hostname=vm_name, tags=vm_tags)
+        self.check.gauge("vm.memory.allocated_bytes", memory_bytes, hostname=vm_name, tags=vm_tags)
         self.check.gauge(
-            "vm.disk_capacity_bytes", self._extract_vm_disk_capacity_bytes(vm), hostname=hostname, tags=vm_tags
+            "vm.disk_capacity_bytes", self._extract_vm_disk_capacity_bytes(vm), hostname=vm_name, tags=vm_tags
         )
 
     def _report_cluster_basic_metrics(self, cluster: dict, cluster_tags: list[str]) -> None:
@@ -357,17 +366,17 @@ def _report_cluster_stats(self, cluster_name: str, cluster_id: str, cluster_tags
         )
 
     def _report_vm_stats(
-        self, vm_id: str, hostname: str, vm_tags: list[str], vm_stats_dict: dict, cluster_name: str
+        self, vm_id: str, vm_name: str, vm_tags: list[str], vm_stats_dict: dict, cluster_name: str
     ) -> None:
         """Report time-series stats for a VM."""
         stats = vm_stats_dict.get(vm_id)
         if stats:
             self._report_stats(
-                f"[{self._pc_label}][{cluster_name}] VM {hostname}",
+                f"[{self._pc_label}][{cluster_name}] VM {vm_name}",
                 stats,
                 VM_STATS_METRICS,
                 vm_tags,
-                hostname=hostname,
+                hostname=vm_name,
             )
 
     def _process_hosts(
@@ -409,43 +418,55 @@ def _process_single_host(
             self.check.log.warning("[%s][%s] Host %s has no extId, skipping", self._pc_label, cluster_name, host_name)
             return
 
+        skip_host_metrics = False
+        if not host_name:
+            self.check.log.warning(
+                "[%s][%s] Host %s has no hostName, skipping host metrics",
+                self._pc_label,
+                cluster_name,
+                host_id,
+            )
+            skip_host_metrics = True
+
         if not should_collect_resource("host", host, self.check.resource_filters, self.check.log):
             return
 
-        self.host_count += 1
-
-        if host_name:
+        if not skip_host_metrics:
+            self.host_count += 1
             self.host_names[host_id] = host_name
 
-        host_tags = cluster_tags + self._extract_host_tags(host)
-        self.check.gauge("host.count", 1, hostname=host_name, tags=host_tags)
-        self._report_host_status_metrics(host, host_name, host_tags)
-        self._set_external_tags_for_host(host_name, host_tags)
-        self._report_host_capacity_metrics(host, host_name, host_tags)
+            host_tags = cluster_tags + self._extract_host_tags(host)
+            self.check.gauge("host.count", 1, hostname=host_name, tags=host_tags)
+            self._report_host_status_metrics(host, host_name, host_tags)
+            self._set_external_tags_for_host(host_name, host_tags)
+            self._report_host_capacity_metrics(host, host_name, host_tags)
 
-        try:
-            stats = self._get_stats(f"api/clustermgmt/v4.0/stats/clusters/{cluster_id}/hosts/{host_id}")
-            if stats:
-                self._report_stats(
-                    f"[{self._pc_label}][{cluster_name}] Host {host_name}",
-                    stats,
-                    HOST_STATS_METRICS,
-                    host_tags,
-                    hostname=host_name,
-                    extra_tags_by_key=self._get_disk_status_storage_tags(host_id),
+            try:
+                stats = self._get_stats(f"api/clustermgmt/v4.0/stats/clusters/{cluster_id}/hosts/{host_id}")
+                if stats:
+                    self._report_stats(
+                        f"[{self._pc_label}][{cluster_name}] Host {host_name}",
+                        stats,
+                        HOST_STATS_METRICS,
+                        host_tags,
+                        hostname=host_name,
+                        extra_tags_by_key=self._get_disk_status_storage_tags(host_id),
+                    )
+            except Exception:
+                self.check.log.exception(
+                    "[%s][%s] Failed to fetch stats for host %s", self._pc_label, cluster_name, host_name
                 )
-        except Exception:
-            self.check.log.exception(
-                "[%s][%s] Failed to fetch stats for host %s", self._pc_label, cluster_name, host_name
-            )
 
+        host_label = host_name or host_id
         try:
             vms = self._get_vms_for_host(host_id)
         except Exception:
-            self.check.log.exception("[%s][%s] Failed to list VMs for host %s", self._pc_label, cluster_name, host_name)
+            self.check.log.exception(
+                "[%s][%s] Failed to list VMs for host %s", self._pc_label, cluster_name, host_label
+            )
             return
 
-        self.check.log.debug("[%s][%s] Host %s has %d VMs", self._pc_label, cluster_name, host_name, len(vms))
+        self.check.log.debug("[%s][%s] Host %s has %d VMs", self._pc_label, cluster_name, host_label, len(vms))
         for vm in vms:
             if self._process_vm(vm, cluster_vm_stats_dict, cluster_name):
                 self.vm_count += 1

nutanix/tests/test_clusters.py

@@ -4,10 +4,12 @@
 
 
 import logging
+from copy import deepcopy
 
 import pytest
 
 from datadog_checks.nutanix import NutanixCheck
+from tests.conftest import load_fixture_page
 from tests.constants import BASE_TAGS, CLUSTER_TAGS
 
 pytestmark = [pytest.mark.unit]
@@ -92,6 +94,24 @@ def test_prism_central_cluster_skipped(dd_run_check, aggregator, mock_instance,
     assert len(pc_metrics) == 0
 
 
+def test_cluster_with_no_name_is_skipped(
+    dd_run_check, aggregator, mock_instance, mock_http_get, mocker, caplog
+) -> None:
+    clusters = deepcopy(load_fixture_page("clusters.json", 0)["data"])
+    clusters.append({"extId": "no-name-cluster-id", "config": {"clusterFunction": ["AOS"]}})
+    mocker.patch(
+        "datadog_checks.nutanix.infrastructure_monitor.InfrastructureMonitor._list_clusters",
+        return_value=clusters,
+    )
+
+    check = NutanixCheck('nutanix', {}, [mock_instance])
+    with caplog.at_level(logging.WARNING):
+        dd_run_check(check)
+
+    assert check.infrastructure_monitor.cluster_count == 2
+    assert any("no-name-cluster-id" in r.message and "has no name" in r.message for r in caplog.records)
+
+
 def test_missing_pc_ip_raises_error(dd_run_check):
     with pytest.raises(Exception, match="(?s)pc_ip.*required"):
         check = NutanixCheck('nutanix', {}, [{"pc_username": "admin", "pc_password": "secret"}])

nutanix/tests/test_vms.py

@@ -2,10 +2,12 @@
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
 
+from copy import deepcopy
 
 import pytest
 
 from datadog_checks.nutanix import NutanixCheck
+from tests.conftest import load_fixture_page
 from tests.constants import OFF_VM_NAME, OFF_VM_TAGS, PCVM_NAME, PCVM_TAGS
 from tests.metrics import VM_STATS_METRICS_REQUIRED
 
@@ -68,6 +70,98 @@ def test_batch_and_non_batch_produce_same_counts(
     aggregator.assert_metric("nutanix.cluster.count", count=2)
 
 
+@pytest.mark.parametrize("batch_vm_collection", [True, False])
+def test_vms_collected_when_host_missing_name(
+    dd_run_check, aggregator, mock_instance, mock_http_get, mocker, batch_vm_collection
+) -> None:
+    mock_instance["batch_vm_collection"] = batch_vm_collection
+
+    hosts = deepcopy(load_fixture_page("hosts_00064715.json", 0)["data"])
+    hosts[0].pop("hostName")
+    hosts_by_cluster = {
+        "00064715-c043-5d8f-ee4b-176ec875554d": hosts,
+        "aabbccdd-1111-2222-3333-444455556666": deepcopy(load_fixture_page("hosts_aabbccdd.json", 0)["data"]),
+    }
+    mocker.patch(
+        "datadog_checks.nutanix.infrastructure_monitor.InfrastructureMonitor._list_hosts_by_cluster",
+        side_effect=lambda cluster_id: hosts_by_cluster[cluster_id],
+    )
+
+    check = NutanixCheck('nutanix', {}, [mock_instance])
+    dd_run_check(check)
+
+    vm_names = {
+        tag.split(":", 1)[1]
+        for m in aggregator.metrics("nutanix.vm.count")
+        for tag in m.tags
+        if tag.startswith("ntnx_vm_name:")
+    }
+    assert {PCVM_NAME, "ubuntu-vm", "random-vm"}.issubset(vm_names)
+    assert check.infrastructure_monitor.host_count == 1
+    aggregator.assert_metric("nutanix.vm.count", count=4)
+    aggregator.assert_metric("nutanix.host.count", count=1)
+
+
+@pytest.mark.parametrize("batch_vm_collection", [True, False])
+def test_vm_with_no_extid_is_skipped(
+    dd_run_check, aggregator, mock_instance, mock_http_get, mocker, batch_vm_collection
+) -> None:
+    mock_instance["batch_vm_collection"] = batch_vm_collection
+
+    all_vms = deepcopy(load_fixture_page("vms.json", 0)["data"])
+    vms_by_host: dict[str, list] = {}
+    for vm in all_vms:
+        host_id = (vm.get("host") or {}).get("extId") or ""
+        vms_by_host.setdefault(host_id, []).append(vm)
+
+    ubuntu_vm = next(v for v in vms_by_host["d8787814-4fe8-4ba5-931f-e1ee31c294a6"] if v.get("name") == "ubuntu-vm")
+    ubuntu_vm.pop("extId")
+
+    mocker.patch(
+        "datadog_checks.nutanix.infrastructure_monitor.InfrastructureMonitor._get_vms_for_host",
+        side_effect=lambda h: vms_by_host.get(h, []),
+    )
+
+    check = NutanixCheck('nutanix', {}, [mock_instance])
+    dd_run_check(check)
+
+    assert check.infrastructure_monitor.vm_count == 3
+    vm_names = {
+        tag.split(":", 1)[1]
+        for m in aggregator.metrics("nutanix.vm.count")
+        for tag in m.tags
+        if tag.startswith("ntnx_vm_name:")
+    }
+    assert "ubuntu-vm" not in vm_names
+
+
+@pytest.mark.parametrize("batch_vm_collection", [True, False])
+def test_vm_with_no_name_is_skipped(
+    dd_run_check, aggregator, mock_instance, mock_http_get, mocker, batch_vm_collection
+) -> None:
+    mock_instance["batch_vm_collection"] = batch_vm_collection
+
+    all_vms = deepcopy(load_fixture_page("vms.json", 0)["data"])
+    vms_by_host: dict[str, list] = {}
+    for vm in all_vms:
+        host_id = (vm.get("host") or {}).get("extId") or ""
+        vms_by_host.setdefault(host_id, []).append(vm)
+
+    ubuntu_vm = next(v for v in vms_by_host["d8787814-4fe8-4ba5-931f-e1ee31c294a6"] if v.get("name") == "ubuntu-vm")
+    ubuntu_vm.pop("name")
+
+    mocker.patch(
+        "datadog_checks.nutanix.infrastructure_monitor.InfrastructureMonitor._get_vms_for_host",
+        side_effect=lambda h: vms_by_host.get(h, []),
+    )
+
+    check = NutanixCheck('nutanix', {}, [mock_instance])
+    dd_run_check(check)
+
+    assert check.infrastructure_monitor.vm_count == 3
+    aggregator.assert_metric("nutanix.vm.count", count=3)
+
+
 def test_external_tags_for_vm(dd_run_check, aggregator, mock_instance, mock_http_get, datadog_agent):
     check = NutanixCheck('nutanix', {}, [mock_instance])
     dd_run_check(check)