Merge branch 'main' into infraM/v2_onboarding_api

* chore: added phase counts feature

* chore: added queries for pod phase counts in custom group by

* chore: added unknown phase count

* fix: isPodUIDInGroupBy in buildPodRecords

* chore: 3 cte --> 2 cte

* chore: pod phase with local table of time series as counts

* chore: comment correction

* chore: corrected comment

* chore: value column for samples table added

* chore: removed query G for phase counts

* chore: rename variable

* chore: added PodPhaseNum constants to types

docs/api/openapi.yml

@@ -4011,6 +4011,94 @@ components:
         enabled:
           type: boolean
       type: object
+    InframonitoringtypesAssociatedComponent:
+      properties:
+        name:
+          type: string
+        type:
+          $ref: '#/components/schemas/InframonitoringtypesCheckComponentType'
+      required:
+      - type
+      - name
+      type: object
+    InframonitoringtypesAttributesComponentEntry:
+      properties:
+        associatedComponent:
+          $ref: '#/components/schemas/InframonitoringtypesAssociatedComponent'
+        attributes:
+          items:
+            type: string
+          nullable: true
+          type: array
+      required:
+      - attributes
+      - associatedComponent
+      type: object
+    InframonitoringtypesCheckComponentType:
+      enum:
+      - receiver
+      - processor
+      type: string
+    InframonitoringtypesCheckType:
+      enum:
+      - hosts
+      - processes
+      - pods
+      - nodes
+      - deployments
+      - daemonsets
+      - statefulsets
+      - jobs
+      - namespaces
+      - clusters
+      - volumes
+      type: string
+    InframonitoringtypesChecks:
+      properties:
+        missingDefaultEnabledMetrics:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesMissingMetricsComponentEntry'
+          nullable: true
+          type: array
+        missingOptionalMetrics:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesMissingMetricsComponentEntry'
+          nullable: true
+          type: array
+        missingRequiredAttributes:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesMissingAttributesComponentEntry'
+          nullable: true
+          type: array
+        presentDefaultEnabledMetrics:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesMetricsComponentEntry'
+          nullable: true
+          type: array
+        presentOptionalMetrics:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesMetricsComponentEntry'
+          nullable: true
+          type: array
+        presentRequiredAttributes:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesAttributesComponentEntry'
+          nullable: true
+          type: array
+        ready:
+          type: boolean
+        type:
+          $ref: '#/components/schemas/InframonitoringtypesCheckType'
+      required:
+      - type
+      - ready
+      - presentDefaultEnabledMetrics
+      - presentOptionalMetrics
+      - presentRequiredAttributes
+      - missingDefaultEnabledMetrics
+      - missingOptionalMetrics
+      - missingRequiredAttributes
+      type: object
     InframonitoringtypesClusterRecord:
       properties:
         clusterCPU:
@@ -4360,6 +4448,57 @@ components:
       - requiredMetricsCheck
       - endTimeBeforeRetention
       type: object
+    InframonitoringtypesMetricsComponentEntry:
+      properties:
+        associatedComponent:
+          $ref: '#/components/schemas/InframonitoringtypesAssociatedComponent'
+        metrics:
+          items:
+            type: string
+          nullable: true
+          type: array
+      required:
+      - metrics
+      - associatedComponent
+      type: object
+    InframonitoringtypesMissingAttributesComponentEntry:
+      properties:
+        associatedComponent:
+          $ref: '#/components/schemas/InframonitoringtypesAssociatedComponent'
+        attributes:
+          items:
+            type: string
+          nullable: true
+          type: array
+        documentationLink:
+          type: string
+        message:
+          type: string
+      required:
+      - attributes
+      - associatedComponent
+      - message
+      - documentationLink
+      type: object
+    InframonitoringtypesMissingMetricsComponentEntry:
+      properties:
+        associatedComponent:
+          $ref: '#/components/schemas/InframonitoringtypesAssociatedComponent'
+        documentationLink:
+          type: string
+        message:
+          type: string
+        metrics:
+          items:
+            type: string
+          nullable: true
+          type: array
+      required:
+      - metrics
+      - associatedComponent
+      - message
+      - documentationLink
+      type: object
     InframonitoringtypesNamespaceRecord:
       properties:
         meta:
@@ -14868,6 +15007,72 @@ paths:
       summary: Health check
       tags:
       - health
+  /api/v2/infra_monitoring/checks:
+    get:
+      deprecated: false
+      description: 'Checks whether the metrics and attributes required to power the
+        infra-monitoring section selected by the ''type'' query parameter (hosts,
+        processes, pods, nodes, deployments, daemonsets, statefulsets, jobs, namespaces,
+        clusters, volumes) are being received. For each collector receiver or processor
+        that contributes required metrics or attributes, lists what is present and
+        what is missing, with a prebuilt user-facing message and a docs link per missing
+        component. Default-enabled metrics are those expected as soon as the receiver
+        is configured; optional metrics require ''enabled: true'' in receiver config.
+        ''ready'' is true only when every missing list is empty.'
+      operationId: GetChecks
+      parameters:
+      - in: query
+        name: type
+        required: true
+        schema:
+          $ref: '#/components/schemas/InframonitoringtypesCheckType'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/InframonitoringtypesChecks'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Run Infra Monitoring Setup Checks
+      tags:
+      - inframonitoring
   /api/v2/infra_monitoring/clusters:
     post:
       deprecated: false

frontend/src/api/generated/services/inframonitoring/index.ts

@@ -4,14 +4,22 @@
  * * regenerate with 'pnpm generate:api'
  * SigNoz
  */
-import { useMutation } from 'react-query';
+import { useMutation, useQuery } from 'react-query';
 import type {
+	InvalidateOptions,
 	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
 	UseMutationOptions,
 	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
 } from 'react-query';
 
 import type {
+	GetChecks200,
+	GetChecksParams,
 	InframonitoringtypesPostableClustersDTO,
 	InframonitoringtypesPostableDaemonSetsDTO,
 	InframonitoringtypesPostableDeploymentsDTO,
@@ -38,6 +46,93 @@ import type {
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
+/**
+ * Checks whether the metrics and attributes required to power the infra-monitoring section selected by the 'type' query parameter (hosts, processes, pods, nodes, deployments, daemonsets, statefulsets, jobs, namespaces, clusters, volumes) are being received. For each collector receiver or processor that contributes required metrics or attributes, lists what is present and what is missing, with a prebuilt user-facing message and a docs link per missing component. Default-enabled metrics are those expected as soon as the receiver is configured; optional metrics require 'enabled: true' in receiver config. 'ready' is true only when every missing list is empty.
+ * @summary Run Infra Monitoring Setup Checks
+ */
+export const getChecks = (params: GetChecksParams, signal?: AbortSignal) => {
+	return GeneratedAPIInstance<GetChecks200>({
+		url: `/api/v2/infra_monitoring/checks`,
+		method: 'GET',
+		params,
+		signal,
+	});
+};
+
+export const getGetChecksQueryKey = (params?: GetChecksParams) => {
+	return [
+		`/api/v2/infra_monitoring/checks`,
+		...(params ? [params] : []),
+	] as const;
+};
+
+export const getGetChecksQueryOptions = <
+	TData = Awaited<ReturnType<typeof getChecks>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	params: GetChecksParams,
+	options?: {
+		query?: UseQueryOptions<Awaited<ReturnType<typeof getChecks>>, TError, TData>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetChecksQueryKey(params);
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getChecks>>> = ({
+		signal,
+	}) => getChecks(params, signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof getChecks>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetChecksQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getChecks>>
+>;
+export type GetChecksQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Run Infra Monitoring Setup Checks
+ */
+
+export function useGetChecks<
+	TData = Awaited<ReturnType<typeof getChecks>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	params: GetChecksParams,
+	options?: {
+		query?: UseQueryOptions<Awaited<ReturnType<typeof getChecks>>, TError, TData>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetChecksQueryOptions(params, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary Run Infra Monitoring Setup Checks
+ */
+export const invalidateGetChecks = async (
+	queryClient: QueryClient,
+	params: GetChecksParams,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetChecksQueryKey(params) },
+		options,
+	);
+
+	return queryClient;
+};
+
 /**
  * Returns a paginated list of Kubernetes clusters with key aggregated metrics derived by summing per-node values within the group: CPU usage, CPU allocatable, memory working set, memory allocatable. Each row also reports per-group nodeCountsByReadiness ({ ready, notReady } from each node's latest k8s.node.condition_ready value) and per-group podCountsByPhase ({ pending, running, succeeded, failed, unknown } from each pod's latest k8s.pod.phase value). Each cluster includes metadata attributes (k8s.cluster.name). The response type is 'list' for the default k8s.cluster.name grouping or 'grouped_list' for custom groupBy keys; in both modes every row aggregates nodes and pods in the group. Supports filtering via a filter expression, custom groupBy, ordering by cpu / cpu_allocatable / memory / memory_allocatable, and pagination via offset/limit. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (clusterCPU, clusterCPUAllocatable, clusterMemory, clusterMemoryAllocatable) return -1 as a sentinel when no data is available for that field.
  * @summary List Clusters for Infra Monitoring

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -5458,6 +5458,121 @@ export interface GlobaltypesConfigDTO {
 	mcp_url: string | null;
 }
 
+export enum InframonitoringtypesCheckComponentTypeDTO {
+	receiver = 'receiver',
+	processor = 'processor',
+}
+export interface InframonitoringtypesAssociatedComponentDTO {
+	/**
+	 * @type string
+	 */
+	name: string;
+	type: InframonitoringtypesCheckComponentTypeDTO;
+}
+
+export interface InframonitoringtypesAttributesComponentEntryDTO {
+	associatedComponent: InframonitoringtypesAssociatedComponentDTO;
+	/**
+	 * @type array,null
+	 */
+	attributes: string[] | null;
+}
+
+export enum InframonitoringtypesCheckTypeDTO {
+	hosts = 'hosts',
+	processes = 'processes',
+	pods = 'pods',
+	nodes = 'nodes',
+	deployments = 'deployments',
+	daemonsets = 'daemonsets',
+	statefulsets = 'statefulsets',
+	jobs = 'jobs',
+	namespaces = 'namespaces',
+	clusters = 'clusters',
+	volumes = 'volumes',
+}
+export interface InframonitoringtypesMissingMetricsComponentEntryDTO {
+	associatedComponent: InframonitoringtypesAssociatedComponentDTO;
+	/**
+	 * @type string
+	 */
+	documentationLink: string;
+	/**
+	 * @type string
+	 */
+	message: string;
+	/**
+	 * @type array,null
+	 */
+	metrics: string[] | null;
+}
+
+export interface InframonitoringtypesMissingAttributesComponentEntryDTO {
+	associatedComponent: InframonitoringtypesAssociatedComponentDTO;
+	/**
+	 * @type array,null
+	 */
+	attributes: string[] | null;
+	/**
+	 * @type string
+	 */
+	documentationLink: string;
+	/**
+	 * @type string
+	 */
+	message: string;
+}
+
+export interface InframonitoringtypesMetricsComponentEntryDTO {
+	associatedComponent: InframonitoringtypesAssociatedComponentDTO;
+	/**
+	 * @type array,null
+	 */
+	metrics: string[] | null;
+}
+
+export interface InframonitoringtypesChecksDTO {
+	/**
+	 * @type array,null
+	 */
+	missingDefaultEnabledMetrics:
+		| InframonitoringtypesMissingMetricsComponentEntryDTO[]
+		| null;
+	/**
+	 * @type array,null
+	 */
+	missingOptionalMetrics:
+		| InframonitoringtypesMissingMetricsComponentEntryDTO[]
+		| null;
+	/**
+	 * @type array,null
+	 */
+	missingRequiredAttributes:
+		| InframonitoringtypesMissingAttributesComponentEntryDTO[]
+		| null;
+	/**
+	 * @type array,null
+	 */
+	presentDefaultEnabledMetrics:
+		| InframonitoringtypesMetricsComponentEntryDTO[]
+		| null;
+	/**
+	 * @type array,null
+	 */
+	presentOptionalMetrics: InframonitoringtypesMetricsComponentEntryDTO[] | null;
+	/**
+	 * @type array,null
+	 */
+	presentRequiredAttributes:
+		| InframonitoringtypesAttributesComponentEntryDTO[]
+		| null;
+	/**
+	 * @type boolean
+	 */
+	ready: boolean;
+	type: InframonitoringtypesCheckTypeDTO;
+}
+
 export type InframonitoringtypesClusterRecordDTOMetaAnyOf = {
 	[key: string]: string;
 };
@@ -10246,6 +10361,21 @@ export type Healthz503 = {
 	status: string;
 };
 
+export type GetChecksParams = {
+	/**
+	 * @description undefined
+	 */
+	type: InframonitoringtypesCheckTypeDTO;
+};
+
+export type GetChecks200 = {
+	data: InframonitoringtypesChecksDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type ListClusters200 = {
 	data: InframonitoringtypesClustersDTO;
 	/**

pkg/apiserver/signozapiserver/inframonitoring.go

@@ -200,5 +200,23 @@ func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v2/infra_monitoring/checks", handler.New(
+		provider.authzMiddleware.ViewAccess(provider.infraMonitoringHandler.GetChecks),
+		handler.OpenAPIDef{
+			ID:                  "GetChecks",
+			Tags:                []string{"inframonitoring"},
+			Summary:             "Run Infra Monitoring Setup Checks",
+			Description:         "Checks whether the metrics and attributes required to power the infra-monitoring section selected by the 'type' query parameter (hosts, processes, pods, nodes, deployments, daemonsets, statefulsets, jobs, namespaces, clusters, volumes) are being received. For each collector receiver or processor that contributes required metrics or attributes, lists what is present and what is missing, with a prebuilt user-facing message and a docs link per missing component. Default-enabled metrics are those expected as soon as the receiver is configured; optional metrics require 'enabled: true' in receiver config. 'ready' is true only when every missing list is empty.",
+			RequestQuery:        new(inframonitoringtypes.PostableChecks),
+			Response:            new(inframonitoringtypes.Checks),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
 	return nil
 }

pkg/modules/inframonitoring/implinframonitoring/checks.go

@@ -0,0 +1,114 @@
+package implinframonitoring
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+)
+
+// splitBucket partitions one component bucket's metric and attribute lists
+// against the module-wide missing sets into up to six response entries.
+// Empty partitions are left nil so callers can skip them.
+func splitBucket(b checkComponentBucket, missingMetrics, missingAttrs map[string]bool) bucketSplit {
+	var s bucketSplit
+	presentDef, missDef := partitionList(b.DefaultMetrics, missingMetrics)
+	if len(presentDef) > 0 {
+		s.PresentDefault = &inframonitoringtypes.MetricsComponentEntry{
+			Metrics:             presentDef,
+			AssociatedComponent: b.Component,
+		}
+	}
+	if len(missDef) > 0 {
+		s.MissingDefault = &inframonitoringtypes.MissingMetricsComponentEntry{
+			MetricsComponentEntry: inframonitoringtypes.MetricsComponentEntry{
+				Metrics:             missDef,
+				AssociatedComponent: b.Component,
+			},
+			Message:           buildMissingDefaultMetricsMessage(missDef, b.Component.Name),
+			DocumentationLink: b.DocumentationLink,
+		}
+	}
+
+	presentOpt, missOpt := partitionList(b.OptionalMetrics, missingMetrics)
+	if len(presentOpt) > 0 {
+		s.PresentOptional = &inframonitoringtypes.MetricsComponentEntry{
+			Metrics:             presentOpt,
+			AssociatedComponent: b.Component,
+		}
+	}
+	if len(missOpt) > 0 {
+		s.MissingOptional = &inframonitoringtypes.MissingMetricsComponentEntry{
+			MetricsComponentEntry: inframonitoringtypes.MetricsComponentEntry{
+				Metrics:             missOpt,
+				AssociatedComponent: b.Component,
+			},
+			Message:           buildMissingOptionalMetricsMessage(missOpt, b.Component.Name),
+			DocumentationLink: b.DocumentationLink,
+		}
+	}
+
+	presentA, missA := partitionList(b.RequiredAttrs, missingAttrs)
+	if len(presentA) > 0 {
+		s.PresentAttrs = &inframonitoringtypes.AttributesComponentEntry{
+			Attributes:          presentA,
+			AssociatedComponent: b.Component,
+		}
+	}
+	if len(missA) > 0 {
+		s.MissingAttrs = &inframonitoringtypes.MissingAttributesComponentEntry{
+			AttributesComponentEntry: inframonitoringtypes.AttributesComponentEntry{
+				Attributes:          missA,
+				AssociatedComponent: b.Component,
+			},
+			Message:           buildMissingRequiredAttrsMessage(missA, b.Component.Name),
+			DocumentationLink: b.DocumentationLink,
+		}
+	}
+
+	return s
+}
+
+// getSpecForType returns the checkSpec for a given CheckType, or an error if the type is invalid.
+func getSpecForType(t inframonitoringtypes.CheckType) (*checkSpec, error) {
+	spec, ok := checkSpecs[t]
+	if !ok {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "no checks spec for type: %s", t)
+	}
+	return &spec, nil
+}
+
+// partitionList splits items into those NOT in `missing` and those in `missing`.
+// Preserves input order.
+func partitionList(items []string, missing map[string]bool) (present, miss []string) {
+	for _, x := range items {
+		if missing[x] {
+			miss = append(miss, x)
+		} else {
+			present = append(present, x)
+		}
+	}
+	return present, miss
+}
+
+func buildMissingDefaultMetricsMessage(metrics []string, componentName string) string {
+	return fmt.Sprintf(
+		"Missing default metrics %s from %s. Learn how to configure here.",
+		strings.Join(metrics, ", "), componentName,
+	)
+}
+
+func buildMissingOptionalMetricsMessage(metrics []string, componentName string) string {
+	return fmt.Sprintf(
+		"Missing optional metrics %s from %s. Learn how to enable here.",
+		strings.Join(metrics, ", "), componentName,
+	)
+}
+
+func buildMissingRequiredAttrsMessage(attrs []string, componentName string) string {
+	return fmt.Sprintf(
+		"Missing required attributes %s from %s. Learn how to configure here.",
+		strings.Join(attrs, ", "), componentName,
+	)
+}

pkg/modules/inframonitoring/implinframonitoring/checks_constants.go

@@ -0,0 +1,397 @@
+package implinframonitoring
+
+import "github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+
+// Component names — the 5 OTel collector receivers/processors that produce
+// metrics and resource attributes consumed by infra-monitoring tabs. Bare
+// strings on purpose (not wrapped enums) — the list is open-ended enough that
+// an enum adds more friction than value.
+const (
+	componentNameHostMetricsReceiver        = "hostmetricsreceiver"
+	componentNameKubeletStatsReceiver       = "kubeletstatsreceiver"
+	componentNameK8sClusterReceiver         = "k8sclusterreceiver"
+	componentNameResourceDetectionProcessor = "resourcedetectionprocessor"
+	componentNameK8sAttributesProcessor     = "k8sattributesprocessor"
+)
+
+// Documentation links — one per component. User-facing; emitted on missing-entries.
+const (
+	docLinkHostMetricsReceiver        = "https://signoz.io/docs/infrastructure-monitoring/user-guides/hostmetrics/#configure-the-hostmetrics-receiver"
+	docLinkKubeletStatsReceiver       = "https://signoz.io/docs/infrastructure-monitoring/user-guides/k8s-metrics/#setup-kubelet-stats-receiver"
+	docLinkK8sClusterReceiver         = "https://signoz.io/docs/infrastructure-monitoring/user-guides/k8s-metrics/#setup-k8s-cluster-receiver"
+	docLinkResourceDetectionProcessor = "https://signoz.io/docs/infrastructure-monitoring/user-guides/hostmetrics/#configure-the-resourcedetection-processor"
+	docLinkK8sAttributesProcessor     = "https://signoz.io/docs/infrastructure-monitoring/user-guides/k8s-metrics/#3-setup-k8sattributesprocessor-to-enable-kubernetes-metadata"
+)
+
+var (
+	componentHostMetricsReceiver = inframonitoringtypes.AssociatedComponent{
+		Type: inframonitoringtypes.CheckComponentTypeReceiver,
+		Name: componentNameHostMetricsReceiver,
+	}
+	componentKubeletStatsReceiver = inframonitoringtypes.AssociatedComponent{
+		Type: inframonitoringtypes.CheckComponentTypeReceiver,
+		Name: componentNameKubeletStatsReceiver,
+	}
+	componentK8sClusterReceiver = inframonitoringtypes.AssociatedComponent{
+		Type: inframonitoringtypes.CheckComponentTypeReceiver,
+		Name: componentNameK8sClusterReceiver,
+	}
+	componentResourceDetectionProcessor = inframonitoringtypes.AssociatedComponent{
+		Type: inframonitoringtypes.CheckComponentTypeProcessor,
+		Name: componentNameResourceDetectionProcessor,
+	}
+	componentK8sAttributesProcessor = inframonitoringtypes.AssociatedComponent{
+		Type: inframonitoringtypes.CheckComponentTypeProcessor,
+		Name: componentNameK8sAttributesProcessor,
+	}
+)
+
+// checkSpecs is the single lookup table the module consults for a type's
+// readiness contract. Every CheckType value must have an entry here.
+var checkSpecs = map[inframonitoringtypes.CheckType]checkSpec{
+	inframonitoringtypes.CheckTypeHosts:        hostsSpec,
+	inframonitoringtypes.CheckTypeProcesses:    processesSpec,
+	inframonitoringtypes.CheckTypePods:         podsSpec,
+	inframonitoringtypes.CheckTypeNodes:        nodesSpec,
+	inframonitoringtypes.CheckTypeDeployments:  deploymentsSpec,
+	inframonitoringtypes.CheckTypeDaemonsets:   daemonsetsSpec,
+	inframonitoringtypes.CheckTypeStatefulsets: statefulsetsSpec,
+	inframonitoringtypes.CheckTypeJobs:         jobsSpec,
+	inframonitoringtypes.CheckTypeNamespaces:   namespacesSpec,
+	inframonitoringtypes.CheckTypeClusters:     clustersSpec,
+	inframonitoringtypes.CheckTypeVolumes:      volumesSpec,
+}
+
+// Per-type specs. Every metric and attribute is spelled out in its own spec
+// on purpose — no shared slices, no concatenation helpers. Repetition is
+// cheaper than indirection when auditing what each tab actually requires.
+
+var hostsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentHostMetricsReceiver,
+			DefaultMetrics: []string{
+				"system.cpu.time",
+				"system.memory.usage",
+				"system.cpu.load_average.15m",
+				"system.filesystem.usage",
+			},
+			DocumentationLink: docLinkHostMetricsReceiver,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"host.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var processesSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentHostMetricsReceiver,
+			DefaultMetrics: []string{
+				"process.cpu.time",
+				"process.memory.usage",
+			},
+			RequiredAttrs:     []string{"process.pid"},
+			DocumentationLink: docLinkHostMetricsReceiver,
+		},
+	},
+}
+
+var podsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			OptionalMetrics: []string{
+				"k8s.pod.cpu_request_utilization",
+				"k8s.pod.cpu_limit_utilization",
+				"k8s.pod.memory_request_utilization",
+				"k8s.pod.memory_limit_utilization",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component:         componentK8sClusterReceiver,
+			DefaultMetrics:    []string{"k8s.pod.phase"},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.pod.uid"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+	},
+}
+
+var nodesSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.node.cpu.usage",
+				"k8s.node.memory.working_set",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.node.allocatable_cpu",
+				"k8s.node.allocatable_memory", // k8s.node.allocatable_cpu and k8s.node.allocatable_memory are
+				// controlled by allocatable_types_to_report config option (Check // https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/4f9a578b210a6dcb9f9bf47942f27208b5765298/receiver/k8sclusterreceiver/metadata.yaml#L805-L806)
+				"k8s.node.condition_ready", // # k8s.node.condition_* metrics (k8s.node.condition_ready, k8s.node.condition_memory_pressure, etc) are controlled# by node_conditions_to_report config option.
+				//  By default, only k8s.node.condition_ready is enabled. (Check https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/4f9a578b210a6dcb9f9bf47942f27208b5765298/receiver/k8sclusterreceiver/metadata.yaml#L802)
+				"k8s.pod.phase", // pod counts per node by phase
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.node.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+	},
+}
+
+var deploymentsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			OptionalMetrics: []string{
+				"k8s.pod.cpu_request_utilization",
+				"k8s.pod.cpu_limit_utilization",
+				"k8s.pod.memory_request_utilization",
+				"k8s.pod.memory_limit_utilization",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.phase",
+				"k8s.deployment.desired",
+				"k8s.deployment.available",
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.deployment.name", "k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var daemonsetsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			OptionalMetrics: []string{
+				"k8s.pod.cpu_request_utilization",
+				"k8s.pod.cpu_limit_utilization",
+				"k8s.pod.memory_request_utilization",
+				"k8s.pod.memory_limit_utilization",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.phase",
+				"k8s.daemonset.desired_scheduled_nodes",
+				"k8s.daemonset.current_scheduled_nodes",
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.daemonset.name", "k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var statefulsetsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			OptionalMetrics: []string{
+				"k8s.pod.cpu_request_utilization",
+				"k8s.pod.cpu_limit_utilization",
+				"k8s.pod.memory_request_utilization",
+				"k8s.pod.memory_limit_utilization",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.phase",
+				"k8s.statefulset.desired_pods",
+				"k8s.statefulset.current_pods",
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.statefulset.name", "k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var jobsSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			OptionalMetrics: []string{
+				"k8s.pod.cpu_request_utilization",
+				"k8s.pod.cpu_limit_utilization",
+				"k8s.pod.memory_request_utilization",
+				"k8s.pod.memory_limit_utilization",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.phase",
+				"k8s.job.desired_successful_pods",
+				"k8s.job.active_pods",
+				"k8s.job.failed_pods",
+				"k8s.job.successful_pods",
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.job.name", "k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var namespacesSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.pod.cpu.usage",
+				"k8s.pod.memory.working_set",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component:         componentK8sClusterReceiver,
+			DefaultMetrics:    []string{"k8s.pod.phase"},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var clustersSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.node.cpu.usage",
+				"k8s.node.memory.working_set",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component: componentK8sClusterReceiver,
+			DefaultMetrics: []string{
+				"k8s.node.allocatable_cpu",
+				"k8s.node.allocatable_memory", //k8s.node.allocatable_cpu and k8s.node.allocatable_memory are
+				// controlled by allocatable_types_to_report config option (Check // https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/4f9a578b210a6dcb9f9bf47942f27208b5765298/receiver/k8sclusterreceiver/metadata.yaml#L805-L806)
+				"k8s.node.condition_ready", // node counts by readiness
+				"k8s.pod.phase",            // pod counts per cluster by phase
+			},
+			DocumentationLink: docLinkK8sClusterReceiver,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}
+
+var volumesSpec = checkSpec{
+	Buckets: []checkComponentBucket{
+		{
+			Component: componentKubeletStatsReceiver,
+			DefaultMetrics: []string{
+				"k8s.volume.available",
+				"k8s.volume.capacity",
+				"k8s.volume.inodes",
+				"k8s.volume.inodes.free",
+				"k8s.volume.inodes.used",
+			},
+			DocumentationLink: docLinkKubeletStatsReceiver,
+		},
+		{
+			Component:         componentK8sAttributesProcessor,
+			RequiredAttrs:     []string{"k8s.persistentvolumeclaim.name", "k8s.namespace.name"},
+			DocumentationLink: docLinkK8sAttributesProcessor,
+		},
+		{
+			Component:         componentResourceDetectionProcessor,
+			RequiredAttrs:     []string{"k8s.cluster.name"},
+			DocumentationLink: docLinkResourceDetectionProcessor,
+		},
+	},
+}

pkg/modules/inframonitoring/implinframonitoring/checks_test.go

@@ -0,0 +1,246 @@
+package implinframonitoring
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/stretchr/testify/require"
+)
+
+// Component used across splitBucket cases — it's a processor so the test
+// doesn't carry any receiver semantics.
+var testComponent = inframonitoringtypes.AssociatedComponent{
+	Type: inframonitoringtypes.CheckComponentTypeReceiver,
+	Name: "testreceiver",
+}
+
+const testDocLink = "https://example.com/docs"
+
+func TestSplitBucket(t *testing.T) {
+	type want struct {
+		presentDefault  []string
+		presentOptional []string
+		presentAttrs    []string
+		missingDefault  []string
+		missingOptional []string
+		missingAttrs    []string
+	}
+
+	tests := []struct {
+		name           string
+		bucket         checkComponentBucket
+		missingMetrics map[string]bool
+		missingAttrs   map[string]bool
+		want           want
+	}{
+		{
+			name:           "empty bucket — nothing to emit",
+			bucket:         checkComponentBucket{Component: testComponent, DocumentationLink: testDocLink},
+			missingMetrics: map[string]bool{},
+			missingAttrs:   map[string]bool{},
+			want:           want{},
+		},
+		{
+			name: "all default metrics present",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				DefaultMetrics:    []string{"m1", "m2"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{},
+			missingAttrs:   map[string]bool{},
+			want: want{
+				presentDefault: []string{"m1", "m2"},
+			},
+		},
+		{
+			name: "all default metrics missing",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				DefaultMetrics:    []string{"m1", "m2"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{"m1": true, "m2": true},
+			missingAttrs:   map[string]bool{},
+			want: want{
+				missingDefault: []string{"m1", "m2"},
+			},
+		},
+		{
+			name: "mixed default metrics",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				DefaultMetrics:    []string{"m1", "m2", "m3"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{"m2": true},
+			missingAttrs:   map[string]bool{},
+			want: want{
+				presentDefault: []string{"m1", "m3"},
+				missingDefault: []string{"m2"},
+			},
+		},
+		{
+			name: "only optional metrics — all missing",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				OptionalMetrics:   []string{"opt1", "opt2"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{"opt1": true, "opt2": true},
+			missingAttrs:   map[string]bool{},
+			want: want{
+				missingOptional: []string{"opt1", "opt2"},
+			},
+		},
+		{
+			name: "only required attrs — all present",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				RequiredAttrs:     []string{"a1", "a2"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{},
+			missingAttrs:   map[string]bool{},
+			want: want{
+				presentAttrs: []string{"a1", "a2"},
+			},
+		},
+		{
+			name: "only required attrs — all missing",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				RequiredAttrs:     []string{"a1"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{},
+			missingAttrs:   map[string]bool{"a1": true},
+			want: want{
+				missingAttrs: []string{"a1"},
+			},
+		},
+		{
+			name: "every dimension populated on both sides",
+			bucket: checkComponentBucket{
+				Component:         testComponent,
+				DefaultMetrics:    []string{"d1", "d2"},
+				OptionalMetrics:   []string{"o1", "o2"},
+				RequiredAttrs:     []string{"a1", "a2"},
+				DocumentationLink: testDocLink,
+			},
+			missingMetrics: map[string]bool{"d2": true, "o1": true},
+			missingAttrs:   map[string]bool{"a2": true},
+			want: want{
+				presentDefault:  []string{"d1"},
+				missingDefault:  []string{"d2"},
+				presentOptional: []string{"o2"},
+				missingOptional: []string{"o1"},
+				presentAttrs:    []string{"a1"},
+				missingAttrs:    []string{"a2"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := splitBucket(tt.bucket, tt.missingMetrics, tt.missingAttrs)
+
+			requireMetricsEntry(t, "presentDefault", got.PresentDefault, tt.want.presentDefault)
+			requireMetricsEntry(t, "presentOptional", got.PresentOptional, tt.want.presentOptional)
+			requireAttrsEntry(t, "presentAttrs", got.PresentAttrs, tt.want.presentAttrs)
+
+			requireMissingMetrics(t, "missingDefault", got.MissingDefault, tt.want.missingDefault)
+			requireMissingMetrics(t, "missingOptional", got.MissingOptional, tt.want.missingOptional)
+			requireMissingAttrs(t, "missingAttrs", got.MissingAttrs, tt.want.missingAttrs)
+		})
+	}
+}
+
+func TestPartitionList(t *testing.T) {
+	present, missing := partitionList(
+		[]string{"a", "b", "c", "d"},
+		map[string]bool{"b": true, "d": true},
+	)
+	require.Equal(t, []string{"a", "c"}, present)
+	require.Equal(t, []string{"b", "d"}, missing)
+}
+
+func TestMissingMessageTemplates(t *testing.T) {
+	require.Equal(t,
+		"Missing default metrics m1, m2 from comp. Learn how to configure here.",
+		buildMissingDefaultMetricsMessage([]string{"m1", "m2"}, "comp"),
+	)
+	require.Equal(t,
+		"Missing optional metrics m1 from comp. Learn how to enable here.",
+		buildMissingOptionalMetricsMessage([]string{"m1"}, "comp"),
+	)
+	require.Equal(t,
+		"Missing required attributes a1 from comp. Learn how to configure here.",
+		buildMissingRequiredAttrsMessage([]string{"a1"}, "comp"),
+	)
+	require.Equal(t,
+		"Missing required attributes a1, a2 from comp. Learn how to configure here.",
+		buildMissingRequiredAttrsMessage([]string{"a1", "a2"}, "comp"),
+	)
+}
+
+// TestChecksSpecs_CoverAllTypes ensures the spec map has an entry for
+// every CheckType — prevents silently shipping an checks type that
+// has no spec and would 500 at runtime.
+func TestChecksSpecs_CoverAllTypes(t *testing.T) {
+	for _, tp := range inframonitoringtypes.ValidCheckTypes {
+		_, ok := checkSpecs[tp]
+		require.True(t, ok, "missing checks spec for type %s", tp)
+	}
+	require.Len(t, checkSpecs, len(inframonitoringtypes.ValidCheckTypes))
+}
+
+// --- helpers ---
+
+func requireMetricsEntry(t *testing.T, name string, got *inframonitoringtypes.MetricsComponentEntry, wantMetrics []string) {
+	t.Helper()
+	if len(wantMetrics) == 0 {
+		require.Nil(t, got, name)
+		return
+	}
+	require.NotNil(t, got, name)
+	require.Equal(t, wantMetrics, got.Metrics, name)
+	require.Equal(t, testComponent, got.AssociatedComponent, name)
+}
+
+func requireAttrsEntry(t *testing.T, name string, got *inframonitoringtypes.AttributesComponentEntry, wantAttrs []string) {
+	t.Helper()
+	if len(wantAttrs) == 0 {
+		require.Nil(t, got, name)
+		return
+	}
+	require.NotNil(t, got, name)
+	require.Equal(t, wantAttrs, got.Attributes, name)
+	require.Equal(t, testComponent, got.AssociatedComponent, name)
+}
+
+func requireMissingMetrics(t *testing.T, name string, got *inframonitoringtypes.MissingMetricsComponentEntry, wantMetrics []string) {
+	t.Helper()
+	if len(wantMetrics) == 0 {
+		require.Nil(t, got, name)
+		return
+	}
+	require.NotNil(t, got, name)
+	require.Equal(t, wantMetrics, got.Metrics, name)
+	require.Equal(t, testComponent, got.AssociatedComponent, name)
+	require.NotEmpty(t, got.Message, name)
+	require.Equal(t, testDocLink, got.DocumentationLink, name)
+}
+
+func requireMissingAttrs(t *testing.T, name string, got *inframonitoringtypes.MissingAttributesComponentEntry, wantAttrs []string) {
+	t.Helper()
+	if len(wantAttrs) == 0 {
+		require.Nil(t, got, name)
+		return
+	}
+	require.NotNil(t, got, name)
+	require.Equal(t, wantAttrs, got.Attributes, name)
+	require.Equal(t, testComponent, got.AssociatedComponent, name)
+	require.NotEmpty(t, got.Message, name)
+	require.Equal(t, testDocLink, got.DocumentationLink, name)
+}

pkg/modules/inframonitoring/implinframonitoring/handler.go

@@ -22,6 +22,30 @@ func NewHandler(m inframonitoring.Module) inframonitoring.Handler {
 	}
 }
 
+func (h *handler) GetChecks(rw http.ResponseWriter, req *http.Request) {
+	claims, err := authtypes.ClaimsFromContext(req.Context())
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID := valuer.MustNewUUID(claims.OrgID)
+
+	var parsedReq inframonitoringtypes.PostableChecks
+	if err := binding.Query.BindQuery(req.URL.Query(), &parsedReq); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.GetChecks(req.Context(), orgID, &parsedReq)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
+
 func (h *handler) ListHosts(rw http.ResponseWriter, req *http.Request) {
 	claims, err := authtypes.ClaimsFromContext(req.Context())
 	if err != nil {

pkg/modules/inframonitoring/implinframonitoring/helpers.go

@@ -473,6 +473,96 @@ func (m *module) getMetricsExistenceAndEarliestTime(ctx context.Context, metricN
 	return missingMetrics, globalMinFirstReported, nil
 }
 
+// getMetricsExistence returns, for each requested metric name, whether it has ever
+// been reported (present in signoz_metrics.distributed_metadata). No time window.
+func (m *module) getMetricsExistence(ctx context.Context, metricNames []string) (map[string]bool, error) {
+	present := make(map[string]bool, len(metricNames))
+	for _, n := range metricNames {
+		present[n] = false
+	}
+	if len(metricNames) == 0 {
+		return present, nil
+	}
+
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select("metric_name", "count(*) AS cnt")
+	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
+	sb.GroupBy("metric_name")
+
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var name string
+		var cnt uint64
+		if err := rows.Scan(&name, &cnt); err != nil {
+			return nil, err
+		}
+		if cnt > 0 {
+			present[name] = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return present, nil
+}
+
+// getAttributesExistence returns, for each requested attrName, whether it has ever
+// been reported as a label on any of the given metricNames. Presence is checked
+// against distributed_metadata without a time-range filter.
+func (m *module) getAttributesExistence(ctx context.Context, metricNames, attrNames []string) (map[string]bool, error) {
+	present := make(map[string]bool, len(attrNames))
+	for _, a := range attrNames {
+		present[a] = false
+	}
+	if len(attrNames) == 0 {
+		return present, nil
+	}
+	if len(metricNames) == 0 {
+		return nil, errors.NewInternalf(errors.CodeInternal, "getAttributesExistence: metricNames must not be empty")
+	}
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select("attr_name", "count(*) AS cnt")
+	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.Where(
+		sb.In("metric_name", sqlbuilder.List(metricNames)),
+		sb.In("attr_name", sqlbuilder.List(attrNames)),
+	)
+	sb.GroupBy("attr_name")
+
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var name string
+		var cnt uint64
+		if err := rows.Scan(&name, &cnt); err != nil {
+			return nil, err
+		}
+		if name != "" && cnt > 0 {
+			present[name] = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return present, nil
+}
+
 // getMetadata fetches the latest values of additionalCols for each unique combination of groupBy keys,
 // within the given time range and metric names. It uses argMax(tuple(...), unix_milli) to ensure
 // we always pick attribute values from the latest timestamp for each group.

pkg/modules/inframonitoring/implinframonitoring/internaltypes.go

@@ -1,5 +1,7 @@
 package implinframonitoring
 
+import "github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+
 // The types in this file are only used within the implinframonitoring package, and are not exposed outside.
 // They are primarily used for internal processing and structuring of data within the module's implementation.
 
@@ -29,3 +31,50 @@ type nodeConditionCounts struct {
 	Ready    int
 	NotReady int
 }
+
+// bucketSplit carries the up-to-six entries a single spec bucket contributes
+// to an checks response. Any field may be nil if the bucket doesn't
+// populate that dimension.
+type bucketSplit struct {
+	PresentDefault  *inframonitoringtypes.MetricsComponentEntry
+	PresentOptional *inframonitoringtypes.MetricsComponentEntry
+	PresentAttrs    *inframonitoringtypes.AttributesComponentEntry
+	MissingDefault  *inframonitoringtypes.MissingMetricsComponentEntry
+	MissingOptional *inframonitoringtypes.MissingMetricsComponentEntry
+	MissingAttrs    *inframonitoringtypes.MissingAttributesComponentEntry
+}
+
+// checkComponentBucket is a single collector component's contribution
+// toward a single infra-monitoring tab's readiness. Any of the three dimension
+// slices (DefaultMetrics, OptionalMetrics, RequiredAttrs) may be empty — the
+// bucketizer in Phase 4 skips empty dimensions.
+type checkComponentBucket struct {
+	Component         inframonitoringtypes.AssociatedComponent
+	DefaultMetrics    []string
+	OptionalMetrics   []string
+	RequiredAttrs     []string
+	DocumentationLink string
+}
+
+// checkSpec defines, for one CheckType, the full set of
+// component-scoped buckets that must be satisfied for the tab to be ready.
+type checkSpec struct {
+	Buckets []checkComponentBucket
+}
+
+func (s checkSpec) getAllMetrics() []string {
+	var out []string
+	for _, b := range s.Buckets {
+		out = append(out, b.DefaultMetrics...)
+		out = append(out, b.OptionalMetrics...)
+	}
+	return out
+}
+
+func (s checkSpec) getAllAttrs() []string {
+	var out []string
+	for _, b := range s.Buckets {
+		out = append(out, b.RequiredAttrs...)
+	}
+	return out
+}

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -49,6 +49,84 @@ func NewModule(
 	}
 }
 
+// GetChecks runs a per-type readiness check: for the requested
+// infra-monitoring tab, reports which required metrics and attributes are
+// present vs missing, grouped by the collector component that produces them.
+// Ready is true iff every missing list is empty.
+func (m *module) GetChecks(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableChecks) (*inframonitoringtypes.Checks, error) {
+	if err := req.Validate(); err != nil {
+		return nil, err
+	}
+
+	spec, err := getSpecForType(req.Type)
+	if err != nil {
+		return nil, err
+	}
+
+	allMetrics := spec.getAllMetrics()
+	allAttrs := spec.getAllAttrs()
+
+	presentMetrics, err := m.getMetricsExistence(ctx, allMetrics)
+	if err != nil {
+		return nil, err
+	}
+	missingMetricsMap := make(map[string]bool, len(allMetrics))
+	for _, name := range allMetrics {
+		if !presentMetrics[name] {
+			missingMetricsMap[name] = true
+		}
+	}
+
+	presentAttrs, err := m.getAttributesExistence(ctx, allMetrics, allAttrs)
+	if err != nil {
+		return nil, err
+	}
+	missingAttrsMap := make(map[string]bool, len(allAttrs))
+	for _, name := range allAttrs {
+		if !presentAttrs[name] {
+			missingAttrsMap[name] = true
+		}
+	}
+
+	resp := &inframonitoringtypes.Checks{
+		Type:                         req.Type,
+		PresentDefaultEnabledMetrics: []inframonitoringtypes.MetricsComponentEntry{},
+		PresentOptionalMetrics:       []inframonitoringtypes.MetricsComponentEntry{},
+		PresentRequiredAttributes:    []inframonitoringtypes.AttributesComponentEntry{},
+		MissingDefaultEnabledMetrics: []inframonitoringtypes.MissingMetricsComponentEntry{},
+		MissingOptionalMetrics:       []inframonitoringtypes.MissingMetricsComponentEntry{},
+		MissingRequiredAttributes:    []inframonitoringtypes.MissingAttributesComponentEntry{},
+	}
+
+	for _, b := range spec.Buckets {
+		s := splitBucket(b, missingMetricsMap, missingAttrsMap)
+		if s.PresentDefault != nil {
+			resp.PresentDefaultEnabledMetrics = append(resp.PresentDefaultEnabledMetrics, *s.PresentDefault)
+		}
+		if s.PresentOptional != nil {
+			resp.PresentOptionalMetrics = append(resp.PresentOptionalMetrics, *s.PresentOptional)
+		}
+		if s.PresentAttrs != nil {
+			resp.PresentRequiredAttributes = append(resp.PresentRequiredAttributes, *s.PresentAttrs)
+		}
+		if s.MissingDefault != nil {
+			resp.MissingDefaultEnabledMetrics = append(resp.MissingDefaultEnabledMetrics, *s.MissingDefault)
+		}
+		if s.MissingOptional != nil {
+			resp.MissingOptionalMetrics = append(resp.MissingOptionalMetrics, *s.MissingOptional)
+		}
+		if s.MissingAttrs != nil {
+			resp.MissingRequiredAttributes = append(resp.MissingRequiredAttributes, *s.MissingAttrs)
+		}
+	}
+
+	resp.Ready = len(resp.MissingDefaultEnabledMetrics) == 0 &&
+		len(resp.MissingOptionalMetrics) == 0 &&
+		len(resp.MissingRequiredAttributes) == 0
+
+	return resp, nil
+}
+
 func (m *module) ListHosts(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableHosts) (*inframonitoringtypes.Hosts, error) {
 	ctx = m.withInfraMonitoringContext(ctx, "ListHosts")
 

pkg/modules/inframonitoring/inframonitoring.go

@@ -20,6 +20,7 @@ type Handler interface {
 	ListStatefulSets(http.ResponseWriter, *http.Request)
 	ListJobs(http.ResponseWriter, *http.Request)
 	ListDaemonSets(http.ResponseWriter, *http.Request)
+	GetChecks(http.ResponseWriter, *http.Request)
 }
 
 type Module interface {
@@ -34,4 +35,5 @@ type Module interface {
 	ListStatefulSets(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableStatefulSets) (*inframonitoringtypes.StatefulSets, error)
 	ListJobs(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableJobs) (*inframonitoringtypes.Jobs, error)
 	ListDaemonSets(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableDaemonSets) (*inframonitoringtypes.DaemonSets, error)
+	GetChecks(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableChecks) (*inframonitoringtypes.Checks, error)
 }

pkg/types/inframonitoringtypes/checks.go

@@ -0,0 +1,83 @@
+package inframonitoringtypes
+
+import (
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// PostableChecks is the request for GET /api/v2/infra_monitoring/checks.
+// The single `type` query param selects which infra-monitoring subsection the
+// readiness check runs for.
+type PostableChecks struct {
+	Type CheckType `query:"type" required:"true"`
+}
+
+// Validate rejects empty/unknown checks types.
+func (req *PostableChecks) Validate() error {
+	if req == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
+	}
+
+	if req.Type.IsZero() {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "type is required")
+	}
+
+	if !slices.Contains(ValidCheckTypes, req.Type) {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid type: %s", req.Type)
+	}
+
+	return nil
+}
+
+// Checks is the response for GET /api/v2/infra_monitoring/checks.
+//
+// The three present/missing pairs partition a type's requirements into three
+// dimensions — default-enabled metrics, optional metrics, required attributes —
+// each bucketed by the collector component (receiver or processor) that
+// produces it. Ready is true iff every Missing* array is empty.
+type Checks struct {
+	Type                         CheckType                         `json:"type" required:"true"`
+	Ready                        bool                              `json:"ready" required:"true"`
+	PresentDefaultEnabledMetrics []MetricsComponentEntry           `json:"presentDefaultEnabledMetrics" required:"true"`
+	PresentOptionalMetrics       []MetricsComponentEntry           `json:"presentOptionalMetrics" required:"true"`
+	PresentRequiredAttributes    []AttributesComponentEntry        `json:"presentRequiredAttributes" required:"true"`
+	MissingDefaultEnabledMetrics []MissingMetricsComponentEntry    `json:"missingDefaultEnabledMetrics" required:"true"`
+	MissingOptionalMetrics       []MissingMetricsComponentEntry    `json:"missingOptionalMetrics" required:"true"`
+	MissingRequiredAttributes    []MissingAttributesComponentEntry `json:"missingRequiredAttributes" required:"true"`
+}
+
+// AssociatedComponent identifies the collector receiver or processor that a
+// metric or attribute originates from. Name is free-form (e.g. "kubeletstatsreceiver").
+type AssociatedComponent struct {
+	Type CheckComponentType `json:"type" required:"true"`
+	Name string             `json:"name" required:"true"`
+}
+
+// MetricsComponentEntry lists metrics that share a single associated component.
+type MetricsComponentEntry struct {
+	Metrics             []string            `json:"metrics" required:"true"`
+	AssociatedComponent AssociatedComponent `json:"associatedComponent" required:"true"`
+}
+
+// AttributesComponentEntry lists resource attributes that share a single associated component.
+type AttributesComponentEntry struct {
+	Attributes          []string            `json:"attributes" required:"true"`
+	AssociatedComponent AssociatedComponent `json:"associatedComponent" required:"true"`
+}
+
+// MissingMetricsComponentEntry extends MetricsComponentEntry with a user-facing
+// message and a docs link for fixing the missing metrics.
+type MissingMetricsComponentEntry struct {
+	MetricsComponentEntry
+	Message           string `json:"message" required:"true"`
+	DocumentationLink string `json:"documentationLink" required:"true"`
+}
+
+// MissingAttributesComponentEntry extends AttributesComponentEntry with a user-facing
+// message and a docs link for fixing the missing attributes.
+type MissingAttributesComponentEntry struct {
+	AttributesComponentEntry
+	Message           string `json:"message" required:"true"`
+	DocumentationLink string `json:"documentationLink" required:"true"`
+}

pkg/types/inframonitoringtypes/checks_constants.go

@@ -0,0 +1,71 @@
+package inframonitoringtypes
+
+import "github.com/SigNoz/signoz/pkg/valuer"
+
+// CheckType identifies a single infra-monitoring subsection (UI tab).
+// One value per v1/v2 list API we surface in the infra-monitoring section.
+type CheckType struct {
+	valuer.String
+}
+
+var (
+	CheckTypeHosts        = CheckType{valuer.NewString("hosts")}
+	CheckTypeProcesses    = CheckType{valuer.NewString("processes")}
+	CheckTypePods         = CheckType{valuer.NewString("pods")}
+	CheckTypeNodes        = CheckType{valuer.NewString("nodes")}
+	CheckTypeDeployments  = CheckType{valuer.NewString("deployments")}
+	CheckTypeDaemonsets   = CheckType{valuer.NewString("daemonsets")}
+	CheckTypeStatefulsets = CheckType{valuer.NewString("statefulsets")}
+	CheckTypeJobs         = CheckType{valuer.NewString("jobs")}
+	CheckTypeNamespaces   = CheckType{valuer.NewString("namespaces")}
+	CheckTypeClusters     = CheckType{valuer.NewString("clusters")}
+	CheckTypeVolumes      = CheckType{valuer.NewString("volumes")}
+)
+
+func (CheckType) Enum() []any {
+	return []any{
+		CheckTypeHosts,
+		CheckTypeProcesses,
+		CheckTypePods,
+		CheckTypeNodes,
+		CheckTypeDeployments,
+		CheckTypeDaemonsets,
+		CheckTypeStatefulsets,
+		CheckTypeJobs,
+		CheckTypeNamespaces,
+		CheckTypeClusters,
+		CheckTypeVolumes,
+	}
+}
+
+var ValidCheckTypes = []CheckType{
+	CheckTypeHosts,
+	CheckTypeProcesses,
+	CheckTypePods,
+	CheckTypeNodes,
+	CheckTypeDeployments,
+	CheckTypeDaemonsets,
+	CheckTypeStatefulsets,
+	CheckTypeJobs,
+	CheckTypeNamespaces,
+	CheckTypeClusters,
+	CheckTypeVolumes,
+}
+
+// CheckComponentType tags each AssociatedComponent as either a receiver or a processor.
+// Only these two values are ever written by the module.
+type CheckComponentType struct {
+	valuer.String
+}
+
+var (
+	CheckComponentTypeReceiver  = CheckComponentType{valuer.NewString("receiver")}
+	CheckComponentTypeProcessor = CheckComponentType{valuer.NewString("processor")}
+)
+
+func (CheckComponentType) Enum() []any {
+	return []any{
+		CheckComponentTypeReceiver,
+		CheckComponentTypeProcessor,
+	}
+}

pkg/types/inframonitoringtypes/checks_test.go

@@ -0,0 +1,110 @@
+package inframonitoringtypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostableChecks_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *PostableChecks
+		wantErr bool
+	}{
+		{
+			name:    "nil request",
+			req:     nil,
+			wantErr: true,
+		},
+		{
+			name:    "empty type",
+			req:     &PostableChecks{},
+			wantErr: true,
+		},
+		{
+			name:    "unknown type",
+			req:     &PostableChecks{Type: CheckType{valuer.NewString("foo")}},
+			wantErr: true,
+		},
+		{
+			name:    "hosts",
+			req:     &PostableChecks{Type: CheckTypeHosts},
+			wantErr: false,
+		},
+		{
+			name:    "processes",
+			req:     &PostableChecks{Type: CheckTypeProcesses},
+			wantErr: false,
+		},
+		{
+			name:    "pods",
+			req:     &PostableChecks{Type: CheckTypePods},
+			wantErr: false,
+		},
+		{
+			name:    "nodes",
+			req:     &PostableChecks{Type: CheckTypeNodes},
+			wantErr: false,
+		},
+		{
+			name:    "deployments",
+			req:     &PostableChecks{Type: CheckTypeDeployments},
+			wantErr: false,
+		},
+		{
+			name:    "daemonsets",
+			req:     &PostableChecks{Type: CheckTypeDaemonsets},
+			wantErr: false,
+		},
+		{
+			name:    "statefulsets",
+			req:     &PostableChecks{Type: CheckTypeStatefulsets},
+			wantErr: false,
+		},
+		{
+			name:    "jobs",
+			req:     &PostableChecks{Type: CheckTypeJobs},
+			wantErr: false,
+		},
+		{
+			name:    "namespaces",
+			req:     &PostableChecks{Type: CheckTypeNamespaces},
+			wantErr: false,
+		},
+		{
+			name:    "clusters",
+			req:     &PostableChecks{Type: CheckTypeClusters},
+			wantErr: false,
+		},
+		{
+			name:    "volumes",
+			req:     &PostableChecks{Type: CheckTypeVolumes},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.req.Validate()
+			if tt.wantErr {
+				require.Error(t, err)
+				require.True(t, errors.Ast(err, errors.TypeInvalidInput), "expected error to be of type InvalidInput")
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+// TestValidCheckTypes_MatchesEnum ensures the ValidCheckTypes slice
+// stays in sync with the Enum() list — both must cover every CheckType value.
+func TestValidCheckTypes_MatchesEnum(t *testing.T) {
+	enum := CheckType{}.Enum()
+	require.Equal(t, len(enum), len(ValidCheckTypes))
+	for i, v := range enum {
+		require.Equal(t, v, ValidCheckTypes[i])
+	}
+}

tests/integration/tests/inframonitoring/11_checks.py

@@ -0,0 +1,327 @@
+"""Integration tests for the v2 infra-monitoring checks endpoint.
+
+GET /api/v2/infra_monitoring/checks?type=<t> reports per-tab readiness:
+for each collector component it lists which required/optional metrics and
+required attributes are present vs missing. `ready` is true iff every missing
+list is empty (optional gaps DO block).
+
+Presence is checked against distributed_metadata with NO time window
+(pkg/modules/inframonitoring/implinframonitoring/helpers.go:423,:479): a metric
+is present iff it was ever ingested; an attribute is present iff it appears as a
+label on any of that type's spec metrics. So seeding here is purely "make these
+(metric, label) rows exist" — no start/end, no value math. insert_metrics is
+function-scoped and truncates metadata on teardown, so (serial suite) each test
+sees only its own seeds.
+
+SPECS mirrors pkg/modules/inframonitoring/implinframonitoring/checks_constants.go
+and is the contract lock: if a Go spec changes, the matching assertion fails.
+"""
+
+from datetime import UTC, datetime
+from http import HTTPStatus
+
+import pytest
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.metrics import Metrics
+
+ENDPOINT = "/api/v2/infra_monitoring/checks"
+
+# Component names (checks_constants.go:9-15) + their type + docs link.
+HMR = "hostmetricsreceiver"
+KSR = "kubeletstatsreceiver"
+KCR = "k8sclusterreceiver"
+RDP = "resourcedetectionprocessor"
+KAP = "k8sattributesprocessor"
+
+COMPONENT_TYPE = {HMR: "receiver", KSR: "receiver", KCR: "receiver", RDP: "processor", KAP: "processor"}
+
+_PODS_OPT = [
+    "k8s.pod.cpu_request_utilization",
+    "k8s.pod.cpu_limit_utilization",
+    "k8s.pod.memory_request_utilization",
+    "k8s.pod.memory_limit_utilization",
+]
+
+# Mirror of checkSpecs: type -> {default|optional: {component: [metrics]}, attrs: {component: [attrs]}}.
+SPECS = {
+    "hosts": {
+        "default": {HMR: ["system.cpu.time", "system.memory.usage", "system.cpu.load_average.15m", "system.filesystem.usage"]},
+        "optional": {},
+        "attrs": {RDP: ["host.name"]},
+    },
+    "processes": {
+        "default": {HMR: ["process.cpu.time", "process.memory.usage"]},
+        "optional": {},
+        "attrs": {HMR: ["process.pid"]},
+    },
+    "pods": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase"]},
+        "optional": {KSR: list(_PODS_OPT)},
+        "attrs": {KAP: ["k8s.pod.uid"]},
+    },
+    "nodes": {
+        "default": {
+            KSR: ["k8s.node.cpu.usage", "k8s.node.memory.working_set"],
+            KCR: ["k8s.node.allocatable_cpu", "k8s.node.allocatable_memory", "k8s.node.condition_ready", "k8s.pod.phase"],
+        },
+        "optional": {},
+        "attrs": {KAP: ["k8s.node.name"]},
+    },
+    "deployments": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase", "k8s.deployment.desired", "k8s.deployment.available"]},
+        "optional": {KSR: list(_PODS_OPT)},
+        "attrs": {KAP: ["k8s.deployment.name", "k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+    "daemonsets": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase", "k8s.daemonset.desired_scheduled_nodes", "k8s.daemonset.current_scheduled_nodes"]},
+        "optional": {KSR: list(_PODS_OPT)},
+        "attrs": {KAP: ["k8s.daemonset.name", "k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+    "statefulsets": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase", "k8s.statefulset.desired_pods", "k8s.statefulset.current_pods"]},
+        "optional": {KSR: list(_PODS_OPT)},
+        "attrs": {KAP: ["k8s.statefulset.name", "k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+    "jobs": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase", "k8s.job.desired_successful_pods", "k8s.job.active_pods", "k8s.job.failed_pods", "k8s.job.successful_pods"]},
+        "optional": {KSR: list(_PODS_OPT)},
+        "attrs": {KAP: ["k8s.job.name", "k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+    "namespaces": {
+        "default": {KSR: ["k8s.pod.cpu.usage", "k8s.pod.memory.working_set"], KCR: ["k8s.pod.phase"]},
+        "optional": {},
+        "attrs": {KAP: ["k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+    "clusters": {
+        "default": {KSR: ["k8s.node.cpu.usage", "k8s.node.memory.working_set"], KCR: ["k8s.node.allocatable_cpu", "k8s.node.allocatable_memory", "k8s.node.condition_ready", "k8s.pod.phase"]},
+        "optional": {},
+        "attrs": {RDP: ["k8s.cluster.name"]},
+    },
+    "volumes": {
+        "default": {KSR: ["k8s.volume.available", "k8s.volume.capacity", "k8s.volume.inodes", "k8s.volume.inodes.free", "k8s.volume.inodes.used"]},
+        "optional": {},
+        "attrs": {KAP: ["k8s.persistentvolumeclaim.name", "k8s.namespace.name"], RDP: ["k8s.cluster.name"]},
+    },
+}
+
+ALL_TYPES = list(SPECS.keys())
+
+
+# --- helpers ---
+
+
+def _all(d: dict) -> list:
+    """Flatten a {component: [items]} map to a flat list."""
+    return [x for items in d.values() for x in items]
+
+
+def _all_metrics(t: str) -> list:
+    return _all(SPECS[t]["default"]) + _all(SPECS[t]["optional"])
+
+
+def _attr_labels(t: str, drop: str | None = None) -> dict:
+    """Labels carrying every required attr (so they resolve present), minus `drop`."""
+    return {a: f"v-{a}" for a in _all(SPECS[t]["attrs"]) if a != drop}
+
+
+# Marker label so every seeded metric registers in distributed_metadata even when
+# `labels` is empty (insert_metrics writes a metadata row per label). Non-spec, so it
+# is never counted as a present required attribute.
+_SEED_MARKER = {"test.seed.marker": "1"}
+
+
+def _seed(insert_metrics, metric_names: list, labels: dict) -> None:
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics([Metrics(metric_name=m, labels={**_SEED_MARKER, **labels}, timestamp=now, value=1.0) for m in metric_names])
+
+
+def _request(signoz: types.SigNoz, token: str, type_: str | None):
+    params = {} if type_ is None else {"type": type_}
+    return requests.get(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        params=params,
+        timeout=5,
+    )
+
+
+def _grouped(entries: list, field: str) -> dict:
+    """{component_name: set(items)} from a present/missing entry list; also asserts
+    each entry's associatedComponent.type matches the known component type."""
+    out: dict = {}
+    for e in entries:
+        comp = e["associatedComponent"]
+        assert comp["type"] == COMPONENT_TYPE[comp["name"]], f"wrong type for {comp!r}"
+        out.setdefault(comp["name"], set()).update(e[field])
+    return out
+
+
+def _exp(d: dict) -> dict:
+    return {comp: set(items) for comp, items in d.items()}
+
+
+def _check_missing_entries(entries: list) -> None:
+    """Every missing entry carries a non-empty message + a non-empty docs link
+    (exact link not asserted — links are subject to change)."""
+    for e in entries:
+        assert e["message"], f"empty message: {e!r}"
+        assert e["documentationLink"], f"empty doc link: {e!r}"
+
+
+# Parametrize cases derived from SPECS.
+_DEFAULT_CASES = [  # one representative dropped default metric per type
+    pytest.param(t, comp, ms[0], id=f"{t}-{ms[0]}") for t in ALL_TYPES for comp, ms in [next(iter(SPECS[t]["default"].items()))]
+]
+_OPTIONAL_CASES = [  # types that have optional metrics
+    pytest.param(t, comp, ms[0], id=f"{t}-{ms[0]}") for t in ALL_TYPES for comp, ms in SPECS[t]["optional"].items() if ms
+]
+_ATTR_CASES = [pytest.param(t, comp, a, id=f"{t}-{a}") for t in ALL_TYPES for comp, attrs in SPECS[t]["attrs"].items() for a in attrs]
+
+
+@pytest.mark.parametrize(
+    "type_,err_substr",
+    [
+        pytest.param(None, "type is required", id="missing_type"),
+        pytest.param("foo", "invalid type", id="invalid_type"),
+    ],
+)
+def test_checks_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    type_,
+    err_substr: str,
+) -> None:
+    """Missing/unknown `type` query param → 400 invalid_input."""
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = _request(signoz, token, type_)
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    error = response.json()["error"]
+    assert error["code"] == "invalid_input"
+
+
+@pytest.mark.parametrize("type_", ALL_TYPES)
+def test_checks_empty_backend(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,  # noqa: ARG001  ensures metadata is truncated around this test
+    type_: str,
+) -> None:
+    """No data ingested → not ready; every default metric + required attr reported
+    missing (bucketed by component, with message + docs link); present lists empty."""
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    data = _request(signoz, token, type_).json()["data"]
+
+    assert data["ready"] is False
+    assert data["presentDefaultEnabledMetrics"] == []
+    assert data["presentOptionalMetrics"] == []
+    assert data["presentRequiredAttributes"] == []
+    assert _grouped(data["missingDefaultEnabledMetrics"], "metrics") == _exp(SPECS[type_]["default"])
+    assert _grouped(data["missingOptionalMetrics"], "metrics") == _exp(SPECS[type_]["optional"])
+    assert _grouped(data["missingRequiredAttributes"], "attributes") == _exp(SPECS[type_]["attrs"])
+    _check_missing_entries(data["missingDefaultEnabledMetrics"])
+    _check_missing_entries(data["missingOptionalMetrics"])
+    _check_missing_entries(data["missingRequiredAttributes"])
+
+
+@pytest.mark.parametrize("type_", ALL_TYPES)
+def test_checks_all_present_ready(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    type_: str,
+) -> None:
+    """Every default+optional metric seeded carrying all required attrs → ready;
+    present buckets exactly match the spec, all missing lists empty."""
+    _seed(insert_metrics, _all_metrics(type_), _attr_labels(type_))
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    data = _request(signoz, token, type_).json()["data"]
+
+    assert data["type"] == type_
+    assert data["ready"] is True
+    assert data["missingDefaultEnabledMetrics"] == []
+    assert data["missingOptionalMetrics"] == []
+    assert data["missingRequiredAttributes"] == []
+    assert _grouped(data["presentDefaultEnabledMetrics"], "metrics") == _exp(SPECS[type_]["default"])
+    assert _grouped(data["presentOptionalMetrics"], "metrics") == _exp(SPECS[type_]["optional"])
+    assert _grouped(data["presentRequiredAttributes"], "attributes") == _exp(SPECS[type_]["attrs"])
+
+
+@pytest.mark.parametrize("type_,component,metric", _DEFAULT_CASES)
+def test_checks_missing_default_metric(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    type_: str,
+    component: str,
+    metric: str,
+) -> None:
+    """One default metric never ingested (everything else present) → that metric is
+    in missingDefaultEnabledMetrics under its component; not ready."""
+    seed = [m for m in _all_metrics(type_) if m != metric]
+    _seed(insert_metrics, seed, _attr_labels(type_))
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    data = _request(signoz, token, type_).json()["data"]
+
+    assert data["ready"] is False
+    assert metric in _grouped(data["missingDefaultEnabledMetrics"], "metrics").get(component, set())
+    assert data["missingOptionalMetrics"] == []
+    assert data["missingRequiredAttributes"] == []
+    _check_missing_entries(data["missingDefaultEnabledMetrics"])
+
+
+@pytest.mark.parametrize("type_,component,metric", _OPTIONAL_CASES)
+def test_checks_missing_optional_metric(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    type_: str,
+    component: str,
+    metric: str,
+) -> None:
+    """One optional metric missing → reported in missingOptionalMetrics and (locked
+    decision) NOT ready, even though all default metrics + attrs are present."""
+    seed = [m for m in _all_metrics(type_) if m != metric]
+    _seed(insert_metrics, seed, _attr_labels(type_))
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    data = _request(signoz, token, type_).json()["data"]
+
+    assert data["ready"] is False
+    assert metric in _grouped(data["missingOptionalMetrics"], "metrics").get(component, set())
+    assert data["missingDefaultEnabledMetrics"] == []
+    assert data["missingRequiredAttributes"] == []
+    _check_missing_entries(data["missingOptionalMetrics"])
+
+
+@pytest.mark.parametrize("type_,component,attr", _ATTR_CASES)
+def test_checks_missing_required_attribute(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    type_: str,
+    component: str,
+    attr: str,
+) -> None:
+    """All metrics present but one required attr never seen on any of them → that
+    attr is in missingRequiredAttributes under its component; not ready."""
+    _seed(insert_metrics, _all_metrics(type_), _attr_labels(type_, drop=attr))
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    data = _request(signoz, token, type_).json()["data"]
+
+    assert data["ready"] is False
+    assert attr in _grouped(data["missingRequiredAttributes"], "attributes").get(component, set())
+    assert data["missingDefaultEnabledMetrics"] == []
+    assert data["missingOptionalMetrics"] == []
+    _check_missing_entries(data["missingRequiredAttributes"])