@oneuptime/common 14.0.3 → 14.0.6

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

@@ -3,6 +3,7 @@ import InventoryItem, {
   EntityAttributes,
   EntityExtractionResult,
   ExtractedEntity,
+  keyForContainer as keyForContainerReExported,
   MAX_DESCRIPTIVE_ATTRIBUTE_VALUE_LENGTH,
   ResourceEntityRef,
   RetiredEntityIdentity,
@@ -20,6 +21,9 @@ import {
   keyForProxmoxCluster,
   keyForCephCluster,
   keyForVMwareVCenter,
+  keyForKubernetesPod,
+  keyForKubernetesDeployment,
+  keyForContainer,
 } from "../../../../Utils/Telemetry/EntityKey";
 import logger from "../../../../Server/Utils/Logger";
 import { describe, expect, test } from "@jest/globals";
@@ -1150,6 +1154,167 @@ describe("read-side keyFor* helpers match ingest-side extraction", () => {
     );
     expect(keyForCephCluster(PROJECT, "ceph-prod")).toBe(stamped!.entityKey);
   });
+
+  /*
+   * The Databases product scopes a Kubernetes / Docker / Podman database's
+   * telemetry by its members' keys, computed by the worker (and the browser)
+   * from inventory rows — so each must equal what ingest stamps.
+   */
+  test("keyForKubernetesPod matches the pod entity stamped from cluster + namespace + pod name", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      {
+        "k8s.cluster.name": "prod-eu",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "pg-main-1",
+        "k8s.pod.uid": "8a1c-uid",
+        "k8s.node.name": "node-3",
+        "container.id": "abc123def456",
+      },
+      EntityType.KubernetesPod,
+    );
+    expect(stamped).toBeDefined();
+    expect(
+      keyForKubernetesPod(PROJECT, {
+        clusterName: "prod-eu",
+        namespace: "shop",
+        podName: "pg-main-1",
+      }),
+    ).toBe(stamped!.entityKey);
+  });
+
+  test("keyForKubernetesPod canonicalizes like ingest", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      {
+        "k8s.cluster.name": "Prod-EU",
+        "k8s.namespace.name": "Shop",
+        "k8s.pod.name": "PG-Main-1",
+      },
+      EntityType.KubernetesPod,
+    );
+    expect(
+      keyForKubernetesPod(PROJECT, {
+        clusterName: "  prod-eu ",
+        namespace: "shop",
+        podName: "pg-main-1",
+      }),
+    ).toBe(stamped!.entityKey);
+  });
+
+  test("keyForKubernetesPod matches a resource without cluster / namespace only when given none", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      { "k8s.pod.name": "pg-0" },
+      EntityType.KubernetesPod,
+    );
+    expect(keyForKubernetesPod(PROJECT, { podName: "pg-0" })).toBe(
+      stamped!.entityKey,
+    );
+    expect(
+      keyForKubernetesPod(PROJECT, {
+        clusterName: " ",
+        namespace: "",
+        podName: "pg-0",
+      }),
+    ).toBe(stamped!.entityKey);
+    expect(
+      keyForKubernetesPod(PROJECT, { clusterName: "prod", podName: "pg-0" }),
+    ).not.toBe(stamped!.entityKey);
+  });
+
+  test("keyForKubernetesDeployment matches the deployment entity stamped from k8s.deployment.name", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      {
+        "k8s.cluster.name": "prod-eu",
+        "k8s.namespace.name": "shop",
+        "k8s.deployment.name": "cache",
+        "k8s.pod.name": "cache-7d9f8b6c5d-x2x4z",
+        "k8s.replicaset.name": "cache-7d9f8b6c5d",
+      },
+      EntityType.KubernetesDeployment,
+    );
+    expect(stamped).toBeDefined();
+    expect(
+      keyForKubernetesDeployment(PROJECT, {
+        clusterName: "prod-eu",
+        namespace: "shop",
+        deploymentName: "cache",
+      }),
+    ).toBe(stamped!.entityKey);
+    // The namespace is part of the identity.
+    expect(
+      keyForKubernetesDeployment(PROJECT, {
+        clusterName: "prod-eu",
+        deploymentName: "cache",
+      }),
+    ).not.toBe(stamped!.entityKey);
+  });
+
+  test("keyForKubernetesDeployment without cluster / namespace matches a bare resource", () => {
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      { "k8s.deployment.name": "Cache" },
+      EntityType.KubernetesDeployment,
+    );
+    expect(
+      keyForKubernetesDeployment(PROJECT, {
+        clusterName: null,
+        namespace: undefined,
+        deploymentName: "cache",
+      }),
+    ).toBe(stamped!.entityKey);
+  });
+
+  test("keyForContainer matches the container entity stamped from container.id", () => {
+    const fullId: string =
+      "3f9a1b2c4d5e6f708192a3b4c5d6e7f8091a2b3c4d5e6f708192a3b4c5d6e7f8";
+    const stamped: ExtractedEntity | undefined = entityOfType(
+      {
+        "container.id": fullId,
+        "container.name": "shop-postgres-1",
+        "container.runtime": "docker",
+        "host.name": "build-host-1",
+      },
+      EntityType.Container,
+    );
+    expect(stamped).toBeDefined();
+    expect(keyForContainer(PROJECT, fullId)).toBe(stamped!.entityKey);
+    expect(keyForContainer(PROJECT, fullId.toUpperCase())).toBe(
+      stamped!.entityKey,
+    );
+    // The short id is a different identity: callers must pass the full id.
+    expect(keyForContainer(PROJECT, fullId.slice(0, 12))).not.toBe(
+      stamped!.entityKey,
+    );
+  });
+
+  test("keyForContainer re-exported from the entity util is the EntityKey helper", () => {
+    expect(keyForContainerReExported).toBe(keyForContainer);
+  });
+});
+
+describe("database.server is membership-only (never resolver-emitted)", () => {
+  test("a DB receiver resource derives no database.server entity", () => {
+    expect(
+      typesFor({
+        "db.system.name": "postgresql",
+        "server.address": "db.prod",
+        "server.port": "5432",
+        "service.instance.id": "db.prod:5432",
+        "host.name": "collector-1",
+      }),
+    ).not.toContain(EntityType.DatabaseServer);
+  });
+
+  test("an app resource with k8s + container attributes derives none either", () => {
+    expect(
+      typesFor({
+        "service.name": "checkout",
+        "k8s.cluster.name": "prod",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-1",
+        "container.id": "abc123def456",
+        "server.address": "pg.shop.svc.cluster.local",
+      }),
+    ).not.toContain(EntityType.DatabaseServer);
+  });
 });
 
 describe("descriptive attributes & labels (never identity-bearing)", () => {
@@ -2338,3 +2503,133 @@ describe("InventoryItem.parseEntityRefs", () => {
     expect(InventoryItem.parseEntityRefs("nope")).toEqual([]);
   });
 });
+
+/*
+ * A database's engine telemetry carries the host.name of the machine its
+ * collector runs on (or, for sqlserver / oracledb, the database server's
+ * name). Ingest asks the extractor to leave the heuristic Host out of such a
+ * batch; everything else — and anything a producer declared — is untouched.
+ */
+describe("extractEntitiesWithRetirements — suppressHeuristicEntityTypes", () => {
+  const collectorAttributes: EntityAttributes = {
+    "host.name": "collector-vm-1",
+    "os.type": "linux",
+    "server.address": "orders-db.example.com",
+  };
+
+  test("drops the heuristic Host of a database receiver batch", () => {
+    const unsuppressed: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+      });
+    const suppressed: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+        suppressHeuristicEntityTypes: [EntityType.Host],
+      });
+
+    // Without suppression the collector machine becomes a Host entity…
+    expect(unsuppressed.entities).toContainEqual(
+      expect.objectContaining({
+        entityType: EntityType.Host,
+        entityKey: keyForHost(PROJECT, "collector-vm-1"),
+      }),
+    );
+    // …with it, neither the entity nor its key is there.
+    expect(suppressed.entities).not.toContainEqual(
+      expect.objectContaining({ entityType: EntityType.Host }),
+    );
+    expect(
+      suppressed.entities.map((entity: ExtractedEntity): string => {
+        return entity.entityKey;
+      }),
+    ).not.toContain(keyForHost(PROJECT, "collector-vm-1"));
+  });
+
+  test("the sqlserver receiver's own host.name mints no phantom Host", () => {
+    const result: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: { "host.name": "SQLPROD01" },
+        suppressHeuristicEntityTypes: [EntityType.Host],
+      });
+
+    expect(result.entities).toEqual([]);
+  });
+
+  test("only the listed types are dropped: a Kubernetes pod identity stays", () => {
+    const attributes: EntityAttributes = {
+      "host.name": "worker-3",
+      "k8s.pod.name": "postgres-0",
+      "k8s.namespace.name": "prod",
+      "k8s.cluster.name": "prod-eu",
+    };
+
+    const unsuppressed: Array<string> =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes,
+      }).entities.map((entity: ExtractedEntity): string => {
+        return entity.entityKey;
+      });
+    const suppressed: Array<string> =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes,
+        suppressHeuristicEntityTypes: [EntityType.Host],
+      }).entities.map((entity: ExtractedEntity): string => {
+        return entity.entityKey;
+      });
+
+    expect(suppressed).toEqual(unsuppressed);
+    expect(suppressed).toContain(
+      keyForKubernetesPod(PROJECT, {
+        clusterName: "prod-eu",
+        namespace: "prod",
+        podName: "postgres-0",
+      }),
+    );
+  });
+
+  test("a Host a producer declared through entity_refs is never suppressed", () => {
+    const result: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+        entityRefs: [{ type: "host", idKeys: ["host.name"] }],
+        suppressHeuristicEntityTypes: [EntityType.Host],
+      });
+
+    expect(result.entities).toEqual([
+      expect.objectContaining({
+        entityType: EntityType.Host,
+        entityKey: keyForHost(PROJECT, "collector-vm-1"),
+      }),
+    ]);
+  });
+
+  test("an empty or absent list changes nothing", () => {
+    const baseline: EntityExtractionResult =
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+      });
+
+    expect(
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+        suppressHeuristicEntityTypes: [],
+      }),
+    ).toEqual(baseline);
+    expect(
+      InventoryItem.extractEntitiesWithRetirements({
+        projectId: PROJECT,
+        attributes: collectorAttributes,
+        suppressHeuristicEntityTypes: undefined,
+      }),
+    ).toEqual(baseline);
+  });
+});

package/Tests/Types/AI/AIResourceContext.test.ts

@@ -84,6 +84,36 @@ describe("infrastructure resource context validation", () => {
     ).toBeUndefined();
   });
 
+  test("Databases reuse the telemetry catalog's facet and label", () => {
+    expect(getAIResourceDefinition(AIResourceType.DatabaseServer)).toEqual(
+      expect.objectContaining({
+        type: AIResourceType.DatabaseServer,
+        facetKey: "databaseServerId",
+        serviceType: ServiceType.DatabaseServer,
+        label: "Database",
+        pluralLabel: "Databases",
+      }),
+    );
+  });
+
+  test.each([
+    { kind: AIResourceSubresourceKind.Instance },
+    { kind: AIResourceSubresourceKind.Pod, key: "postgres-0" },
+    { kind: AIResourceSubresourceKind.Container, key: "postgres" },
+  ])(
+    "a database has no child identity - %p is refused rather than widened",
+    (subresource: JSONObject) => {
+      expect(
+        AIChatPageContextHelper.sanitize(
+          resource({
+            resourceType: AIResourceType.DatabaseServer,
+            subresource,
+          }),
+        ),
+      ).toBeUndefined();
+    },
+  );
+
   test("IoT fleet telemetry keeps its historical discriminator", () => {
     expect(getAIResourceDefinition(AIResourceType.IoTFleet)).toEqual(
       expect.objectContaining({

package/Tests/Types/BaseDatabase/AggregationType.test.ts

@@ -9,14 +9,16 @@ describe("AggregationType", () => {
   describe("PercentileAggregationLevels", () => {
     test("maps each percentile enum to its quantile fraction", () => {
       expect(PercentileAggregationLevels[AggregationType.P50]).toBe(0.5);
+      expect(PercentileAggregationLevels[AggregationType.P75]).toBe(0.75);
       expect(PercentileAggregationLevels[AggregationType.P90]).toBe(0.9);
       expect(PercentileAggregationLevels[AggregationType.P95]).toBe(0.95);
       expect(PercentileAggregationLevels[AggregationType.P99]).toBe(0.99);
     });
 
-    test("contains exactly the four percentile aggregations", () => {
+    test("contains exactly the five percentile aggregations", () => {
       expect(Object.keys(PercentileAggregationLevels).sort()).toEqual([
         "P50",
+        "P75",
         "P90",
         "P95",
         "P99",
@@ -27,6 +29,7 @@ describe("AggregationType", () => {
   describe("isPercentileAggregation", () => {
     test("returns true for every percentile aggregation", () => {
       expect(isPercentileAggregation(AggregationType.P50)).toBe(true);
+      expect(isPercentileAggregation(AggregationType.P75)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P90)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P95)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P99)).toBe(true);
@@ -44,6 +47,7 @@ describe("AggregationType", () => {
   describe("getPercentileLevel", () => {
     test("returns the quantile fraction for percentile aggregations", () => {
       expect(getPercentileLevel(AggregationType.P50)).toBe(0.5);
+      expect(getPercentileLevel(AggregationType.P75)).toBe(0.75);
       expect(getPercentileLevel(AggregationType.P99)).toBe(0.99);
     });
 

package/Tests/Types/Dashboard/KubernetesDashboardTemplate.test.ts

@@ -0,0 +1,184 @@
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import DashboardViewConfig from "../../../Types/Dashboard/DashboardViewConfig";
+import {
+  DashboardTemplateType,
+  getTemplateConfig,
+} from "../../../Types/Dashboard/DashboardTemplates";
+import KubernetesClusterCpuTileRepair, {
+  BUSIEST_NODE_CPU_TILE_TITLE,
+  KUBERNETES_NODE_CPU_USAGE_METRIC,
+  LEGACY_CLUSTER_CPU_TILE_TITLE,
+} from "../../../Utils/Dashboard/KubernetesClusterCpuTileRepair";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Editorial invariants for the Kubernetes template specifically. The
+ * structural rules every template must satisfy live in
+ * DashboardTemplateInvariants; this file pins the aggregation of the
+ * Kubernetes Value tiles.
+ *
+ * Every metric the Kubernetes template reads into a Value tile is a gauge
+ * the agent re-emits for every node or pod on every scrape. A Value tile
+ * reduces the whole window to one number: the server aggregates each time
+ * bucket over every series and scrape in it, and the widget then folds the
+ * buckets (ValueWidgetData.aggregateValues). With `Sum` both steps add, so
+ * the number grows with the node count, the scrape rate and the window:
+ * "Cluster CPU (cores in use)" read ~540 for three nodes on 1.5 cores each
+ * over the default hour. Avg, Max and Min have no such multiplier.
+ */
+
+function loadKubernetesTemplate(): DashboardViewConfig {
+  const config: DashboardViewConfig | null = getTemplateConfig(
+    DashboardTemplateType.Kubernetes,
+  );
+
+  if (!config) {
+    throw new Error("Expected the Kubernetes template to resolve to a config");
+  }
+
+  return config;
+}
+
+function getArguments(
+  component: DashboardBaseComponent,
+): Record<string, unknown> {
+  return (component.arguments as Record<string, unknown>) || {};
+}
+
+function getFilterData(
+  component: DashboardBaseComponent,
+): Record<string, unknown> {
+  const queryConfig: Record<string, unknown> | undefined = getArguments(
+    component,
+  )["metricQueryConfig"] as Record<string, unknown> | undefined;
+  const queryData: Record<string, unknown> | undefined = queryConfig?.[
+    "metricQueryData"
+  ] as Record<string, unknown> | undefined;
+
+  return (queryData?.["filterData"] as Record<string, unknown>) || {};
+}
+
+function getValueTiles(
+  config: DashboardViewConfig,
+): Array<DashboardBaseComponent> {
+  return config.components.filter(
+    (component: DashboardBaseComponent): boolean => {
+      return component.componentType === DashboardComponentType.Value;
+    },
+  );
+}
+
+function describeTile(component: DashboardBaseComponent): string {
+  const filterData: Record<string, unknown> = getFilterData(component);
+
+  return `"${String(getArguments(component)["title"])}" ${String(
+    filterData["metricName"],
+  )}/${String(filterData["aggegationType"])}`;
+}
+
+describe("Kubernetes dashboard template", () => {
+  describe("busiest node CPU tile", () => {
+    function findNodeCpuTiles(): Array<DashboardBaseComponent> {
+      return getValueTiles(loadKubernetesTemplate()).filter(
+        (component: DashboardBaseComponent): boolean => {
+          return (
+            getFilterData(component)["metricName"] ===
+            KUBERNETES_NODE_CPU_USAGE_METRIC
+          );
+        },
+      );
+    }
+
+    test("reads k8s.node.cpu.usage with Max, never Sum", (): void => {
+      const busiestNodeTile: DashboardBaseComponent | undefined =
+        findNodeCpuTiles().find((component: DashboardBaseComponent) => {
+          return (
+            getArguments(component)["title"] === BUSIEST_NODE_CPU_TILE_TITLE
+          );
+        });
+
+      expect(busiestNodeTile).toBeDefined();
+      expect(getFilterData(busiestNodeTile!)["aggegationType"]).toBe(
+        AggregationType.Max,
+      );
+    });
+
+    test("no longer ships the summed cluster CPU tile under any title", (): void => {
+      const nodeCpuTiles: Array<DashboardBaseComponent> = findNodeCpuTiles();
+
+      expect(nodeCpuTiles.length).toBeGreaterThan(0);
+
+      for (const component of nodeCpuTiles) {
+        expect(describeTile(component)).not.toContain(
+          `/${AggregationType.Sum}`,
+        );
+        expect(getArguments(component)["title"]).not.toBe(
+          LEGACY_CLUSTER_CPU_TILE_TITLE,
+        );
+      }
+    });
+
+    /*
+     * The migration writes BUSIEST_NODE_CPU_TILE_TITLE and Max onto
+     * existing dashboards. If the template and the repair drift apart, a
+     * repaired dashboard and a freshly created one show different tiles.
+     */
+    test("is exactly what the repair writes onto existing dashboards", (): void => {
+      const busiestNodeTile: DashboardBaseComponent | undefined =
+        findNodeCpuTiles().find((component: DashboardBaseComponent) => {
+          return (
+            getArguments(component)["title"] === BUSIEST_NODE_CPU_TILE_TITLE
+          );
+        });
+
+      expect(busiestNodeTile).toBeDefined();
+
+      const legacyTile: DashboardBaseComponent = JSON.parse(
+        JSON.stringify(busiestNodeTile),
+      );
+      (legacyTile.arguments as Record<string, unknown>)["title"] =
+        LEGACY_CLUSTER_CPU_TILE_TITLE;
+      getFilterData(legacyTile)["aggegationType"] = AggregationType.Sum;
+
+      const repaired: ReturnType<typeof KubernetesClusterCpuTileRepair.repair> =
+        KubernetesClusterCpuTileRepair.repair({ components: [legacyTile] });
+
+      expect(repaired).not.toBeNull();
+      expect(
+        (repaired!.config["components"] as Array<unknown>)[0],
+      ).toStrictEqual(JSON.parse(JSON.stringify(busiestNodeTile)));
+    });
+
+    test("is not matched by the repair, so a new dashboard is never rewritten", (): void => {
+      expect(
+        KubernetesClusterCpuTileRepair.repair(
+          JSON.parse(JSON.stringify(loadKubernetesTemplate())),
+        )?.repairedTileCount ?? 0,
+      ).toBe(0);
+    });
+  });
+
+  test("no Value tile sums a per-resource gauge across the window", (): void => {
+    const valueTiles: Array<DashboardBaseComponent> = getValueTiles(
+      loadKubernetesTemplate(),
+    );
+
+    expect(valueTiles.length).toBeGreaterThan(0);
+
+    for (const component of valueTiles) {
+      const aggregation: unknown = getFilterData(component)["aggegationType"];
+
+      expect(describeTile(component)).toBe(
+        `"${String(getArguments(component)["title"])}" ${String(
+          getFilterData(component)["metricName"],
+        )}/${
+          aggregation === AggregationType.Sum
+            ? "<not Sum>"
+            : String(aggregation)
+        }`,
+      );
+    }
+  });
+});

package/Tests/Types/Dashboard/KubernetesDashboardTemplates.test.ts

@@ -0,0 +1,107 @@
+import DashboardViewConfig from "../../../Types/Dashboard/DashboardViewConfig";
+import {
+  DashboardTemplateType,
+  getTemplateConfig,
+} from "../../../Types/Dashboard/DashboardTemplates";
+import { AGENT_EMITTED_METRIC_NAMES } from "../Monitor/Utils/KubernetesAgentEmittedMetrics";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The Kubernetes dashboard templates chart what the kubernetes-agent chart
+ * sends, and nothing else feeds them. A widget naming a metric the agent
+ * never sends does not error — its query returns zero rows and the widget
+ * renders empty on every dashboard created from the template.
+ *
+ * That shipped: the Kubernetes template's four CPU widgets read
+ * `k8s.pod.cpu.usage` and `k8s.node.cpu.usage`, which kubeletstats at the
+ * pinned collector leaves off by default, before the chart enabled them.
+ * Nothing checked the dashboards against AGENT_EMITTED_METRIC_NAMES, so
+ * this holds every widget of both templates to it.
+ */
+const KUBERNETES_TEMPLATE_TYPES: Array<DashboardTemplateType> = [
+  DashboardTemplateType.Kubernetes,
+  DashboardTemplateType.KubernetesCost,
+];
+
+interface MetricQuery {
+  widget: string;
+  metricName: string;
+}
+
+function getConfig(type: DashboardTemplateType): DashboardViewConfig {
+  const config: DashboardViewConfig | null = getTemplateConfig(type);
+
+  if (!config) {
+    throw new Error(`Expected ${type} to resolve to a config`);
+  }
+
+  return config;
+}
+
+/*
+ * Every `filterData.metricName` anywhere in a widget's arguments, so a
+ * widget that carries several queries cannot hide one from the check.
+ */
+function collectMetricNames(value: unknown, into: Array<string>): void {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+
+  const record: Record<string, unknown> = value as Record<string, unknown>;
+  const filterData: Record<string, unknown> | undefined = record[
+    "filterData"
+  ] as Record<string, unknown> | undefined;
+
+  if (filterData && typeof filterData["metricName"] === "string") {
+    into.push(filterData["metricName"]);
+  }
+
+  for (const child of Object.values(record)) {
+    collectMetricNames(child, into);
+  }
+}
+
+function getMetricQueries(type: DashboardTemplateType): Array<MetricQuery> {
+  const queries: Array<MetricQuery> = [];
+
+  for (const component of getConfig(type).components) {
+    const args: Record<string, unknown> =
+      (component.arguments as Record<string, unknown>) || {};
+    const label: unknown =
+      args["title"] ??
+      args["chartTitle"] ??
+      args["gaugeTitle"] ??
+      args["tableTitle"];
+    const metricNames: Array<string> = [];
+
+    collectMetricNames(args, metricNames);
+
+    for (const metricName of metricNames) {
+      queries.push({
+        widget: `${component.componentType} "${String(label ?? "<untitled>")}"`,
+        metricName: metricName,
+      });
+    }
+  }
+
+  return queries;
+}
+
+describe("Kubernetes dashboard templates", () => {
+  describe.each(KUBERNETES_TEMPLATE_TYPES)(
+    "%s",
+    (type: DashboardTemplateType) => {
+      test("queries at least one metric (guards the guard)", () => {
+        expect(getMetricQueries(type).length).toBeGreaterThan(0);
+      });
+
+      test("every widget queries a metric the agent emits", () => {
+        for (const query of getMetricQueries(type)) {
+          expect(
+            `${query.widget} → ${query.metricName} emitted: ${AGENT_EMITTED_METRIC_NAMES.has(query.metricName)}`,
+          ).toBe(`${query.widget} → ${query.metricName} emitted: true`);
+        }
+      });
+    },
+  );
+});