chore: nodes list v2 full blown

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

cmd/enterprise/server.go

@@ -167,7 +167,7 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			if err != nil {
 				return nil, err
 			}
-			azureCloudProviderModule := implcloudprovider.NewAzureCloudProvider(defStore)
+			azureCloudProviderModule := implcloudprovider.NewAzureCloudProvider()
 			cloudProvidersMap := map[cloudintegrationtypes.CloudProviderType]cloudintegration.CloudProviderModule{
 				cloudintegrationtypes.CloudProviderTypeAWS:   awsCloudProviderModule,
 				cloudintegrationtypes.CloudProviderTypeAzure: azureCloudProviderModule,

ee/modules/cloudintegration/implcloudintegration/implcloudprovider/awscloudprovider.go

@@ -18,7 +18,6 @@ func NewAWSCloudProvider(defStore cloudintegrationtypes.ServiceDefinitionStore)
 	return &awscloudprovider{serviceDefinitions: defStore}, nil
 }
 
-// TODO: move URL construction logic to cloudintegrationtypes and add unit tests for it.
 func (provider *awscloudprovider) GetConnectionArtifact(ctx context.Context, account *cloudintegrationtypes.Account, req *cloudintegrationtypes.GetConnectionArtifactRequest) (*cloudintegrationtypes.ConnectionArtifact, error) {
 	baseURL := fmt.Sprintf(cloudintegrationtypes.CloudFormationQuickCreateBaseURL.StringValue(), req.Config.AWS.DeploymentRegion)
 	u, _ := url.Parse(baseURL)

ee/modules/cloudintegration/implcloudintegration/implcloudprovider/azurecloudprovider.go

@@ -2,48 +2,27 @@ package implcloudprovider
 
 import (
 	"context"
-	"sort"
 
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
 )
 
-type azurecloudprovider struct {
-	serviceDefinitions cloudintegrationtypes.ServiceDefinitionStore
-}
+type azurecloudprovider struct{}
 
-func NewAzureCloudProvider(defStore cloudintegrationtypes.ServiceDefinitionStore) cloudintegration.CloudProviderModule {
-	return &azurecloudprovider{
-		serviceDefinitions: defStore,
-	}
+func NewAzureCloudProvider() cloudintegration.CloudProviderModule {
+	return &azurecloudprovider{}
 }
 
 func (provider *azurecloudprovider) GetConnectionArtifact(ctx context.Context, account *cloudintegrationtypes.Account, req *cloudintegrationtypes.GetConnectionArtifactRequest) (*cloudintegrationtypes.ConnectionArtifact, error) {
-	connectionArtifact, err := cloudintegrationtypes.NewAzureConnectionArtifact(account.ID, req.Config.AgentVersion, req.Credentials, req.Config.Azure)
-	if err != nil {
-		return nil, err
-	}
-	return &cloudintegrationtypes.ConnectionArtifact{
-		Azure: connectionArtifact,
-	}, nil
+	panic("implement me")
 }
 
 func (provider *azurecloudprovider) ListServiceDefinitions(ctx context.Context) ([]*cloudintegrationtypes.ServiceDefinition, error) {
-	return provider.serviceDefinitions.List(ctx, cloudintegrationtypes.CloudProviderTypeAzure)
+	panic("implement me")
 }
 
 func (provider *azurecloudprovider) GetServiceDefinition(ctx context.Context, serviceID cloudintegrationtypes.ServiceID) (*cloudintegrationtypes.ServiceDefinition, error) {
-	serviceDef, err := provider.serviceDefinitions.Get(ctx, cloudintegrationtypes.CloudProviderTypeAzure, serviceID)
-	if err != nil {
-		return nil, err
-	}
-
-	// override cloud integration dashboard id.
-	for index, dashboard := range serviceDef.Assets.Dashboards {
-		serviceDef.Assets.Dashboards[index].ID = cloudintegrationtypes.GetCloudIntegrationDashboardID(cloudintegrationtypes.CloudProviderTypeAzure, serviceID.StringValue(), dashboard.ID)
-	}
-
-	return serviceDef, nil
+	panic("implement me")
 }
 
 func (provider *azurecloudprovider) BuildIntegrationConfig(
@@ -51,56 +30,5 @@ func (provider *azurecloudprovider) BuildIntegrationConfig(
 	account *cloudintegrationtypes.Account,
 	services []*cloudintegrationtypes.StorableCloudIntegrationService,
 ) (*cloudintegrationtypes.ProviderIntegrationConfig, error) {
-	sort.Slice(services, func(i, j int) bool {
-		return services[i].Type.StringValue() < services[j].Type.StringValue()
-	})
-
-	var strategies []*cloudintegrationtypes.AzureTelemetryCollectionStrategy
-
-	for _, storedSvc := range services {
-		svcCfg, err := cloudintegrationtypes.NewServiceConfigFromJSON(cloudintegrationtypes.CloudProviderTypeAzure, storedSvc.Config)
-		if err != nil {
-			return nil, err
-		}
-
-		svcDef, err := provider.GetServiceDefinition(ctx, storedSvc.Type)
-		if err != nil {
-			return nil, err
-		}
-
-		strategy := svcDef.TelemetryCollectionStrategy.Azure
-		if strategy == nil {
-			continue
-		}
-
-		logsEnabled := svcCfg.IsLogsEnabled(cloudintegrationtypes.CloudProviderTypeAzure)
-		metricsEnabled := svcCfg.IsMetricsEnabled(cloudintegrationtypes.CloudProviderTypeAzure)
-
-		if !logsEnabled && !metricsEnabled {
-			continue
-		}
-
-		entry := &cloudintegrationtypes.AzureTelemetryCollectionStrategy{
-			ResourceProvider: strategy.ResourceProvider,
-			ResourceType:     strategy.ResourceType,
-		}
-
-		if metricsEnabled && strategy.Metrics != nil {
-			entry.Metrics = strategy.Metrics
-		}
-
-		if logsEnabled && strategy.Logs != nil {
-			entry.Logs = strategy.Logs
-		}
-
-		strategies = append(strategies, entry)
-	}
-
-	return &cloudintegrationtypes.ProviderIntegrationConfig{
-		Azure: cloudintegrationtypes.NewAzureIntegrationConfig(
-			account.Config.Azure.DeploymentRegion,
-			account.Config.Azure.ResourceGroups,
-			strategies,
-		),
-	}, nil
+	panic("implement me")
 }

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -429,14 +429,10 @@ func (module *module) Collect(ctx context.Context, orgID valuer.UUID) (map[strin
 		stats["cloudintegration.aws.connectedaccounts.count"] = awsAccountsCount
 	}
 
-	// get connected accounts for Azure
-	azureAccountsCount, err := module.store.CountConnectedAccounts(ctx, orgID, cloudintegrationtypes.CloudProviderTypeAzure)
-	if err == nil {
-		stats["cloudintegration.azure.connectedaccounts.count"] = azureAccountsCount
-	}
-
 	// NOTE: not adding stats for services for now.
 
+	// TODO: add more cloud providers when supported
+
 	return stats, nil
 }
 

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

@@ -13,7 +13,11 @@ import type {
 
 import type {
 	InframonitoringtypesPostableHostsDTO,
+	InframonitoringtypesPostableNodesDTO,
+	InframonitoringtypesPostablePodsDTO,
 	ListHosts200,
+	ListNodes200,
+	ListPods200,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';
 
@@ -21,7 +25,7 @@ import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
 /**
- * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.
+ * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (cpu, memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.
  * @summary List Hosts for Infra Monitoring
  */
 export const listHosts = (
@@ -104,3 +108,171 @@ export const useListHosts = <
 
 	return useMutation(mutationOptions);
 };
+/**
+ * Returns a paginated list of Kubernetes nodes with key metrics: CPU usage, CPU allocatable, memory working set, memory allocatable, and per-group readyNodeCount / notReadyNodeCount derived from each node's latest k8s.node.condition_ready value in the window. Each node includes metadata attributes (k8s.node.uid, k8s.cluster.name). The response type is 'list' for the default k8s.node.name grouping (each row is one node with its current condition string: ready / not_ready / '') or 'grouped_list' for custom groupBy keys (each row aggregates nodes in the group with readyNodeCount and notReadyNodeCount; condition stays empty). 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 (nodeCPU, nodeCPUAllocatable, nodeMemory, nodeMemoryAllocatable) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.
+ * @summary List Nodes for Infra Monitoring
+ */
+export const listNodes = (
+	inframonitoringtypesPostableNodesDTO: BodyType<InframonitoringtypesPostableNodesDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListNodes200>({
+		url: `/api/v2/infra_monitoring/nodes`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: inframonitoringtypesPostableNodesDTO,
+		signal,
+	});
+};
+
+export const getListNodesMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listNodes>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof listNodes>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
+	TContext
+> => {
+	const mutationKey = ['listNodes'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof listNodes>>,
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return listNodes(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type ListNodesMutationResult = NonNullable<
+	Awaited<ReturnType<typeof listNodes>>
+>;
+export type ListNodesMutationBody =
+	BodyType<InframonitoringtypesPostableNodesDTO>;
+export type ListNodesMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List Nodes for Infra Monitoring
+ */
+export const useListNodes = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listNodes>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof listNodes>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
+	TContext
+> => {
+	const mutationOptions = getListNodesMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Returns a paginated list of Kubernetes pods with key metrics: CPU usage, CPU request/limit utilization, memory working set, memory request/limit utilization, current pod phase (pending/running/succeeded/failed/unknown), and pod age (ms since start time). Each pod includes metadata attributes (namespace, node, workload owner such as deployment/statefulset/daemonset/job/cronjob, cluster). Supports filtering via a filter expression, custom groupBy to aggregate pods by any attribute, ordering by any of the six metrics (cpu, cpu_request, cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit. The response type is 'list' for the default k8s.pod.uid grouping (each row is one pod with its current phase) or 'grouped_list' for custom groupBy keys (each row aggregates pods in the group with per-phase counts: pendingPodCount, runningPodCount, succeededPodCount, failedPodCount, unknownPodCount derived from each pod's latest phase in the window). Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory, podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.
+ * @summary List Pods for Infra Monitoring
+ */
+export const listPods = (
+	inframonitoringtypesPostablePodsDTO: BodyType<InframonitoringtypesPostablePodsDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListPods200>({
+		url: `/api/v2/infra_monitoring/pods`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: inframonitoringtypesPostablePodsDTO,
+		signal,
+	});
+};
+
+export const getListPodsMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listPods>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof listPods>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+	TContext
+> => {
+	const mutationKey = ['listPods'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof listPods>>,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return listPods(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type ListPodsMutationResult = NonNullable<
+	Awaited<ReturnType<typeof listPods>>
+>;
+export type ListPodsMutationBody =
+	BodyType<InframonitoringtypesPostablePodsDTO>;
+export type ListPodsMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List Pods for Infra Monitoring
+ */
+export const useListPods = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listPods>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof listPods>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+	TContext
+> => {
+	const mutationOptions = getListPodsMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};

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

@@ -3243,6 +3243,180 @@ export interface InframonitoringtypesHostsDTO {
 	warning?: Querybuildertypesv5QueryWarnDataDTO;
 }
 
+export enum InframonitoringtypesNodeConditionDTO {
+	ready = 'ready',
+	not_ready = 'not_ready',
+	'' = '',
+}
+/**
+ * @nullable
+ */
+export type InframonitoringtypesNodeRecordDTOMeta = {
+	[key: string]: unknown;
+} | null;
+
+export interface InframonitoringtypesNodeRecordDTO {
+	condition: InframonitoringtypesNodeConditionDTO;
+	/**
+	 * @type object
+	 * @nullable true
+	 */
+	meta: InframonitoringtypesNodeRecordDTOMeta;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	nodeCPU: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	nodeCPUAllocatable: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	nodeMemory: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	nodeMemoryAllocatable: number;
+	/**
+	 * @type string
+	 */
+	nodeName: string;
+	/**
+	 * @type integer
+	 */
+	notReadyNodeCount: number;
+	/**
+	 * @type integer
+	 */
+	readyNodeCount: number;
+}
+
+export interface InframonitoringtypesNodesDTO {
+	/**
+	 * @type boolean
+	 */
+	endTimeBeforeRetention: boolean;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	records: InframonitoringtypesNodeRecordDTO[] | null;
+	requiredMetricsCheck: InframonitoringtypesRequiredMetricsCheckDTO;
+	/**
+	 * @type integer
+	 */
+	total: number;
+	type: InframonitoringtypesResponseTypeDTO;
+	warning?: Querybuildertypesv5QueryWarnDataDTO;
+}
+
+export enum InframonitoringtypesPodPhaseDTO {
+	pending = 'pending',
+	running = 'running',
+	succeeded = 'succeeded',
+	failed = 'failed',
+	unknown = 'unknown',
+	'' = '',
+}
+/**
+ * @nullable
+ */
+export type InframonitoringtypesPodRecordDTOMeta = {
+	[key: string]: unknown;
+} | null;
+
+export interface InframonitoringtypesPodRecordDTO {
+	/**
+	 * @type integer
+	 */
+	failedPodCount: number;
+	/**
+	 * @type object
+	 * @nullable true
+	 */
+	meta: InframonitoringtypesPodRecordDTOMeta;
+	/**
+	 * @type integer
+	 */
+	pendingPodCount: number;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	podAge: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPU: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPULimit: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPURequest: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemory: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemoryLimit: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemoryRequest: number;
+	podPhase: InframonitoringtypesPodPhaseDTO;
+	/**
+	 * @type string
+	 */
+	podUID: string;
+	/**
+	 * @type integer
+	 */
+	runningPodCount: number;
+	/**
+	 * @type integer
+	 */
+	succeededPodCount: number;
+	/**
+	 * @type integer
+	 */
+	unknownPodCount: number;
+}
+
+export interface InframonitoringtypesPodsDTO {
+	/**
+	 * @type boolean
+	 */
+	endTimeBeforeRetention: boolean;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	records: InframonitoringtypesPodRecordDTO[] | null;
+	requiredMetricsCheck: InframonitoringtypesRequiredMetricsCheckDTO;
+	/**
+	 * @type integer
+	 */
+	total: number;
+	type: InframonitoringtypesResponseTypeDTO;
+	warning?: Querybuildertypesv5QueryWarnDataDTO;
+}
+
 export interface InframonitoringtypesPostableHostsDTO {
 	/**
 	 * @type integer
@@ -3271,6 +3445,62 @@ export interface InframonitoringtypesPostableHostsDTO {
 	start: number;
 }
 
+export interface InframonitoringtypesPostableNodesDTO {
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	end: number;
+	filter?: Querybuildertypesv5FilterDTO;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
+	/**
+	 * @type integer
+	 */
+	limit: number;
+	/**
+	 * @type integer
+	 */
+	offset?: number;
+	orderBy?: Querybuildertypesv5OrderByDTO;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	start: number;
+}
+
+export interface InframonitoringtypesPostablePodsDTO {
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	end: number;
+	filter?: Querybuildertypesv5FilterDTO;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
+	/**
+	 * @type integer
+	 */
+	limit: number;
+	/**
+	 * @type integer
+	 */
+	offset?: number;
+	orderBy?: Querybuildertypesv5OrderByDTO;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	start: number;
+}
+
 export interface InframonitoringtypesRequiredMetricsCheckDTO {
 	/**
 	 * @type array
@@ -3701,7 +3931,10 @@ export interface PromotetypesPromotePathDTO {
 }
 
 export interface PromotetypesWrappedIndexDTO {
-	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
+	/**
+	 * @type string
+	 */
+	column_type?: string;
 	/**
 	 * @type integer
 	 */
@@ -5472,187 +5705,6 @@ export interface Sigv4SigV4ConfigDTO {
 	[key: string]: unknown;
 }
 
-export enum SpantypesFieldContextDTO {
-	attribute = 'attribute',
-	resource = 'resource',
-}
-export interface SpantypesGettableSpanMapperGroupsDTO {
-	/**
-	 * @type array
-	 */
-	items: SpantypesSpanMapperGroupDTO[];
-}
-
-export interface SpantypesPostableSpanMapperDTO {
-	config: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	field_context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpantypesPostableSpanMapperGroupDTO {
-	category: SpantypesSpanMapperGroupCategoryDTO;
-	condition: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpantypesSpanMapperDTO {
-	config: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	field_context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	group_id: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpantypesSpanMapperConfigDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	sources: SpantypesSpanMapperSourceDTO[] | null;
-}
-
-export interface SpantypesSpanMapperGroupDTO {
-	category: SpantypesSpanMapperGroupCategoryDTO;
-	condition: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpantypesSpanMapperGroupCategoryDTO {
-	[key: string]: unknown;
-}
-
-export interface SpantypesSpanMapperGroupConditionDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	attributes: string[] | null;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	resource: string[] | null;
-}
-
-export enum SpantypesSpanMapperOperationDTO {
-	move = 'move',
-	copy = 'copy',
-}
-export interface SpantypesSpanMapperSourceDTO {
-	context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	key: string;
-	operation: SpantypesSpanMapperOperationDTO;
-	/**
-	 * @type integer
-	 */
-	priority: number;
-}
-
-export interface SpantypesUpdatableSpanMapperDTO {
-	config?: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	field_context?: SpantypesFieldContextDTO;
-}
-
-export interface SpantypesUpdatableSpanMapperGroupDTO {
-	condition?: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	name?: string | null;
-}
-
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -7103,71 +7155,6 @@ export type GetMyServiceAccount200 = {
 	status: string;
 };
 
-export type ListSpanMapperGroupsParams = {
-	/**
-	 * @description undefined
-	 */
-	category?: SpantypesSpanMapperGroupCategoryDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 * @description undefined
-	 */
-	enabled?: boolean | null;
-};
-
-export type ListSpanMapperGroups200 = {
-	data: SpantypesGettableSpanMapperGroupsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateSpanMapperGroup201 = {
-	data: SpantypesSpanMapperGroupDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteSpanMapperGroupPathParameters = {
-	groupId: string;
-};
-export type UpdateSpanMapperGroupPathParameters = {
-	groupId: string;
-};
-export type ListSpanMappersPathParameters = {
-	groupId: string;
-};
-export type ListSpanMappers200 = {
-	data: SpantypesGettableSpanMapperGroupsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateSpanMapperPathParameters = {
-	groupId: string;
-};
-export type CreateSpanMapper201 = {
-	data: SpantypesSpanMapperDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteSpanMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
-export type UpdateSpanMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array
@@ -7350,6 +7337,22 @@ export type ListHosts200 = {
 	status: string;
 };
 
+export type ListNodes200 = {
+	data: InframonitoringtypesNodesDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type ListPods200 = {
+	data: InframonitoringtypesPodsDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type Livez200 = {
 	data: FactoryResponseDTO;
 	/**

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

@@ -1,787 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import { useMutation, useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type {
-	CreateSpanMapper201,
-	CreateSpanMapperGroup201,
-	CreateSpanMapperPathParameters,
-	DeleteSpanMapperGroupPathParameters,
-	DeleteSpanMapperPathParameters,
-	ListSpanMapperGroups200,
-	ListSpanMapperGroupsParams,
-	ListSpanMappers200,
-	ListSpanMappersPathParameters,
-	RenderErrorResponseDTO,
-	SpantypesPostableSpanMapperDTO,
-	SpantypesPostableSpanMapperGroupDTO,
-	SpantypesUpdatableSpanMapperDTO,
-	SpantypesUpdatableSpanMapperGroupDTO,
-	UpdateSpanMapperGroupPathParameters,
-	UpdateSpanMapperPathParameters,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * Returns all span attribute mapping groups for the authenticated org.
- * @summary List span attribute mapping groups
- */
-export const listSpanMapperGroups = (
-	params?: ListSpanMapperGroupsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanMapperGroups200>({
-		url: `/api/v1/span_mapper_groups`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListSpanMapperGroupsQueryKey = (
-	params?: ListSpanMapperGroupsParams,
-) => {
-	return [`/api/v1/span_mapper_groups`, ...(params ? [params] : [])] as const;
-};
-
-export const getListSpanMapperGroupsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanMapperGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanMapperGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMapperGroups>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanMapperGroupsQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listSpanMapperGroups>>
-	> = ({ signal }) => listSpanMapperGroups(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanMapperGroups>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanMapperGroupsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanMapperGroups>>
->;
-export type ListSpanMapperGroupsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mapping groups
- */
-
-export function useListSpanMapperGroups<
-	TData = Awaited<ReturnType<typeof listSpanMapperGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanMapperGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMapperGroups>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanMapperGroupsQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span attribute mapping groups
- */
-export const invalidateListSpanMapperGroups = async (
-	queryClient: QueryClient,
-	params?: ListSpanMapperGroupsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanMapperGroupsQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates a new span attribute mapping group for the org.
- * @summary Create a span attribute mapping group
- */
-export const createSpanMapperGroup = (
-	spantypesPostableSpanMapperGroupDTO: BodyType<SpantypesPostableSpanMapperGroupDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateSpanMapperGroup201>({
-		url: `/api/v1/span_mapper_groups`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableSpanMapperGroupDTO,
-		signal,
-	});
-};
-
-export const getCreateSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		TError,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>,
-	TError,
-	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-	TContext
-> => {
-	const mutationKey = ['createSpanMapperGroup'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createSpanMapperGroup(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>
->;
-export type CreateSpanMapperGroupMutationBody =
-	BodyType<SpantypesPostableSpanMapperGroupDTO>;
-export type CreateSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapping group
- */
-export const useCreateSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		TError,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>,
-	TError,
-	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapping group and cascades to all its mappers.
- * @summary Delete a span attribute mapping group
- */
-export const deleteSpanMapperGroup = ({
-	groupId,
-}: DeleteSpanMapperGroupPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-		TError,
-		{ pathParams: DeleteSpanMapperGroupPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-	TError,
-	{ pathParams: DeleteSpanMapperGroupPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteSpanMapperGroup'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-		{ pathParams: DeleteSpanMapperGroupPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteSpanMapperGroup(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>
->;
-
-export type DeleteSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapping group
- */
-export const useDeleteSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-		TError,
-		{ pathParams: DeleteSpanMapperGroupPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-	TError,
-	{ pathParams: DeleteSpanMapperGroupPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapping group's name, condition, or enabled state.
- * @summary Update a span attribute mapping group
- */
-export const updateSpanMapperGroup = (
-	{ groupId }: UpdateSpanMapperGroupPathParameters,
-	spantypesUpdatableSpanMapperGroupDTO: BodyType<SpantypesUpdatableSpanMapperGroupDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesUpdatableSpanMapperGroupDTO,
-	});
-};
-
-export const getUpdateSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperGroupPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateSpanMapperGroup'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateSpanMapperGroup(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>
->;
-export type UpdateSpanMapperGroupMutationBody =
-	BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-export type UpdateSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapping group
- */
-export const useUpdateSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperGroupPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns all mappers belonging to a mapping group.
- * @summary List span mappers for a group
- */
-export const listSpanMappers = (
-	{ groupId }: ListSpanMappersPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanMappers200>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListSpanMappersQueryKey = ({
-	groupId,
-}: ListSpanMappersPathParameters) => {
-	return [`/api/v1/span_mapper_groups/${groupId}/span_mappers`] as const;
-};
-
-export const getListSpanMappersQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMappers>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanMappersQueryKey({ groupId });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listSpanMappers>>> = ({
-		signal,
-	}) => listSpanMappers({ groupId }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!groupId,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanMappers>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanMappersQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanMappers>>
->;
-export type ListSpanMappersQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span mappers for a group
- */
-
-export function useListSpanMappers<
-	TData = Awaited<ReturnType<typeof listSpanMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMappers>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanMappersQueryOptions({ groupId }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span mappers for a group
- */
-export const invalidateListSpanMappers = async (
-	queryClient: QueryClient,
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanMappersQueryKey({ groupId }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Adds a new mapper to the specified mapping group.
- * @summary Create a span mapper
- */
-export const createSpanMapper = (
-	{ groupId }: CreateSpanMapperPathParameters,
-	spantypesPostableSpanMapperDTO: BodyType<SpantypesPostableSpanMapperDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateSpanMapper201>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableSpanMapperDTO,
-		signal,
-	});
-};
-
-export const getCreateSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapper>>,
-		TError,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createSpanMapper>>,
-	TError,
-	{
-		pathParams: CreateSpanMapperPathParameters;
-		data: BodyType<SpantypesPostableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['createSpanMapper'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createSpanMapper>>,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return createSpanMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createSpanMapper>>
->;
-export type CreateSpanMapperMutationBody =
-	BodyType<SpantypesPostableSpanMapperDTO>;
-export type CreateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span mapper
- */
-export const useCreateSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapper>>,
-		TError,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createSpanMapper>>,
-	TError,
-	{
-		pathParams: CreateSpanMapperPathParameters;
-		data: BodyType<SpantypesPostableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getCreateSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapper from a mapping group.
- * @summary Delete a span mapper
- */
-export const deleteSpanMapper = ({
-	groupId,
-	mapperId,
-}: DeleteSpanMapperPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapper>>,
-		TError,
-		{ pathParams: DeleteSpanMapperPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteSpanMapper>>,
-	TError,
-	{ pathParams: DeleteSpanMapperPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteSpanMapper'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteSpanMapper>>,
-		{ pathParams: DeleteSpanMapperPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteSpanMapper(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteSpanMapper>>
->;
-
-export type DeleteSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span mapper
- */
-export const useDeleteSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapper>>,
-		TError,
-		{ pathParams: DeleteSpanMapperPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteSpanMapper>>,
-	TError,
-	{ pathParams: DeleteSpanMapperPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapper's field context, config, or enabled state.
- * @summary Update a span mapper
- */
-export const updateSpanMapper = (
-	{ groupId, mapperId }: UpdateSpanMapperPathParameters,
-	spantypesUpdatableSpanMapperDTO: BodyType<SpantypesUpdatableSpanMapperDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesUpdatableSpanMapperDTO,
-	});
-};
-
-export const getUpdateSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapper>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateSpanMapper>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateSpanMapper'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updateSpanMapper>>,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateSpanMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateSpanMapper>>
->;
-export type UpdateSpanMapperMutationBody =
-	BodyType<SpantypesUpdatableSpanMapperDTO>;
-export type UpdateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span mapper
- */
-export const useUpdateSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapper>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateSpanMapper>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

frontend/src/container/BillingContainer/BillingContainer.tsx

@@ -34,7 +34,6 @@ import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
 import { getBaseUrl } from 'utils/basePath';
 import { getFormattedDate, getRemainingDays } from 'utils/timeUtils';
 
-import CancelSubscriptionBanner from './CancelSubscriptionBanner';
 import { BillingUsageGraph } from './BillingUsageGraph/BillingUsageGraph';
 import { prepareCsvData } from './BillingUsageGraph/utils';
 
@@ -536,8 +535,6 @@ export default function BillingContainer(): JSX.Element {
 				{(isLoading || isFetchingBillingData) && renderTableSkeleton()}
 			</div>
 
-			{trialInfo?.trialConvertedToSubscription && <CancelSubscriptionBanner />}
-
 			{!trialInfo?.trialConvertedToSubscription && (
 				<div className="upgrade-plan-benefits">
 					<Row

frontend/src/container/BillingContainer/CancelSubscriptionBanner.styles.scss

@@ -1,35 +0,0 @@
-.cancel-subscription-banner {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-	padding: var(--padding-4);
-	border-radius: 4px;
-	border: 1px solid var(--callout-error-border);
-	background-color: var(--callout-error-background);
-	margin: var(--spacing-4) 0 var(--spacing-12);
-
-	&__info {
-		display: flex;
-		flex-direction: column;
-		gap: var(--spacing-2);
-	}
-
-	&__title {
-		font-size: var(--font-size-sm);
-		font-weight: var(--font-weight-medium);
-		color: var(--callout-error-title);
-	}
-
-	&__subtitle {
-		font-size: var(--paragraph-base-400-font-size);
-		font-weight: var(--paragraph-base-400-font-weight);
-		line-height: var(--paragraph-base-400-line-height);
-		color: var(--callout-error-icon);
-	}
-}
-
-.cancel-subscription-dialog__body {
-	font-size: var(--font-size-sm);
-	line-height: var(--line-height-relaxed);
-	color: var(--l2-foreground);
-}

frontend/src/container/BillingContainer/CancelSubscriptionBanner.tsx

@@ -1,96 +0,0 @@
-import { useState } from 'react';
-import { X } from '@signozhq/icons';
-import { Button, DialogWrapper } from '@signozhq/ui';
-import { useAppContext } from 'providers/App/App';
-import { getBaseUrl } from 'utils/basePath';
-
-import './CancelSubscriptionBanner.styles.scss';
-
-function CancelSubscriptionBanner(): JSX.Element {
-	const [open, setOpen] = useState(false);
-	const { user, org } = useAppContext();
-
-	const handleContactSupport = (): void => {
-		const subject = encodeURIComponent('Cancel My SigNoz Subscription');
-		const orgName = org?.[0]?.displayName ?? '';
-		const body = encodeURIComponent(
-			[
-				'Hi SigNoz Team,',
-				'',
-				'I would like to cancel my SigNoz Cloud subscription.',
-				'Please find my account details below.',
-				'',
-				'Account Details:',
-				`  • SigNoz URL:      ${getBaseUrl()}`,
-				...(orgName ? [`  • Organization:   ${orgName}`] : []),
-				`  • Account Email:  ${user?.email ?? ''}`,
-				'',
-				'Reason for Cancellation:',
-				'[Please share the reason for cancellation]',
-				'',
-				'Additional feedback (optional):',
-				'[Any other feedback]',
-				'',
-				'Regards,',
-				'[user name or team name]',
-			].join('\n'),
-		);
-		const link = document.createElement('a');
-		link.href = `mailto:cloud-support@signoz.io?subject=${subject}&body=${body}`;
-		link.click();
-		setOpen(false);
-	};
-
-	const footer = (
-		<>
-			<Button
-				variant="solid"
-				color="secondary"
-				onClick={(): void => setOpen(false)}
-			>
-				Keep Subscription
-			</Button>
-			<Button variant="solid" color="destructive" onClick={handleContactSupport}>
-				Contact Support
-			</Button>
-		</>
-	);
-
-	return (
-		<>
-			<div className="cancel-subscription-banner">
-				<div className="cancel-subscription-banner__info">
-					<span className="cancel-subscription-banner__title">
-						Cancel Subscription
-					</span>
-					<span className="cancel-subscription-banner__subtitle">
-						Cancel your SigNoz subscription.
-					</span>
-				</div>
-				<Button
-					variant="solid"
-					color="destructive"
-					prefix={<X size={12} />}
-					onClick={(): void => setOpen(true)}
-				>
-					Cancel Subscription
-				</Button>
-			</div>
-			<DialogWrapper
-				open={open}
-				onOpenChange={setOpen}
-				title="Cancel your subscription"
-				width="narrow"
-				showCloseButton
-				footer={footer}
-			>
-				<p className="cancel-subscription-dialog__body">
-					To cancel your SigNoz subscription, please reach out to our support team.
-					We&apos;ll be happy to assist you.
-				</p>
-			</DialogWrapper>
-		</>
-	);
-}
-
-export default CancelSubscriptionBanner;

frontend/src/container/FormAlertRules/ChartPreview/index.tsx

@@ -139,8 +139,8 @@ function ChartPreview({
 		if (startTime && endTime && startTime !== endTime) {
 			dispatch(
 				UpdateTimeInterval('custom', [
-					parseInt(getTimeString(startTime), 10),
-					parseInt(getTimeString(endTime), 10),
+					Number.parseInt(getTimeString(startTime), 10),
+					Number.parseInt(getTimeString(endTime), 10),
 				]),
 			);
 		}

frontend/src/container/FormAlertRules/index.tsx

@@ -370,7 +370,7 @@ function FormAlertRules({
 	// onQueryCategoryChange handles changes to query category
 	// in state as well as sets additional defaults
 	const onQueryCategoryChange = (val: EQueryType): void => {
-		const element = document.getElementById('top');
+		const element = document.querySelector('#top');
 		if (element) {
 			element.scrollIntoView({ behavior: 'smooth' });
 		}

frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx

@@ -279,7 +279,7 @@ function Explorer(): JSX.Element {
 		[],
 	);
 
-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();
 
 	const oneChartPerQueryDisabledTooltip = useMemo(() => {
 		if (splitedQueries.length <= 1) {
@@ -291,7 +291,7 @@ function Explorer(): JSX.Element {
 		if (disableOneChartPerQuery) {
 			return 'One chart per query cannot be disabled for multiple queries with different units.';
 		}
-		return undefined;
+		return;
 	}, [disableOneChartPerQuery, splitedQueries.length, units.length]);
 
 	// Show the y axis unit selector if -

frontend/src/container/MetricsExplorer/Inspect/Inspect.tsx

@@ -217,7 +217,7 @@ function Inspect({
 			);
 		}
 
-		if (!inspectMetricsTimeSeries.length) {
+		if (inspectMetricsTimeSeries.length === 0) {
 			return renderFallback(
 				'inspect-metrics-empty',
 				<Empty description="No time series found for this metric to inspect." />,

frontend/src/container/MetricsExplorer/Inspect/useInspectMetrics.ts

@@ -254,10 +254,10 @@ export function useInspectMetrics(
 			const valuesMap = new Map<number, number>();
 
 			series.values.forEach(({ timestamp, value }) => {
-				valuesMap.set(timestamp, parseFloat(value));
+				valuesMap.set(timestamp, Number.parseFloat(value));
 			});
 
-			return timestamps.map((timestamp) => valuesMap.get(timestamp) ?? NaN);
+			return timestamps.map((timestamp) => valuesMap.get(timestamp) ?? Number.NaN);
 		});
 
 		const rawData = [timestamps, ...timeseriesArray];
@@ -271,7 +271,7 @@ export function useInspectMetrics(
 				labels.add(label);
 			});
 		});
-		return Array.from(labels);
+		return [...labels];
 	}, [inspectMetricsData]);
 
 	const reset = useCallback(() => {

frontend/src/container/QueryBuilder/components/RunQueryBtn/__test__/RunQueryBtn.test.tsx

@@ -18,7 +18,7 @@ describe('RunQueryBtn', () => {
 		);
 	});
 
-	test('renders run state and triggers on click', async () => {
+	it('renders run state and triggers on click', async () => {
 		const user = userEvent.setup();
 		const onRun = jest.fn();
 		const onCancel = jest.fn();
@@ -35,7 +35,7 @@ describe('RunQueryBtn', () => {
 		expect(onRun).toHaveBeenCalledTimes(1);
 	});
 
-	test('shows cancel state and calls handleCancelQuery', async () => {
+	it('shows cancel state and calls handleCancelQuery', async () => {
 		const user = userEvent.setup();
 		const onRun = jest.fn();
 		const onCancel = jest.fn();
@@ -51,19 +51,19 @@ describe('RunQueryBtn', () => {
 		expect(onCancel).toHaveBeenCalledTimes(1);
 	});
 
-	test('disabled when disabled prop is true', () => {
+	it('disabled when disabled prop is true', () => {
 		render(<RunQueryBtn disabled />);
 		expect(screen.getByRole('button', { name: /run query/i })).toBeDisabled();
 	});
 
-	test('disabled when no props provided', () => {
+	it('disabled when no props provided', () => {
 		render(<RunQueryBtn />);
 		expect(
 			screen.getByRole('button', { name: /run query/i }),
 		).toBeInTheDocument();
 	});
 
-	test('shows Command + CornerDownLeft on mac', () => {
+	it('shows Command + CornerDownLeft on mac', () => {
 		const { container } = render(
 			<RunQueryBtn
 				onStageRunQuery={jest.fn()}
@@ -77,7 +77,7 @@ describe('RunQueryBtn', () => {
 		).toBeInTheDocument();
 	});
 
-	test('shows ChevronUp + CornerDownLeft on non-mac', () => {
+	it('shows ChevronUp + CornerDownLeft on non-mac', () => {
 		(getUserOperatingSystem as jest.Mock).mockReturnValue(
 			UserOperatingSystem.WINDOWS,
 		);
@@ -95,7 +95,7 @@ describe('RunQueryBtn', () => {
 		).toBeInTheDocument();
 	});
 
-	test('renders custom label when provided', () => {
+	it('renders custom label when provided', () => {
 		render(
 			<RunQueryBtn
 				onStageRunQuery={jest.fn()}

frontend/src/hooks/queryBuilder/useGetQueryRange.ts

@@ -115,8 +115,8 @@ export const useGetQueryRange: UseGetQueryRange = (
 
 			const updatedQuery = updateBarStepInterval(
 				requestData.query,
-				requestData.start ? requestData.start * 1e3 : parseInt(start, 10) * 1e3,
-				requestData.end ? requestData.end * 1e3 : parseInt(end, 10) * 1e3,
+				requestData.start ? requestData.start * 1e3 : Number.parseInt(start, 10) * 1e3,
+				requestData.end ? requestData.end * 1e3 : Number.parseInt(end, 10) * 1e3,
 			);
 
 			return {

frontend/src/pages/LogsExplorer/index.tsx

@@ -98,7 +98,7 @@ function LogsExplorer(): JSX.Element {
 		setIsLoadingQueries(false);
 	}, [queryClient]);
 
-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();
 
 	const handleChangeSelectedView = useCallback(
 		(view: ExplorerViews, querySearchParameters?: ICurrentQueryData): void => {

frontend/src/pages/TracesExplorer/index.tsx

@@ -101,7 +101,7 @@ function TracesExplorer(): JSX.Element {
 		getExplorerViewFromUrl(searchParams, panelTypesFromUrl),
 	);
 
-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();
 	const [isOpen, setOpen] = useState<boolean>(true);
 
 	const defaultQuery = useMemo(

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.40.1
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd
-	github.com/SigNoz/signoz-otel-collector v0.144.3
+	github.com/SigNoz/signoz-otel-collector v0.144.3-rc.4
 	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/antonmedv/expr v1.15.3
 	github.com/cespare/xxhash/v2 v2.3.0

go.sum

@@ -108,8 +108,8 @@ github.com/SigNoz/expr v1.17.7-beta h1:FyZkleM5dTQ0O6muQfwGpoH5A2ohmN/XTasRCO72g
 github.com/SigNoz/expr v1.17.7-beta/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd h1:Bk43AsDYe0fhkbj57eGXx8H3ZJ4zhmQXBnrW523ktj8=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd/go.mod h1:nxRcH/OEdM8QxzH37xkGzomr1O0JpYBRS6pwjsWW6Pc=
-github.com/SigNoz/signoz-otel-collector v0.144.3 h1:/7PPIqIpPsaWtrgnfHam2XVYP41ZlgEKLHzQO8oVxcA=
-github.com/SigNoz/signoz-otel-collector v0.144.3/go.mod h1:9pLVpcIQvUT88ZiNnZN/MI+XLruvwC+Xm2UzPmGjNfA=
+github.com/SigNoz/signoz-otel-collector v0.144.3-rc.4 h1:EskJkEMfuuIyArWhV8SleDV/fuKxiaEGTXrCZIFqDT4=
+github.com/SigNoz/signoz-otel-collector v0.144.3-rc.4/go.mod h1:9pLVpcIQvUT88ZiNnZN/MI+XLruvwC+Xm2UzPmGjNfA=
 github.com/Yiling-J/theine-go v0.6.2 h1:1GeoXeQ0O0AUkiwj2S9Jc0Mzx+hpqzmqsJ4kIC4M9AY=
 github.com/Yiling-J/theine-go v0.6.2/go.mod h1:08QpMa5JZ2pKN+UJCRrCasWYO1IKCdl54Xa836rpmDU=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=

pkg/apiserver/signozapiserver/inframonitoring.go

@@ -16,7 +16,7 @@ func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
 			ID:                  "ListHosts",
 			Tags:                []string{"inframonitoring"},
 			Summary:             "List Hosts for Infra Monitoring",
-			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.",
+			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (cpu, memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.",
 			Request:             new(inframonitoringtypes.PostableHosts),
 			RequestContentType:  "application/json",
 			Response:            new(inframonitoringtypes.Hosts),
@@ -29,5 +29,43 @@ func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v2/infra_monitoring/pods", handler.New(
+		provider.authZ.ViewAccess(provider.infraMonitoringHandler.ListPods),
+		handler.OpenAPIDef{
+			ID:                  "ListPods",
+			Tags:                []string{"inframonitoring"},
+			Summary:             "List Pods for Infra Monitoring",
+			Description:         "Returns a paginated list of Kubernetes pods with key metrics: CPU usage, CPU request/limit utilization, memory working set, memory request/limit utilization, current pod phase (pending/running/succeeded/failed/unknown), and pod age (ms since start time). Each pod includes metadata attributes (namespace, node, workload owner such as deployment/statefulset/daemonset/job/cronjob, cluster). Supports filtering via a filter expression, custom groupBy to aggregate pods by any attribute, ordering by any of the six metrics (cpu, cpu_request, cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit. The response type is 'list' for the default k8s.pod.uid grouping (each row is one pod with its current phase) or 'grouped_list' for custom groupBy keys (each row aggregates pods in the group with per-phase counts: pendingPodCount, runningPodCount, succeededPodCount, failedPodCount, unknownPodCount derived from each pod's latest phase in the window). Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory, podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.",
+			Request:             new(inframonitoringtypes.PostablePods),
+			RequestContentType:  "application/json",
+			Response:            new(inframonitoringtypes.Pods),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/infra_monitoring/nodes", handler.New(
+		provider.authZ.ViewAccess(provider.infraMonitoringHandler.ListNodes),
+		handler.OpenAPIDef{
+			ID:                  "ListNodes",
+			Tags:                []string{"inframonitoring"},
+			Summary:             "List Nodes for Infra Monitoring",
+			Description:         "Returns a paginated list of Kubernetes nodes with key metrics: CPU usage, CPU allocatable, memory working set, memory allocatable, and per-group readyNodeCount / notReadyNodeCount derived from each node's latest k8s.node.condition_ready value in the window. Each node includes metadata attributes (k8s.node.uid, k8s.cluster.name). The response type is 'list' for the default k8s.node.name grouping (each row is one node with its current condition string: ready / not_ready / '') or 'grouped_list' for custom groupBy keys (each row aggregates nodes in the group with readyNodeCount and notReadyNodeCount; condition stays empty). 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 (nodeCPU, nodeCPUAllocatable, nodeMemory, nodeMemoryAllocatable) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.",
+			Request:             new(inframonitoringtypes.PostableNodes),
+			RequestContentType:  "application/json",
+			Response:            new(inframonitoringtypes.Nodes),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
 	return nil
 }

pkg/apiserver/signozapiserver/provider.go

@@ -16,8 +16,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -25,7 +25,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
@@ -63,7 +62,6 @@ type provider struct {
 	factoryHandler          factory.Handler
 	cloudIntegrationHandler cloudintegration.Handler
 	ruleStateHistoryHandler rulestatehistory.Handler
-	spanMapperHandler       spanmapper.Handler
 	alertmanagerHandler     alertmanager.Handler
 	traceDetailHandler      tracedetail.Handler
 	rulerHandler            ruler.Handler
@@ -94,7 +92,6 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanMapperHandler spanmapper.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
@@ -128,7 +125,6 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
-			spanMapperHandler,
 			alertmanagerHandler,
 			traceDetailHandler,
 			rulerHandler,
@@ -164,7 +160,6 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanMapperHandler spanmapper.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
@@ -198,7 +193,6 @@ func newProvider(
 		factoryHandler:          factoryHandler,
 		cloudIntegrationHandler: cloudIntegrationHandler,
 		ruleStateHistoryHandler: ruleStateHistoryHandler,
-		spanMapperHandler:       spanMapperHandler,
 		alertmanagerHandler:     alertmanagerHandler,
 		traceDetailHandler:      traceDetailHandler,
 		rulerHandler:            rulerHandler,
@@ -306,10 +300,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addSpanMapperRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addAlertmanagerRoutes(router); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/spanmapper.go

@@ -1,171 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addSpanMapperRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/span_mapper_groups", handler.New(
-		provider.authZ.ViewAccess(provider.spanMapperHandler.ListGroups),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanMapperGroups",
-			Tags:                []string{"spanmapper"},
-			Summary:             "List span attribute mapping groups",
-			Description:         "Returns all span attribute mapping groups for the authenticated org.",
-			Request:             nil,
-			RequestContentType:  "",
-			RequestQuery:        new(spantypes.ListSpanMapperGroupsQuery),
-			Response:            new(spantypes.GettableSpanMapperGroups),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.CreateGroup),
-		handler.OpenAPIDef{
-			ID:                  "CreateSpanMapperGroup",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Create a span attribute mapping group",
-			Description:         "Creates a new span attribute mapping group for the org.",
-			Request:             new(spantypes.PostableSpanMapperGroup),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableSpanMapperGroup),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.UpdateGroup),
-		handler.OpenAPIDef{
-			ID:                 "UpdateSpanMapperGroup",
-			Tags:               []string{"spanmapper"},
-			Summary:            "Update a span attribute mapping group",
-			Description:        "Partially updates an existing mapping group's name, condition, or enabled state.",
-			Request:            new(spantypes.UpdatableSpanMapperGroup),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.DeleteGroup),
-		handler.OpenAPIDef{
-			ID:                  "DeleteSpanMapperGroup",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Delete a span attribute mapping group",
-			Description:         "Hard-deletes a mapping group and cascades to all its mappers.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers", handler.New(
-		provider.authZ.ViewAccess(provider.spanMapperHandler.ListMappers),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanMappers",
-			Tags:                []string{"spanmapper"},
-			Summary:             "List span mappers for a group",
-			Description:         "Returns all mappers belonging to a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(spantypes.GettableSpanMapperGroups),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.CreateMapper),
-		handler.OpenAPIDef{
-			ID:                  "CreateSpanMapper",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Create a span mapper",
-			Description:         "Adds a new mapper to the specified mapping group.",
-			Request:             new(spantypes.PostableSpanMapper),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableSpanMapper),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.UpdateMapper),
-		handler.OpenAPIDef{
-			ID:                 "UpdateSpanMapper",
-			Tags:               []string{"spanmapper"},
-			Summary:            "Update a span mapper",
-			Description:        "Partially updates an existing mapper's field context, config, or enabled state.",
-			Request:            new(spantypes.UpdatableSpanMapper),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.DeleteMapper),
-		handler.OpenAPIDef{
-			ID:                  "DeleteSpanMapper",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Delete a span mapper",
-			Description:         "Hard-deletes a mapper from a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/modules/cloudintegration/implcloudintegration/handler.go

@@ -440,4 +440,3 @@ func (handler *handler) AgentCheckIn(rw http.ResponseWriter, r *http.Request) {
 
 	render.Success(rw, http.StatusOK, cloudintegrationtypes.NewGettableAgentCheckIn(provider, resp))
 }
-

pkg/modules/inframonitoring/implinframonitoring/handler.go

@@ -45,3 +45,51 @@ func (h *handler) ListHosts(rw http.ResponseWriter, req *http.Request) {
 
 	render.Success(rw, http.StatusOK, result)
 }
+
+func (h *handler) ListPods(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.PostablePods
+	if err := binding.JSON.BindBody(req.Body, &parsedReq); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.ListPods(req.Context(), orgID, &parsedReq)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
+
+func (h *handler) ListNodes(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.PostableNodes
+	if err := binding.JSON.BindBody(req.Body, &parsedReq); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.ListNodes(req.Context(), orgID, &parsedReq)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}

pkg/modules/inframonitoring/implinframonitoring/internaltypes.go

@@ -14,3 +14,18 @@ type groupHostStatusCounts struct {
 	Active   int
 	Inactive int
 }
+
+// podPhaseCounts holds per-group pod counts bucketed by latest phase in window.
+type podPhaseCounts struct {
+	Pending   int
+	Running   int
+	Succeeded int
+	Failed    int
+	Unknown   int
+}
+
+// nodeConditionCounts holds per-group node counts bucketed by latest condition_ready in window.
+type nodeConditionCounts struct {
+	Ready    int
+	NotReady int
+}

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -159,3 +159,169 @@ func (m *module) ListHosts(ctx context.Context, orgID valuer.UUID, req *inframon
 
 	return resp, nil
 }
+
+func (m *module) ListPods(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostablePods) (*inframonitoringtypes.Pods, error) {
+	if err := req.Validate(); err != nil {
+		return nil, err
+	}
+
+	resp := &inframonitoringtypes.Pods{}
+
+	if req.OrderBy == nil {
+		req.OrderBy = &qbtypes.OrderBy{
+			Key: qbtypes.OrderByKey{
+				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+					Name: inframonitoringtypes.PodsOrderByCPU,
+				},
+			},
+			Direction: qbtypes.OrderDirectionDesc,
+		}
+	}
+
+	if len(req.GroupBy) == 0 {
+		req.GroupBy = []qbtypes.GroupByKey{podUIDGroupByKey}
+		resp.Type = inframonitoringtypes.ResponseTypeList
+	} else {
+		resp.Type = inframonitoringtypes.ResponseTypeGroupedList
+	}
+
+	missingMetrics, minFirstReportedUnixMilli, err := m.getMetricsExistenceAndEarliestTime(ctx, podsTableMetricNamesList)
+	if err != nil {
+		return nil, err
+	}
+	if len(missingMetrics) > 0 {
+		resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: missingMetrics}
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	if req.End < int64(minFirstReportedUnixMilli) {
+		resp.EndTimeBeforeRetention = true
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: []string{}}
+
+	metadataMap, err := m.getPodsTableMetadata(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = len(metadataMap)
+
+	pageGroups, err := m.getTopPodGroups(ctx, orgID, req, metadataMap)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(pageGroups) == 0 {
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		return resp, nil
+	}
+
+	filterExpr := ""
+	if req.Filter != nil {
+		filterExpr = req.Filter.Expression
+	}
+
+	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newPodsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
+
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req, pageGroups)
+	if err != nil {
+		return nil, err
+	}
+
+	isPodUIDInGroupBy := isKeyInGroupByAttrs(req.GroupBy, podUIDAttrKey)
+	resp.Records = buildPodRecords(isPodUIDInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, phaseCounts, req.End)
+	resp.Warning = queryResp.Warning
+
+	return resp, nil
+}
+
+func (m *module) ListNodes(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableNodes) (*inframonitoringtypes.Nodes, error) {
+	if err := req.Validate(); err != nil {
+		return nil, err
+	}
+
+	resp := &inframonitoringtypes.Nodes{}
+
+	if req.OrderBy == nil {
+		req.OrderBy = &qbtypes.OrderBy{
+			Key: qbtypes.OrderByKey{
+				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+					Name: inframonitoringtypes.NodesOrderByCPU,
+				},
+			},
+			Direction: qbtypes.OrderDirectionDesc,
+		}
+	}
+
+	if len(req.GroupBy) == 0 {
+		req.GroupBy = []qbtypes.GroupByKey{nodeNameGroupByKey}
+		resp.Type = inframonitoringtypes.ResponseTypeList
+	} else {
+		resp.Type = inframonitoringtypes.ResponseTypeGroupedList
+	}
+
+	missingMetrics, minFirstReportedUnixMilli, err := m.getMetricsExistenceAndEarliestTime(ctx, nodesTableMetricNamesList)
+	if err != nil {
+		return nil, err
+	}
+	if len(missingMetrics) > 0 {
+		resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: missingMetrics}
+		resp.Records = []inframonitoringtypes.NodeRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	if req.End < int64(minFirstReportedUnixMilli) {
+		resp.EndTimeBeforeRetention = true
+		resp.Records = []inframonitoringtypes.NodeRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: []string{}}
+
+	metadataMap, err := m.getNodesTableMetadata(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = len(metadataMap)
+
+	pageGroups, err := m.getTopNodeGroups(ctx, orgID, req, metadataMap)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(pageGroups) == 0 {
+		resp.Records = []inframonitoringtypes.NodeRecord{}
+		return resp, nil
+	}
+
+	filterExpr := ""
+	if req.Filter != nil {
+		filterExpr = req.Filter.Expression
+	}
+
+	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newNodesTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
+
+	conditionCounts, err := m.getPerGroupNodeConditionCounts(ctx, req, pageGroups)
+	if err != nil {
+		return nil, err
+	}
+
+	isNodeNameInGroupBy := isKeyInGroupByAttrs(req.GroupBy, nodeNameAttrKey)
+	resp.Records = buildNodeRecords(isNodeNameInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, conditionCounts)
+	resp.Warning = queryResp.Warning
+
+	return resp, nil
+}

pkg/modules/inframonitoring/implinframonitoring/nodes.go

@@ -0,0 +1,299 @@
+package implinframonitoring
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+// buildNodeRecords assembles the page records. Condition counts come from
+// conditionCounts in both modes. In list mode (isNodeNameInGroupBy=true) each
+// group is one node, so exactly one count is 1; Condition is derived from
+// which one. In grouped_list mode Condition stays NodeConditionNone.
+func buildNodeRecords(
+	isNodeNameInGroupBy bool,
+	resp *qbtypes.QueryRangeResponse,
+	pageGroups []map[string]string,
+	groupBy []qbtypes.GroupByKey,
+	metadataMap map[string]map[string]string,
+	conditionCounts map[string]nodeConditionCounts,
+) []inframonitoringtypes.NodeRecord {
+	metricsMap := parseFullQueryResponse(resp, groupBy)
+
+	records := make([]inframonitoringtypes.NodeRecord, 0, len(pageGroups))
+	for _, labels := range pageGroups {
+		compositeKey := compositeKeyFromLabels(labels, groupBy)
+		nodeName := labels[nodeNameAttrKey]
+
+		record := inframonitoringtypes.NodeRecord{ // initialize with default values
+			NodeName:              nodeName,
+			Condition:             inframonitoringtypes.NodeConditionNone,
+			NodeCPU:               -1,
+			NodeCPUAllocatable:    -1,
+			NodeMemory:            -1,
+			NodeMemoryAllocatable: -1,
+			Meta:                  map[string]any{},
+		}
+
+		if metrics, ok := metricsMap[compositeKey]; ok {
+			if v, exists := metrics["A"]; exists {
+				record.NodeCPU = v
+			}
+			if v, exists := metrics["B"]; exists {
+				record.NodeCPUAllocatable = v
+			}
+			if v, exists := metrics["C"]; exists {
+				record.NodeMemory = v
+			}
+			if v, exists := metrics["D"]; exists {
+				record.NodeMemoryAllocatable = v
+			}
+		}
+
+		if conditionCountsForGroup, ok := conditionCounts[compositeKey]; ok {
+			record.ReadyNodesCount = conditionCountsForGroup.Ready
+			record.NotReadyNodesCount = conditionCountsForGroup.NotReady
+
+			// In list mode each group is one node; the count==1 bucket identifies the condition.
+			if isNodeNameInGroupBy {
+				switch {
+				case conditionCountsForGroup.Ready == 1:
+					record.Condition = inframonitoringtypes.NodeConditionReady
+				case conditionCountsForGroup.NotReady == 1:
+					record.Condition = inframonitoringtypes.NodeConditionNotReady
+				}
+			}
+		}
+
+		if attrs, ok := metadataMap[compositeKey]; ok {
+			for k, v := range attrs {
+				record.Meta[k] = v
+			}
+		}
+
+		records = append(records, record)
+	}
+	return records
+}
+
+func (m *module) getTopNodeGroups(
+	ctx context.Context,
+	orgID valuer.UUID,
+	req *inframonitoringtypes.PostableNodes,
+	metadataMap map[string]map[string]string,
+) ([]map[string]string, error) {
+	orderByKey := req.OrderBy.Key.Name
+	queryNamesForOrderBy := orderByToNodesQueryNames[orderByKey]
+	rankingQueryName := queryNamesForOrderBy[len(queryNamesForOrderBy)-1]
+
+	topReq := &qbtypes.QueryRangeRequest{
+		Start:       uint64(req.Start),
+		End:         uint64(req.End),
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: make([]qbtypes.QueryEnvelope, 0, len(queryNamesForOrderBy)),
+		},
+	}
+
+	for _, envelope := range m.newNodesTableListQuery().CompositeQuery.Queries {
+		if !slices.Contains(queryNamesForOrderBy, envelope.GetQueryName()) {
+			continue
+		}
+		copied := envelope
+		if copied.Type == qbtypes.QueryTypeBuilder {
+			existingExpr := ""
+			if f := copied.GetFilter(); f != nil {
+				existingExpr = f.Expression
+			}
+			reqFilterExpr := ""
+			if req.Filter != nil {
+				reqFilterExpr = req.Filter.Expression
+			}
+			merged := mergeFilterExpressions(existingExpr, reqFilterExpr)
+			copied.SetFilter(&qbtypes.Filter{Expression: merged})
+			copied.SetGroupBy(req.GroupBy)
+		}
+		topReq.CompositeQuery.Queries = append(topReq.CompositeQuery.Queries, copied)
+	}
+
+	resp, err := m.querier.QueryRange(ctx, orgID, topReq)
+	if err != nil {
+		return nil, err
+	}
+
+	allMetricGroups := parseAndSortGroups(resp, rankingQueryName, req.GroupBy, req.OrderBy.Direction)
+	return paginateWithBackfill(allMetricGroups, metadataMap, req.GroupBy, req.Offset, req.Limit), nil
+}
+
+func (m *module) getNodesTableMetadata(ctx context.Context, req *inframonitoringtypes.PostableNodes) (map[string]map[string]string, error) {
+	var nonGroupByAttrs []string
+	for _, key := range nodeAttrKeysForMetadata {
+		if !isKeyInGroupByAttrs(req.GroupBy, key) {
+			nonGroupByAttrs = append(nonGroupByAttrs, key)
+		}
+	}
+	return m.getMetadata(ctx, nodesTableMetricNamesList, req.GroupBy, nonGroupByAttrs, req.Filter, req.Start, req.End)
+}
+
+// getPerGroupNodeConditionCounts computes per-group node counts bucketed by each
+// node's latest condition_ready value (0 / 1) in the requested window.
+// Pipeline:
+//
+//	timeSeriesFPs:           fp ↔ (node_name, groupBy cols) from the time_series table.
+//	                         User filter + page-groups filter applied here.
+//	latestConditionPerNode:  INNER JOIN samples × timeSeriesFPs, collapsed to
+//	                         the latest condition value per node via argMax(value, unix_milli).
+//	countNodesPerCondition:  per-group uniqExactIf into ready/not_ready buckets.
+//
+// Groups absent from the result map have implicit zero counts (caller default).
+func (m *module) getPerGroupNodeConditionCounts(
+	ctx context.Context,
+	req *inframonitoringtypes.PostableNodes,
+	pageGroups []map[string]string,
+) (map[string]nodeConditionCounts, error) {
+	if len(pageGroups) == 0 || len(req.GroupBy) == 0 {
+		return map[string]nodeConditionCounts{}, nil
+	}
+
+	// Merged filter expression (user filter + page-groups IN clauses).
+	reqFilterExpr := ""
+	if req.Filter != nil {
+		reqFilterExpr = req.Filter.Expression
+	}
+	pageGroupsFilterExpr := buildPageGroupsFilterExpr(pageGroups)
+	filterExpr := mergeFilterExpressions(reqFilterExpr, pageGroupsFilterExpr)
+
+	// Resolve tables. Same convention as pods.
+	adjustedStart, adjustedEnd, _, localTimeSeriesTable := telemetrymetrics.WhichTSTableToUse(
+		uint64(req.Start), uint64(req.End), nil,
+	)
+	samplesTable := telemetrymetrics.WhichSamplesTableToUse(
+		uint64(req.Start), uint64(req.End),
+		metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, nil,
+	)
+	valueCol := telemetrymetrics.ValueColumnForSamplesTable(samplesTable)
+
+	// ----- timeSeriesFPs -----
+	timeSeriesFPs := sqlbuilder.NewSelectBuilder()
+	timeSeriesFPsSelectCols := []string{
+		"fingerprint",
+		fmt.Sprintf("JSONExtractString(labels, %s) AS node_name", timeSeriesFPs.Var(nodeNameAttrKey)),
+	}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsSelectCols = append(timeSeriesFPsSelectCols,
+			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", timeSeriesFPs.Var(key.Name), quoteIdentifier(key.Name)),
+		)
+	}
+	timeSeriesFPs.Select(timeSeriesFPsSelectCols...)
+	timeSeriesFPs.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	timeSeriesFPs.Where(
+		timeSeriesFPs.E("metric_name", nodeConditionMetricName),
+		timeSeriesFPs.GE("unix_milli", adjustedStart),
+		timeSeriesFPs.L("unix_milli", adjustedEnd),
+	)
+	if filterExpr != "" {
+		filterClause, err := m.buildFilterClause(ctx, &qbtypes.Filter{Expression: filterExpr}, req.Start, req.End)
+		if err != nil {
+			return nil, err
+		}
+		if filterClause != nil {
+			timeSeriesFPs.AddWhereClause(filterClause)
+		}
+	}
+	timeSeriesFPsGroupBy := []string{"fingerprint", "node_name"}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsGroupBy = append(timeSeriesFPsGroupBy, quoteIdentifier(key.Name))
+	}
+	timeSeriesFPs.GroupBy(timeSeriesFPsGroupBy...)
+	timeSeriesFPsSQL, timeSeriesFPsArgs := timeSeriesFPs.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// ----- latestConditionPerNode -----
+	latestConditionPerNode := sqlbuilder.NewSelectBuilder()
+	latestConditionPerNodeSelectCols := []string{"tsfp.node_name AS node_name"}
+	latestConditionPerNodeGroupBy := []string{"node_name"}
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		latestConditionPerNodeSelectCols = append(latestConditionPerNodeSelectCols, fmt.Sprintf("tsfp.%s AS %s", col, col))
+		latestConditionPerNodeGroupBy = append(latestConditionPerNodeGroupBy, col)
+	}
+	latestConditionPerNodeSelectCols = append(latestConditionPerNodeSelectCols,
+		fmt.Sprintf("argMax(samples.%s, samples.unix_milli) AS condition_value", valueCol),
+	)
+	latestConditionPerNode.Select(latestConditionPerNodeSelectCols...)
+	latestConditionPerNode.From(fmt.Sprintf(
+		"%s.%s AS samples INNER JOIN time_series_fps AS tsfp ON samples.fingerprint = tsfp.fingerprint",
+		telemetrymetrics.DBName, samplesTable,
+	))
+	latestConditionPerNode.Where(
+		latestConditionPerNode.E("samples.metric_name", nodeConditionMetricName),
+		latestConditionPerNode.GE("samples.unix_milli", req.Start),
+		latestConditionPerNode.L("samples.unix_milli", req.End),
+		"tsfp.node_name != ''",
+	)
+	latestConditionPerNode.GroupBy(latestConditionPerNodeGroupBy...)
+	latestConditionPerNodeSQL, latestConditionPerNodeArgs := latestConditionPerNode.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// ----- countNodesPerCondition (outer SELECT) -----
+	countNodesPerConditionSelectCols := make([]string, 0, len(req.GroupBy)+2)
+	countNodesPerConditionGroupBy := make([]string, 0, len(req.GroupBy))
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		countNodesPerConditionSelectCols = append(countNodesPerConditionSelectCols, col)
+		countNodesPerConditionGroupBy = append(countNodesPerConditionGroupBy, col)
+	}
+	countNodesPerConditionSelectCols = append(countNodesPerConditionSelectCols,
+		fmt.Sprintf("uniqExactIf(node_name, condition_value = %d) AS ready_count", inframonitoringtypes.NodeConditionNumReady),
+		fmt.Sprintf("uniqExactIf(node_name, condition_value = %d) AS not_ready_count", inframonitoringtypes.NodeConditionNumNotReady),
+	)
+	countNodesPerConditionSQL := fmt.Sprintf(
+		"SELECT %s FROM latest_condition_per_node GROUP BY %s",
+		strings.Join(countNodesPerConditionSelectCols, ", "),
+		strings.Join(countNodesPerConditionGroupBy, ", "),
+	)
+
+	// Combine CTEs + outer.
+	cteFragments := []string{
+		fmt.Sprintf("time_series_fps AS (%s)", timeSeriesFPsSQL),
+		fmt.Sprintf("latest_condition_per_node AS (%s)", latestConditionPerNodeSQL),
+	}
+	finalSQL := querybuilder.CombineCTEs(cteFragments) + countNodesPerConditionSQL
+	finalArgs := querybuilder.PrependArgs([][]any{timeSeriesFPsArgs, latestConditionPerNodeArgs}, nil)
+
+	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, finalSQL, finalArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	result := make(map[string]nodeConditionCounts)
+	for rows.Next() {
+		groupVals := make([]string, len(req.GroupBy))
+		scanPtrs := make([]any, 0, len(req.GroupBy)+2)
+		for i := range groupVals {
+			scanPtrs = append(scanPtrs, &groupVals[i])
+		}
+		var ready, notReady uint64
+		scanPtrs = append(scanPtrs, &ready, &notReady)
+
+		if err := rows.Scan(scanPtrs...); err != nil {
+			return nil, err
+		}
+		result[compositeKeyFromList(groupVals)] = nodeConditionCounts{
+			Ready:    int(ready),
+			NotReady: int(notReady),
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return result, nil
+}

pkg/modules/inframonitoring/implinframonitoring/nodes_constants.go

@@ -0,0 +1,136 @@
+package implinframonitoring
+
+import (
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+const (
+	nodeNameAttrKey         = "k8s.node.name"
+	nodeConditionMetricName = "k8s.node.condition_ready"
+)
+
+var nodeNameGroupByKey = qbtypes.GroupByKey{
+	TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+		Name:          nodeNameAttrKey,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	},
+}
+
+// nodesTableMetricNamesList drives the existence/retention check.
+// Includes condition_ready so the response short-circuits cleanly when a
+// cluster doesn't ship the metric — even though condition_ready isn't part
+// of the QB composite query (it's queried separately via getPerGroupNodeConditionCounts).
+var nodesTableMetricNamesList = []string{
+	"k8s.node.cpu.usage",
+	"k8s.node.allocatable_cpu",
+	"k8s.node.memory.working_set",
+	"k8s.node.allocatable_memory",
+	nodeConditionMetricName,
+}
+
+var nodeAttrKeysForMetadata = []string{
+	"k8s.node.name",
+	"k8s.node.uid",
+	"k8s.cluster.name",
+}
+
+var orderByToNodesQueryNames = map[string][]string{
+	inframonitoringtypes.NodesOrderByCPU:               {"A"},
+	inframonitoringtypes.NodesOrderByCPUAllocatable:    {"B"},
+	inframonitoringtypes.NodesOrderByMemory:            {"C"},
+	inframonitoringtypes.NodesOrderByMemoryAllocatable: {"D"},
+}
+
+// newNodesTableListQuery builds the composite QB v5 request for the nodes list.
+// Node condition is derived separately via getPerGroupNodeConditionCounts (works
+// for both list and grouped_list modes), so no condition query is included here.
+func (m *module) newNodesTableListQuery() *qbtypes.QueryRangeRequest {
+	queries := []qbtypes.QueryEnvelope{
+		// Query A: CPU usage
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "A",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.node.cpu.usage",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{nodeNameGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query B: CPU allocatable.
+		// TimeAggregationLatest is the closest v5 equivalent of v1's AnyLast;
+		// allocatable values change rarely so divergence in practice is negligible.
+		// TODO(nikhilmantri0902): switch to AnyLast once v5 supports it.
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "B",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.node.allocatable_cpu",
+						TimeAggregation:  metrictypes.TimeAggregationLatest,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{nodeNameGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query C: Memory working set
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "C",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.node.memory.working_set",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{nodeNameGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query D: Memory allocatable. Same Latest caveat as Query B.
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "D",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.node.allocatable_memory",
+						TimeAggregation:  metrictypes.TimeAggregationLatest,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{nodeNameGroupByKey},
+				Disabled: false,
+			},
+		},
+	}
+
+	return &qbtypes.QueryRangeRequest{
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: queries,
+		},
+	}
+}

pkg/modules/inframonitoring/implinframonitoring/pods.go

@@ -0,0 +1,334 @@
+package implinframonitoring
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+// buildPodRecords assembles the page records. Phase counts come from
+// phaseCounts in both modes. In list mode (isPodUIDInGroupBy=true) each
+// group is one pod, so exactly one count is 1; PodPhase is derived from
+// which one. In grouped_list mode PodPhase stays PodPhaseNone.
+func buildPodRecords(
+	isPodUIDInGroupBy bool,
+	resp *qbtypes.QueryRangeResponse,
+	pageGroups []map[string]string,
+	groupBy []qbtypes.GroupByKey,
+	metadataMap map[string]map[string]string,
+	phaseCounts map[string]podPhaseCounts,
+	reqEnd int64,
+) []inframonitoringtypes.PodRecord {
+	metricsMap := parseFullQueryResponse(resp, groupBy)
+
+	records := make([]inframonitoringtypes.PodRecord, 0, len(pageGroups))
+	for _, labels := range pageGroups {
+		compositeKey := compositeKeyFromLabels(labels, groupBy)
+		podUID := labels[podUIDAttrKey]
+
+		record := inframonitoringtypes.PodRecord{ // initialize with default values
+			PodUID:           podUID,
+			PodPhase:         inframonitoringtypes.PodPhaseNone,
+			PodCPU:           -1,
+			PodCPURequest:    -1,
+			PodCPULimit:      -1,
+			PodMemory:        -1,
+			PodMemoryRequest: -1,
+			PodMemoryLimit:   -1,
+			PodAge:           -1,
+			Meta:             map[string]any{},
+		}
+
+		if metrics, ok := metricsMap[compositeKey]; ok {
+			if v, exists := metrics["A"]; exists {
+				record.PodCPU = v
+			}
+			if v, exists := metrics["B"]; exists {
+				record.PodCPURequest = v
+			}
+			if v, exists := metrics["C"]; exists {
+				record.PodCPULimit = v
+			}
+			if v, exists := metrics["D"]; exists {
+				record.PodMemory = v
+			}
+			if v, exists := metrics["E"]; exists {
+				record.PodMemoryRequest = v
+			}
+			if v, exists := metrics["F"]; exists {
+				record.PodMemoryLimit = v
+			}
+		}
+
+		if phaseCountsForGroup, ok := phaseCounts[compositeKey]; ok {
+			record.PendingPodCount = phaseCountsForGroup.Pending
+			record.RunningPodCount = phaseCountsForGroup.Running
+			record.SucceededPodCount = phaseCountsForGroup.Succeeded
+			record.FailedPodCount = phaseCountsForGroup.Failed
+			record.UnknownPodCount = phaseCountsForGroup.Unknown
+
+			// In list mode each group is one pod; the count==1 bucket identifies the phase.
+			if isPodUIDInGroupBy {
+				switch {
+				case phaseCountsForGroup.Pending == 1:
+					record.PodPhase = inframonitoringtypes.PodPhasePending
+				case phaseCountsForGroup.Running == 1:
+					record.PodPhase = inframonitoringtypes.PodPhaseRunning
+				case phaseCountsForGroup.Succeeded == 1:
+					record.PodPhase = inframonitoringtypes.PodPhaseSucceeded
+				case phaseCountsForGroup.Failed == 1:
+					record.PodPhase = inframonitoringtypes.PodPhaseFailed
+				case phaseCountsForGroup.Unknown == 1:
+					record.PodPhase = inframonitoringtypes.PodPhaseUnknown
+				}
+			}
+		}
+
+		if attrs, ok := metadataMap[compositeKey]; ok && isPodUIDInGroupBy {
+			// the condition above ensures we deduce age only if pod uid is in group by because if
+			// it's not in group by then we might have multiple pod uids in the same group and hence then podAge wont make sense
+			if startTimeStr, exists := attrs[podStartTimeAttrKey]; exists && startTimeStr != "" {
+				if t, err := time.Parse(time.RFC3339, startTimeStr); err == nil {
+					startTimeMs := t.UnixMilli()
+					if startTimeMs > 0 {
+						record.PodAge = reqEnd - startTimeMs
+					}
+				}
+			}
+			for k, v := range attrs {
+				record.Meta[k] = v
+			}
+		}
+
+		records = append(records, record)
+	}
+	return records
+}
+
+func (m *module) getTopPodGroups(
+	ctx context.Context,
+	orgID valuer.UUID,
+	req *inframonitoringtypes.PostablePods,
+	metadataMap map[string]map[string]string,
+) ([]map[string]string, error) {
+	orderByKey := req.OrderBy.Key.Name
+	queryNamesForOrderBy := orderByToPodsQueryNames[orderByKey]
+	rankingQueryName := queryNamesForOrderBy[len(queryNamesForOrderBy)-1]
+
+	topReq := &qbtypes.QueryRangeRequest{
+		Start:       uint64(req.Start),
+		End:         uint64(req.End),
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: make([]qbtypes.QueryEnvelope, 0, len(queryNamesForOrderBy)),
+		},
+	}
+
+	for _, envelope := range m.newPodsTableListQuery().CompositeQuery.Queries {
+		if !slices.Contains(queryNamesForOrderBy, envelope.GetQueryName()) {
+			continue
+		}
+		copied := envelope
+		if copied.Type == qbtypes.QueryTypeBuilder {
+			existingExpr := ""
+			if f := copied.GetFilter(); f != nil {
+				existingExpr = f.Expression
+			}
+			reqFilterExpr := ""
+			if req.Filter != nil {
+				reqFilterExpr = req.Filter.Expression
+			}
+			merged := mergeFilterExpressions(existingExpr, reqFilterExpr)
+			copied.SetFilter(&qbtypes.Filter{Expression: merged})
+			copied.SetGroupBy(req.GroupBy)
+		}
+		topReq.CompositeQuery.Queries = append(topReq.CompositeQuery.Queries, copied)
+	}
+
+	resp, err := m.querier.QueryRange(ctx, orgID, topReq)
+	if err != nil {
+		return nil, err
+	}
+
+	allMetricGroups := parseAndSortGroups(resp, rankingQueryName, req.GroupBy, req.OrderBy.Direction)
+	return paginateWithBackfill(allMetricGroups, metadataMap, req.GroupBy, req.Offset, req.Limit), nil
+}
+
+func (m *module) getPodsTableMetadata(ctx context.Context, req *inframonitoringtypes.PostablePods) (map[string]map[string]string, error) {
+	var nonGroupByAttrs []string
+	for _, key := range podAttrKeysForMetadata {
+		if !isKeyInGroupByAttrs(req.GroupBy, key) {
+			nonGroupByAttrs = append(nonGroupByAttrs, key)
+		}
+	}
+	return m.getMetadata(ctx, podsTableMetricNamesList, req.GroupBy, nonGroupByAttrs, req.Filter, req.Start, req.End)
+}
+
+// getPerGroupPodPhaseCounts computes per-group pod counts bucketed by each
+// pod's latest phase in the requested window.
+// Pipeline:
+//
+//	timeSeriesFPs:      fp ↔ (pod_uid, groupBy cols) from the time_series table.
+//	                    User filter + page-groups filter applied here.
+//	latestPhasePerPod:  INNER JOIN samples × timeSeriesFPs, collapsed to
+//	                    the latest phase per pod via argMax(value, unix_milli).
+//	countPodsPerPhase:  per-group uniqExactIf into 5 phase buckets.
+//
+// Groups absent from the result map have implicit zero counts (caller default).
+func (m *module) getPerGroupPodPhaseCounts(
+	ctx context.Context,
+	req *inframonitoringtypes.PostablePods,
+	pageGroups []map[string]string,
+) (map[string]podPhaseCounts, error) {
+	if len(pageGroups) == 0 || len(req.GroupBy) == 0 {
+		return map[string]podPhaseCounts{}, nil
+	}
+
+	// Merged filter expression (user filter + page-groups IN clauses).
+	reqFilterExpr := ""
+	if req.Filter != nil {
+		reqFilterExpr = req.Filter.Expression
+	}
+	pageGroupsFilterExpr := buildPageGroupsFilterExpr(pageGroups)
+	filterExpr := mergeFilterExpressions(reqFilterExpr, pageGroupsFilterExpr)
+
+	// Resolve tables. Same convention as hosts (distributed names from helpers).
+	adjustedStart, adjustedEnd, _, localTimeSeriesTable := telemetrymetrics.WhichTSTableToUse(
+		uint64(req.Start), uint64(req.End), nil,
+	)
+	samplesTable := telemetrymetrics.WhichSamplesTableToUse(
+		uint64(req.Start), uint64(req.End),
+		metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, nil,
+	)
+	valueCol := telemetrymetrics.ValueColumnForSamplesTable(samplesTable)
+
+	// ----- timeSeriesFPs -----
+	timeSeriesFPs := sqlbuilder.NewSelectBuilder()
+	timeSeriesFPsSelectCols := []string{
+		"fingerprint",
+		fmt.Sprintf("JSONExtractString(labels, %s) AS pod_uid", timeSeriesFPs.Var(podUIDAttrKey)),
+	}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsSelectCols = append(timeSeriesFPsSelectCols,
+			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", timeSeriesFPs.Var(key.Name), quoteIdentifier(key.Name)),
+		)
+	}
+	timeSeriesFPs.Select(timeSeriesFPsSelectCols...)
+	timeSeriesFPs.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	timeSeriesFPs.Where(
+		timeSeriesFPs.E("metric_name", podPhaseMetricName),
+		timeSeriesFPs.GE("unix_milli", adjustedStart),
+		timeSeriesFPs.L("unix_milli", adjustedEnd),
+	)
+	if filterExpr != "" {
+		filterClause, err := m.buildFilterClause(ctx, &qbtypes.Filter{Expression: filterExpr}, req.Start, req.End)
+		if err != nil {
+			return nil, err
+		}
+		if filterClause != nil {
+			timeSeriesFPs.AddWhereClause(filterClause)
+		}
+	}
+	timeSeriesFPsGroupBy := []string{"fingerprint", "pod_uid"}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsGroupBy = append(timeSeriesFPsGroupBy, quoteIdentifier(key.Name))
+	}
+	timeSeriesFPs.GroupBy(timeSeriesFPsGroupBy...)
+	timeSeriesFPsSQL, timeSeriesFPsArgs := timeSeriesFPs.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	latestPhasePerPod := sqlbuilder.NewSelectBuilder()
+	latestPhasePerPodSelectCols := []string{"tsfp.pod_uid AS pod_uid"}
+	latestPhasePerPodGroupBy := []string{"pod_uid"}
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		latestPhasePerPodSelectCols = append(latestPhasePerPodSelectCols, fmt.Sprintf("tsfp.%s AS %s", col, col))
+		latestPhasePerPodGroupBy = append(latestPhasePerPodGroupBy, col)
+	}
+	latestPhasePerPodSelectCols = append(latestPhasePerPodSelectCols,
+		fmt.Sprintf("argMax(samples.%s, samples.unix_milli) AS phase_value", valueCol),
+	)
+	latestPhasePerPod.Select(latestPhasePerPodSelectCols...)
+	latestPhasePerPod.From(fmt.Sprintf(
+		"%s.%s AS samples INNER JOIN time_series_fps AS tsfp ON samples.fingerprint = tsfp.fingerprint",
+		telemetrymetrics.DBName, samplesTable,
+	))
+	latestPhasePerPod.Where(
+		latestPhasePerPod.E("samples.metric_name", podPhaseMetricName),
+		latestPhasePerPod.GE("samples.unix_milli", req.Start),
+		latestPhasePerPod.L("samples.unix_milli", req.End),
+		"tsfp.pod_uid != ''",
+	)
+	latestPhasePerPod.GroupBy(latestPhasePerPodGroupBy...)
+	latestPhasePerPodSQL, latestPhasePerPodArgs := latestPhasePerPod.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// ----- countPodsPerPhase (outer SELECT) -----
+	countPodsPerPhaseSelectCols := make([]string, 0, len(req.GroupBy)+5)
+	countPodsPerPhaseGroupBy := make([]string, 0, len(req.GroupBy))
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		countPodsPerPhaseSelectCols = append(countPodsPerPhaseSelectCols, col)
+		countPodsPerPhaseGroupBy = append(countPodsPerPhaseGroupBy, col)
+	}
+	countPodsPerPhaseSelectCols = append(countPodsPerPhaseSelectCols,
+		fmt.Sprintf("uniqExactIf(pod_uid, phase_value = %d) AS pending_count", inframonitoringtypes.PodPhaseNumPending),
+		fmt.Sprintf("uniqExactIf(pod_uid, phase_value = %d) AS running_count", inframonitoringtypes.PodPhaseNumRunning),
+		fmt.Sprintf("uniqExactIf(pod_uid, phase_value = %d) AS succeeded_count", inframonitoringtypes.PodPhaseNumSucceeded),
+		fmt.Sprintf("uniqExactIf(pod_uid, phase_value = %d) AS failed_count", inframonitoringtypes.PodPhaseNumFailed),
+		fmt.Sprintf("uniqExactIf(pod_uid, phase_value = %d) AS unknown_count", inframonitoringtypes.PodPhaseNumUnknown),
+	)
+	countPodsPerPhaseSQL := fmt.Sprintf(
+		"SELECT %s FROM latest_phase_per_pod GROUP BY %s",
+		strings.Join(countPodsPerPhaseSelectCols, ", "),
+		strings.Join(countPodsPerPhaseGroupBy, ", "),
+	)
+
+	// Combine CTEs + outer.
+	cteFragments := []string{
+		fmt.Sprintf("time_series_fps AS (%s)", timeSeriesFPsSQL),
+		fmt.Sprintf("latest_phase_per_pod AS (%s)", latestPhasePerPodSQL),
+	}
+	finalSQL := querybuilder.CombineCTEs(cteFragments) + countPodsPerPhaseSQL
+	finalArgs := querybuilder.PrependArgs([][]any{timeSeriesFPsArgs, latestPhasePerPodArgs}, nil)
+
+	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, finalSQL, finalArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	result := make(map[string]podPhaseCounts)
+	for rows.Next() {
+		groupVals := make([]string, len(req.GroupBy))
+		scanPtrs := make([]any, 0, len(req.GroupBy)+5)
+		for i := range groupVals {
+			scanPtrs = append(scanPtrs, &groupVals[i])
+		}
+		var pending, running, succeeded, failed, unknown uint64
+		scanPtrs = append(scanPtrs, &pending, &running, &succeeded, &failed, &unknown)
+
+		if err := rows.Scan(scanPtrs...); err != nil {
+			return nil, err
+		}
+		result[compositeKeyFromList(groupVals)] = podPhaseCounts{
+			Pending:   int(pending),
+			Running:   int(running),
+			Succeeded: int(succeeded),
+			Failed:    int(failed),
+			Unknown:   int(unknown),
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return result, nil
+}

pkg/modules/inframonitoring/implinframonitoring/pods_constants.go

@@ -0,0 +1,178 @@
+package implinframonitoring
+
+import (
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+const (
+	podUIDAttrKey       = "k8s.pod.uid"
+	podStartTimeAttrKey = "k8s.pod.start_time"
+	podPhaseMetricName  = "k8s.pod.phase"
+)
+
+var podUIDGroupByKey = qbtypes.GroupByKey{
+	TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+		Name:          podUIDAttrKey,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	},
+}
+
+var podsTableMetricNamesList = []string{
+	"k8s.pod.cpu.usage",
+	"k8s.pod.cpu_request_utilization",
+	"k8s.pod.cpu_limit_utilization",
+	"k8s.pod.memory.working_set",
+	"k8s.pod.memory_request_utilization",
+	"k8s.pod.memory_limit_utilization",
+	"k8s.pod.phase",
+}
+
+var podAttrKeysForMetadata = []string{
+	"k8s.pod.uid",
+	"k8s.pod.name",
+	"k8s.namespace.name",
+	"k8s.node.name",
+	"k8s.deployment.name",
+	"k8s.statefulset.name",
+	"k8s.daemonset.name",
+	"k8s.job.name",
+	"k8s.cronjob.name",
+	"k8s.cluster.name",
+	"k8s.pod.start_time",
+}
+
+var orderByToPodsQueryNames = map[string][]string{
+	inframonitoringtypes.PodsOrderByCPU:           {"A"},
+	inframonitoringtypes.PodsOrderByCPURequest:    {"B"},
+	inframonitoringtypes.PodsOrderByCPULimit:      {"C"},
+	inframonitoringtypes.PodsOrderByMemory:        {"D"},
+	inframonitoringtypes.PodsOrderByMemoryRequest: {"E"},
+	inframonitoringtypes.PodsOrderByMemoryLimit:   {"F"},
+}
+
+// newPodsTableListQuery builds the composite QB v5 request for the pods list.
+// Pod phase is derived separately via getPerGroupPodPhaseCounts (works for both
+// list and grouped_list modes), so no phase query is included here.
+func (m *module) newPodsTableListQuery() *qbtypes.QueryRangeRequest {
+	queries := []qbtypes.QueryEnvelope{
+		// Query A: CPU usage
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "A",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu.usage",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query B: CPU request utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "B",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu_request_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query C: CPU limit utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "C",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu_limit_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query D: Memory working set
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "D",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory.working_set",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query E: Memory request utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "E",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory_request_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query F: Memory limit utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "F",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory_limit_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+	}
+
+	return &qbtypes.QueryRangeRequest{
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: queries,
+		},
+	}
+}

pkg/modules/inframonitoring/inframonitoring.go

@@ -10,8 +10,12 @@ import (
 
 type Handler interface {
 	ListHosts(http.ResponseWriter, *http.Request)
+	ListPods(http.ResponseWriter, *http.Request)
+	ListNodes(http.ResponseWriter, *http.Request)
 }
 
 type Module interface {
 	ListHosts(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableHosts) (*inframonitoringtypes.Hosts, error)
+	ListPods(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostablePods) (*inframonitoringtypes.Pods, error)
+	ListNodes(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableNodes) (*inframonitoringtypes.Nodes, error)
 }

pkg/modules/promote/implpromote/module.go

@@ -32,17 +32,27 @@ func NewModule(metadataStore telemetrytypes.MetadataStore, telemetrystore teleme
 }
 
 func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetypes.PromotePath, error) {
-	indexes, err := m.metadataStore.ListLogsJSONIndexes(ctx)
+	logsIndexes, err := m.metadataStore.ListLogsJSONIndexes(ctx)
 	if err != nil {
 		return nil, err
 	}
+	// Flatten the map values (which are slices) into a single slice
+	indexes := slices.Concat(slices.Collect(maps.Values(logsIndexes))...)
 
 	aggr := map[string][]promotetypes.WrappedIndex{}
 	for _, index := range indexes {
-		aggr[index.Name] = append(aggr[index.Name], promotetypes.WrappedIndex{
-			FieldDataType: index.FieldDataType,
-			Type:          index.IndexType,
-			Granularity:   index.Granularity,
+		path, columnType, err := schemamigrator.UnfoldJSONSubColumnIndexExpr(index.Expression)
+		if err != nil {
+			return nil, err
+		}
+
+		// clean backticks from the path
+		path = strings.ReplaceAll(path, "`", "")
+
+		aggr[path] = append(aggr[path], promotetypes.WrappedIndex{
+			ColumnType:  columnType,
+			Type:        index.Type,
+			Granularity: index.Granularity,
 		})
 	}
 	promotedPaths, err := m.listPromotedPaths(ctx)

pkg/modules/spanmapper/implspanmapper/handler.go

@@ -1,301 +0,0 @@
-package implspanmapper
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module           spanmapper.Module
-	providerSettings factory.ProviderSettings
-}
-
-func NewHandler(module spanmapper.Module, providerSettings factory.ProviderSettings) spanmapper.Handler {
-	return &handler{module: module, providerSettings: providerSettings}
-}
-
-// ListGroups handles GET /api/v1/span_mapper_groups.
-func (h *handler) ListGroups(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	var q spantypes.ListSpanMapperGroupsQuery
-	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groups, err := h.module.ListGroups(ctx, orgID, &q)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spantypes.NewGettableSpanMapperGroups(groups))
-}
-
-// CreateGroup handles POST /api/v1/span_mapper_groups.
-func (h *handler) CreateGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	req := new(spantypes.PostableSpanMapperGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	group := spantypes.NewSpanMapperGroupFromPostable(req)
-
-	err = h.module.CreateGroup(ctx, orgID, claims.Email, group)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	render.Success(rw, http.StatusCreated, group)
-}
-
-// UpdateGroup handles PUT /api/v1/span_mapper_groups/{id}.
-func (h *handler) UpdateGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.UpdatableSpanMapperGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateGroup(ctx, orgID, id, claims.Email, spantypes.NewSpanMapperGroupFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteGroup handles DELETE /api/v1/span_mapper_groups/{id}.
-func (h *handler) DeleteGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteGroup(ctx, orgID, id); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// ListMappers handles GET /api/v1/span_mapper_groups/{id}/span_mappers.
-func (h *handler) ListMappers(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mappers, err := h.module.ListMappers(ctx, orgID, groupID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spantypes.NewGettableSpanMappers(mappers))
-}
-
-// CreateMapper handles POST /api/v1/span_mapper_groups/{id}/span_mappers.
-func (h *handler) CreateMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.PostableSpanMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	mapper := spantypes.NewSpanMapperFromPostable(req)
-
-	err = h.module.CreateMapper(ctx, orgID, groupID, claims.Email, mapper)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, mapper)
-}
-
-// UpdateMapper handles PUT /api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}.
-func (h *handler) UpdateMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.UpdatableSpanMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateMapper(ctx, orgID, groupID, mapperID, claims.Email, spantypes.NewSpanMapperFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteMapper handles DELETE /api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}.
-func (h *handler) DeleteMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteMapper(ctx, orgID, groupID, mapperID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// groupIDFromPath extracts and validates the {id} or {groupId} path variable.
-func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
-	vars := mux.Vars(r)
-	raw := vars["groupId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "group id is not a valid uuid")
-	}
-	return id, nil
-}
-
-// mapperIDFromPath extracts and validates the {mapperId} path variable.
-func mapperIDFromPath(r *http.Request) (valuer.UUID, error) {
-	raw := mux.Vars(r)["mapperId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "mapper id is not a valid uuid")
-	}
-	return id, nil
-}

pkg/modules/spanmapper/spanmapper.go

@@ -1,41 +0,0 @@
-package spanmapper
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Module defines the business logic for span attribute mapping groups and mappers.
-type Module interface {
-	// Group operations
-	ListGroups(ctx context.Context, orgID valuer.UUID, q *spantypes.ListSpanMapperGroupsQuery) ([]*spantypes.SpanMapperGroup, error)
-	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapperGroup, error)
-	CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, group *spantypes.SpanMapperGroup) error
-	UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, group *spantypes.SpanMapperGroup) error
-	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spantypes.SpanMapper, error)
-	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapper, error)
-	CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, mapper *spantypes.SpanMapper) error
-	UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, mapper *spantypes.SpanMapper) error
-	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
-}
-
-// Handler defines the HTTP handler interface for mapping group and mapper endpoints.
-type Handler interface {
-	// Group handlers
-	ListGroups(rw http.ResponseWriter, r *http.Request)
-	CreateGroup(rw http.ResponseWriter, r *http.Request)
-	UpdateGroup(rw http.ResponseWriter, r *http.Request)
-	DeleteGroup(rw http.ResponseWriter, r *http.Request)
-
-	// Mapper handlers
-	ListMappers(rw http.ResponseWriter, r *http.Request)
-	CreateMapper(rw http.ResponseWriter, r *http.Request)
-	UpdateMapper(rw http.ResponseWriter, r *http.Request)
-	DeleteMapper(rw http.ResponseWriter, r *http.Request)
-}

pkg/querybuilder/collision.go

@@ -204,7 +204,7 @@ func AdjustKey(key *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemet
 		// Downstream query builder should handle multiple matching keys with their own metadata
 		// and not rely on this function to do so.
 		materialized := true
-		indexes := []telemetrytypes.TelemetryFieldKeySkipIndex{}
+		indexes := []telemetrytypes.JSONDataTypeIndex{}
 		fieldContextsSeen := map[telemetrytypes.FieldContext]bool{}
 		dataTypesSeen := map[telemetrytypes.FieldDataType]bool{}
 		for _, matchingKey := range matchingKeys {

pkg/signoz/handler.go

@@ -36,8 +36,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/services"
 	"github.com/SigNoz/signoz/pkg/modules/services/implservices"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper/implspanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
@@ -73,7 +71,6 @@ type Handlers struct {
 	RegistryHandler         factory.Handler
 	CloudIntegrationHandler cloudintegration.Handler
 	RuleStateHistory        rulestatehistory.Handler
-	SpanMapperHandler       spanmapper.Handler
 	AlertmanagerHandler     alertmanager.Handler
 	TraceDetail             tracedetail.Handler
 	RulerHandler            ruler.Handler
@@ -117,7 +114,6 @@ func NewHandlers(
 		RegistryHandler:         registryHandler,
 		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
 		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
-		SpanMapperHandler:       implspanmapper.NewHandler(nil, providerSettings), // todo(nitya): will update this in future PR
 		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
 		TraceDetail:             impltracedetail.NewHandler(modules.TraceDetail),
 		RulerHandler:            signozruler.NewHandler(rulerService),

pkg/signoz/openapi.go

@@ -21,8 +21,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -30,7 +30,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
@@ -75,7 +74,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
-		struct{ spanmapper.Handler }{},
 		struct{ alertmanager.Handler }{},
 		struct{ tracedetail.Handler }{},
 		struct{ ruler.Handler }{},

pkg/signoz/provider.go

@@ -281,7 +281,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
-			handlers.SpanMapperHandler,
 			handlers.AlertmanagerHandler,
 			handlers.TraceDetail,
 			handlers.RulerHandler,

pkg/telemetrylogs/json_condition_builder.go

@@ -195,8 +195,8 @@ func (c *jsonConditionBuilder) buildPrimitiveTerminalCondition(node *telemetryty
 	// the field genuinely holds the empty/zero value.
 	//
 	// Note: indexing is also skipped for Array Nested fields because they cannot be indexed.
-	indexed := slices.ContainsFunc(node.TerminalConfig.Key.Indexes, func(index telemetrytypes.TelemetryFieldKeySkipIndex) bool {
-		return telemetrytypes.MappingFieldDataTypeToJSONDataType[index.FieldDataType] == node.TerminalConfig.ElemType
+	indexed := slices.ContainsFunc(node.TerminalConfig.Key.Indexes, func(index telemetrytypes.JSONDataTypeIndex) bool {
+		return index.Type == node.TerminalConfig.ElemType
 	})
 	isExistsCheck := operator == qbtypes.FilterOperatorExists || operator == qbtypes.FilterOperatorNotExists
 	if node.TerminalConfig.ElemType.IndexSupported && indexed && !isExistsCheck {

pkg/telemetrylogs/json_stmt_builder_test.go

@@ -1127,12 +1127,9 @@ func buildTestTelemetryMetadataStore(t *testing.T, addIndexes bool) *telemetryty
 					return entry.Path == path && entry.Type == jsonType
 				})
 				if idx >= 0 {
-					key.Indexes = append(key.Indexes, telemetrytypes.TelemetryFieldKeySkipIndex{
-						Name:            path,
-						FieldContext:    telemetrytypes.FieldContextBody,
-						FieldDataType:   fdt,
-						BaseColumn:      LogsV2BodyV2Column,
-						IndexExpression: schemamigrator.JSONSubColumnIndexExpr(LogsV2BodyV2Column, path, jsonType.StringValue()),
+					key.Indexes = append(key.Indexes, telemetrytypes.JSONDataTypeIndex{
+						Type:             jsonType,
+						ColumnExpression: schemamigrator.JSONSubColumnIndexExpr(LogsV2BodyV2Column, path, jsonType.StringValue()),
 					})
 				}
 			}

pkg/telemetrymetadata/body_json_metadata.go

@@ -106,7 +106,7 @@ func (t *telemetryMetaStore) buildJSONPlans(keys []*telemetrytypes.TelemetryFiel
 	return nil
 }
 
-func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...string) (map[string][]telemetrytypes.TelemetryFieldKeySkipIndex, error) {
+func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...string) (map[string][]telemetrytypes.JSONDataTypeIndex, error) {
 	filteredPaths := []string{}
 	for _, path := range paths {
 		// skip array paths; since they don't have any indexes
@@ -116,22 +116,47 @@ func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...st
 		filteredPaths = append(filteredPaths, path)
 	}
 	if len(filteredPaths) == 0 {
-		return make(map[string][]telemetrytypes.TelemetryFieldKeySkipIndex), nil
+		return make(map[string][]telemetrytypes.JSONDataTypeIndex), nil
 	}
 
 	// list indexes for the paths
-	indexes, err := t.ListLogsJSONIndexes(ctx, filteredPaths...)
+	indexesMap, err := t.ListLogsJSONIndexes(ctx, filteredPaths...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to list JSON path indexes")
 	}
 
 	// build a set of indexes
-	fieldPathToIndexes := make(map[string][]telemetrytypes.TelemetryFieldKeySkipIndex)
-	for _, index := range indexes {
-		fieldPathToIndexes[index.Name] = append(fieldPathToIndexes[index.Name], index)
+	cleanIndexes := make(map[string][]telemetrytypes.JSONDataTypeIndex)
+	for path, indexes := range indexesMap {
+		for _, index := range indexes {
+			columnExpr, columnType, err := schemamigrator.UnfoldJSONSubColumnIndexExpr(index.Expression)
+			if err != nil {
+				return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to unfold JSON sub column index expression: %s", index.Expression)
+			}
+
+			jsonDataType, found := telemetrytypes.MappingStringToJSONDataType[columnType]
+			if !found {
+				t.logger.ErrorContext(ctx, "failed to map column type to JSON data type", slog.String("column_type", columnType), slog.String("column_expr", columnExpr))
+				continue
+			}
+
+			if jsonDataType == telemetrytypes.String {
+				cleanIndexes[path] = append(cleanIndexes[path], telemetrytypes.JSONDataTypeIndex{
+					Type:             telemetrytypes.String,
+					ColumnExpression: columnExpr,
+					IndexExpression:  index.Expression,
+				})
+			} else if strings.HasPrefix(index.Type, "minmax") {
+				cleanIndexes[path] = append(cleanIndexes[path], telemetrytypes.JSONDataTypeIndex{
+					Type:             jsonDataType,
+					ColumnExpression: columnExpr,
+					IndexExpression:  index.Expression,
+				})
+			}
+		}
 	}
 
-	return fieldPathToIndexes, nil
+	return cleanIndexes, nil
 }
 
 func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, []any) {
@@ -148,15 +173,14 @@ func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, [
 
 	filterExprs := []string{}
 	for _, filter := range filters {
-		// Remove backticks from actual expr cuz paths from metadata doesn't have backticks
-		filterExprs = append(filterExprs, sb.ILike("replaceAll(expr, '`', '')", fmt.Sprintf("%%%s%%", querybuilder.FormatValueForContains(filter))))
+		filterExprs = append(filterExprs, sb.ILike("expr", fmt.Sprintf("%%%s%%", querybuilder.FormatValueForContains(filter))))
 	}
 	sb.Where(sb.Or(filterExprs...))
 
 	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
 }
 
-func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) ([]telemetrytypes.TelemetryFieldKeySkipIndex, error) {
+func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
 	ctx = withTelemetryContext(ctx, "ListLogsJSONIndexes")
 	query, args := buildListLogsJSONIndexesQuery(t.telemetrystore.Cluster(), filters...)
 	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
@@ -165,7 +189,7 @@ func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ..
 	}
 	defer rows.Close()
 
-	indexes := []telemetrytypes.TelemetryFieldKeySkipIndex{}
+	indexes := make(map[string][]schemamigrator.Index)
 	for rows.Next() {
 		var name string
 		var typeFull string
@@ -174,39 +198,11 @@ func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ..
 		if err := rows.Scan(&name, &typeFull, &expr, &granularity); err != nil {
 			return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to scan string indexed column")
 		}
-
-		columnExpr, columnType, err := schemamigrator.UnfoldJSONSubColumnIndexExpr(expr)
-		if err != nil {
-			return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to unfold JSON sub column index expression: %s", expr)
-		}
-
-		fdt, found := telemetrytypes.MappingJSONDataTypeToFieldDataType[columnType]
-		if !found {
-			t.logger.ErrorContext(ctx, "failed to map JSON data type to field data type", slog.String("column_type", columnType), slog.String("column_expr", columnExpr))
-			continue
-		}
-
-		baseColumn := ""
-		fieldName := ""
-		switch {
-		case strings.HasPrefix(columnExpr, telemetrylogs.BodyV2ColumnPrefix):
-			baseColumn = telemetrylogs.BodyV2ColumnPrefix
-			fieldName = strings.TrimPrefix(columnExpr, telemetrylogs.BodyV2ColumnPrefix)
-		case strings.HasPrefix(columnExpr, telemetrylogs.BodyPromotedColumnPrefix):
-			baseColumn = telemetrylogs.BodyPromotedColumnPrefix
-			fieldName = strings.TrimPrefix(columnExpr, telemetrylogs.BodyPromotedColumnPrefix)
-		}
-		fieldName = strings.ReplaceAll(fieldName, "`", "")
-
-		indexes = append(indexes, telemetrytypes.TelemetryFieldKeySkipIndex{
-			Name:            fieldName,
-			FieldContext:    telemetrytypes.FieldContextBody,
-			FieldDataType:   fdt,
-			BaseColumn:      baseColumn,
-			IndexName:       name,
-			IndexType:       typeFull,
-			IndexExpression: expr,
-			Granularity:     int(granularity),
+		indexes[name] = append(indexes[name], schemamigrator.Index{
+			Name:        name,
+			Type:        typeFull,
+			Expression:  expr,
+			Granularity: int(granularity),
 		})
 	}
 

pkg/telemetrymetadata/body_json_metadata_test.go

@@ -36,7 +36,7 @@ func TestBuildListLogsJSONIndexesQuery(t *testing.T) {
 			cluster: "test-cluster",
 			filters: []string{"foo", "bar"},
 			expectedSQL: "SELECT name, type_full, expr, granularity FROM clusterAllReplicas('test-cluster', system.data_skipping_indices) " +
-				"WHERE database = ? AND table = ? AND (LOWER(expr) LIKE LOWER(?) OR LOWER(expr) LIKE LOWER(?)) AND (LOWER(replaceAll(expr, '`', '')) LIKE LOWER(?) OR LOWER(replaceAll(expr, '`', '')) LIKE LOWER(?))",
+				"WHERE database = ? AND table = ? AND (LOWER(expr) LIKE LOWER(?) OR LOWER(expr) LIKE LOWER(?)) AND (LOWER(expr) LIKE LOWER(?) OR LOWER(expr) LIKE LOWER(?))",
 			expectedArgs: []any{
 				telemetrylogs.DBName,
 				telemetrylogs.LogsV2LocalTableName,

pkg/telemetrymetrics/tables.go

@@ -124,6 +124,17 @@ func CountExpressionForSamplesTable(tableName string) string {
 	return "sum(count)"
 }
 
+// ValueColumnForSamplesTable returns the column name holding the sample value:
+// "last" for the 5m/30m aggregated tables, "value" otherwise.
+// note all the other columns in the aggregated samples tables are nothing but aggregations.
+// and so "last" is the value column for these tables.
+func ValueColumnForSamplesTable(tableName string) string {
+	if tableName == SamplesV4Agg5mTableName || tableName == SamplesV4Agg30mTableName {
+		return "last"
+	}
+	return "value"
+}
+
 // start and end are in milliseconds
 // we have three tables for samples
 // 1. distributed_samples_v4

pkg/types/cloudintegrationtypes/cloudprovider_azure.go

@@ -1,39 +1,5 @@
 package cloudintegrationtypes
 
-import (
-	"bytes"
-	"fmt"
-	"text/template"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	AgentArmTemplateStorePath = "https://signoz-integrations.s3.us-east-1.amazonaws.com/azure-arm-template-%s.json"
-	AgentDeploymentStackName  = "signoz-integration"
-
-	// Default values for fixed ARM template parameters.
-	armDefaultRgName           = "signoz-integration-rg"
-	armDefaultContainerEnvName = "signoz-integration-agent-env"
-	armDefaultDeploymentEnv    = "production"
-
-	// ARM template parameter key names used in both CLI and PowerShell deployment commands.
-	armParamLocation           = "location"
-	armParamSignozAPIKey       = "signozApiKey"
-	armParamSignozAPIUrl       = "signozApiUrl"
-	armParamSignozIngestionURL = "signozIngestionUrl"
-	armParamSignozIngestionKey = "signozIngestionKey"
-	armParamAccountID          = "signozIntegrationAccountId"
-	armParamAgentVersion       = "signozIntegrationAgentVersion"
-	armParamRgName             = "rgName"
-	armParamContainerEnvName   = "containerEnvName"
-	armParamDeploymentEnv      = "deploymentEnv"
-
-	// command templates.
-	azureCLITemplate        = template.Must(template.New("azureCLI").Parse(azureCLITemplateStr()))
-	azurePowerShellTemplate = template.Must(template.New("azurePS").Parse(azurePowerShellTemplateStr()))
-)
-
 type AzureAccountConfig struct {
 	DeploymentRegion string   `json:"deploymentRegion" required:"true"`
 	ResourceGroups   []string `json:"resourceGroups" required:"true" nullable:"false"`
@@ -85,36 +51,6 @@ type AzureIntegrationConfig struct {
 	TelemetryCollectionStrategy []*AzureTelemetryCollectionStrategy `json:"telemetryCollectionStrategy" required:"true" nullable:"false"`
 }
 
-// azureTemplateData is the data struct passed to both command templates.
-// All fields are exported so text/template can access them.
-type azureTemplateData struct {
-	// Deploy parameter values.
-	TemplateURL        string
-	Location           string
-	SignozAPIKey       string
-	SignozAPIUrl       string
-	SignozIngestionURL string
-	SignozIngestionKey string
-	AccountID          string
-	AgentVersion       string
-	// ARM parameter key names (from package-level vars).
-	StackName               string
-	ParamLocation           string
-	ParamSignozAPIKey       string
-	ParamSignozAPIUrl       string
-	ParamSignozIngestionURL string
-	ParamSignozIngestionKey string
-	ParamAccountID          string
-	ParamAgentVersion       string
-	ParamRgName             string
-	ParamContainerEnvName   string
-	ParamDeploymentEnv      string
-	// Fixed default values.
-	DefaultRgName           string
-	DefaultContainerEnvName string
-	DefaultDeploymentEnv    string
-}
-
 func NewAzureIntegrationConfig(
 	deploymentRegion string,
 	resourceGroups []string,
@@ -126,105 +62,3 @@ func NewAzureIntegrationConfig(
 		TelemetryCollectionStrategy: strategies,
 	}
 }
-
-func NewAzureConnectionArtifact(
-	accountID valuer.UUID,
-	agentVersion string,
-	creds *Credentials,
-	cfg *AzurePostableAccountConfig,
-) (*AzureConnectionArtifact, error) {
-	data := azureTemplateData{
-		TemplateURL:             fmt.Sprintf(AgentArmTemplateStorePath, agentVersion),
-		Location:                cfg.DeploymentRegion,
-		SignozAPIKey:            creds.SigNozAPIKey,
-		SignozAPIUrl:            creds.SigNozAPIURL,
-		SignozIngestionURL:      creds.IngestionURL,
-		SignozIngestionKey:      creds.IngestionKey,
-		AccountID:               accountID.StringValue(),
-		AgentVersion:            agentVersion,
-		StackName:               AgentDeploymentStackName,
-		ParamLocation:           armParamLocation,
-		ParamSignozAPIKey:       armParamSignozAPIKey,
-		ParamSignozAPIUrl:       armParamSignozAPIUrl,
-		ParamSignozIngestionURL: armParamSignozIngestionURL,
-		ParamSignozIngestionKey: armParamSignozIngestionKey,
-		ParamAccountID:          armParamAccountID,
-		ParamAgentVersion:       armParamAgentVersion,
-		ParamRgName:             armParamRgName,
-		ParamContainerEnvName:   armParamContainerEnvName,
-		ParamDeploymentEnv:      armParamDeploymentEnv,
-		DefaultRgName:           armDefaultRgName,
-		DefaultContainerEnvName: armDefaultContainerEnvName,
-		DefaultDeploymentEnv:    armDefaultDeploymentEnv,
-	}
-
-	cliCommand, err := newAzureConnectionCLICommand(data)
-	if err != nil {
-		return nil, err
-	}
-
-	psCommand, err := newAzureConnectionPowerShellCommand(data)
-	if err != nil {
-		return nil, err
-	}
-	return &AzureConnectionArtifact{
-		CLICommand:             cliCommand,
-		CloudPowerShellCommand: psCommand,
-	}, nil
-}
-
-func newAzureConnectionCLICommand(data azureTemplateData) (string, error) {
-	var buf bytes.Buffer
-	err := azureCLITemplate.Execute(&buf, data)
-	if err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-func newAzureConnectionPowerShellCommand(data azureTemplateData) (string, error) {
-	var buf bytes.Buffer
-	err := azurePowerShellTemplate.Execute(&buf, data)
-	if err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-func azureCLITemplateStr() string {
-	return `az stack sub create \
-  --name {{.StackName}} \
-  --location {{.Location}} \
-  --template-uri {{.TemplateURL}} \
-  --parameters \
-    {{.ParamLocation}}='{{.Location}}' \
-    {{.ParamSignozAPIKey}}='{{.SignozAPIKey}}' \
-    {{.ParamSignozAPIUrl}}='{{.SignozAPIUrl}}' \
-    {{.ParamSignozIngestionURL}}='{{.SignozIngestionURL}}' \
-    {{.ParamSignozIngestionKey}}='{{.SignozIngestionKey}}' \
-    {{.ParamAccountID}}='{{.AccountID}}' \
-    {{.ParamAgentVersion}}='{{.AgentVersion}}' \
-  --action-on-unmanage deleteAll \
-  --deny-settings-mode denyDelete`
-}
-
-func azurePowerShellTemplateStr() string {
-	return "New-AzSubscriptionDeploymentStack `\n" +
-		"  -Name \"{{.StackName}}\" `\n" +
-		"  -Location \"{{.Location}}\" `\n" +
-		"  -TemplateUri \"{{.TemplateURL}}\" `\n" +
-		"  -TemplateParameterObject @{\n" +
-		"    {{.ParamLocation}} = \"{{.Location}}\"\n" +
-		"    {{.ParamSignozAPIKey}} = \"{{.SignozAPIKey}}\"\n" +
-		"    {{.ParamSignozAPIUrl}} = \"{{.SignozAPIUrl}}\"\n" +
-		"    {{.ParamSignozIngestionURL}} = \"{{.SignozIngestionURL}}\"\n" +
-		"    {{.ParamSignozIngestionKey}} = \"{{.SignozIngestionKey}}\"\n" +
-		"    {{.ParamAccountID}} = \"{{.AccountID}}\"\n" +
-		"    {{.ParamAgentVersion}} = \"{{.AgentVersion}}\"\n" +
-		"    {{.ParamRgName}} = \"{{.DefaultRgName}}\"\n" +
-		"    {{.ParamContainerEnvName}} = \"{{.DefaultContainerEnvName}}\"\n" +
-		"    {{.ParamDeploymentEnv}} = \"{{.DefaultDeploymentEnv}}\"\n" +
-		"  } `\n" +
-		"  -ActionOnUnmanage \"deleteAll\" `\n" +
-		"  -DenySettingsMode \"denyDelete\""
-}

pkg/types/cloudintegrationtypes/cloudprovider_azure_test.go

@@ -1,142 +0,0 @@
-// file is generated by AI
-package cloudintegrationtypes
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var testTemplateData = azureTemplateData{
-	TemplateURL:             fmt.Sprintf(AgentArmTemplateStorePath, "v0.1.0"),
-	Location:                "eastus",
-	SignozAPIKey:            "test-api-key",
-	SignozAPIUrl:            "https://signoz.example.com",
-	SignozIngestionURL:      "https://ingest.example.com",
-	SignozIngestionKey:      "test-ingest-key",
-	AccountID:               "acct-123",
-	AgentVersion:            "v0.1.0",
-	StackName:               AgentDeploymentStackName,
-	ParamLocation:           armParamLocation,
-	ParamSignozAPIKey:       armParamSignozAPIKey,
-	ParamSignozAPIUrl:       armParamSignozAPIUrl,
-	ParamSignozIngestionURL: armParamSignozIngestionURL,
-	ParamSignozIngestionKey: armParamSignozIngestionKey,
-	ParamAccountID:          armParamAccountID,
-	ParamAgentVersion:       armParamAgentVersion,
-	ParamRgName:             armParamRgName,
-	ParamContainerEnvName:   armParamContainerEnvName,
-	ParamDeploymentEnv:      armParamDeploymentEnv,
-	DefaultRgName:           armDefaultRgName,
-	DefaultContainerEnvName: armDefaultContainerEnvName,
-	DefaultDeploymentEnv:    armDefaultDeploymentEnv,
-}
-
-func TestNewAzureConnectionCLICommand(t *testing.T) {
-	cmd, err := newAzureConnectionCLICommand(testTemplateData)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	mustContain := []string{
-		"az stack sub create",
-		fmt.Sprintf("--name %s", AgentDeploymentStackName),
-		fmt.Sprintf("--location %s", testTemplateData.Location),
-		fmt.Sprintf("--template-uri %s", testTemplateData.TemplateURL),
-		fmt.Sprintf("%s='%s'", armParamLocation, testTemplateData.Location),
-		fmt.Sprintf("%s='%s'", armParamSignozAPIKey, testTemplateData.SignozAPIKey),
-		fmt.Sprintf("%s='%s'", armParamSignozAPIUrl, testTemplateData.SignozAPIUrl),
-		fmt.Sprintf("%s='%s'", armParamSignozIngestionURL, testTemplateData.SignozIngestionURL),
-		fmt.Sprintf("%s='%s'", armParamSignozIngestionKey, testTemplateData.SignozIngestionKey),
-		fmt.Sprintf("%s='%s'", armParamAccountID, testTemplateData.AccountID),
-		fmt.Sprintf("%s='%s'", armParamAgentVersion, testTemplateData.AgentVersion),
-		"--action-on-unmanage deleteAll",
-		"--deny-settings-mode denyDelete",
-	}
-
-	for _, fragment := range mustContain {
-		if !strings.Contains(cmd, fragment) {
-			t.Errorf("CLI command missing %q\ngot:\n%s", fragment, cmd)
-		}
-	}
-
-	// Lines must be joined with the bash line-continuation separator.
-	if !strings.Contains(cmd, " \\\n") {
-		t.Errorf("CLI command missing line-continuation separator ' \\\\\\n'\ngot:\n%s", cmd)
-	}
-}
-
-func TestNewAzureConnectionPowerShellCommand(t *testing.T) {
-	cmd, err := newAzureConnectionPowerShellCommand(testTemplateData)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	mustContain := []string{
-		"New-AzSubscriptionDeploymentStack",
-		fmt.Sprintf("-Name \"%s\"", AgentDeploymentStackName),
-		fmt.Sprintf("-Location \"%s\"", testTemplateData.Location),
-		fmt.Sprintf("-TemplateUri \"%s\"", testTemplateData.TemplateURL),
-		armParamLocation,
-		armParamSignozAPIKey,
-		armParamSignozAPIUrl,
-		armParamSignozIngestionURL,
-		armParamSignozIngestionKey,
-		armParamAccountID,
-		armParamAgentVersion,
-		armParamRgName,
-		armParamContainerEnvName,
-		armParamDeploymentEnv,
-		armDefaultRgName,
-		armDefaultContainerEnvName,
-		armDefaultDeploymentEnv,
-		"-ActionOnUnmanage \"deleteAll\"",
-		"-DenySettingsMode \"denyDelete\"",
-	}
-
-	for _, fragment := range mustContain {
-		if !strings.Contains(cmd, fragment) {
-			t.Errorf("PowerShell command missing %q\ngot:\n%s", fragment, cmd)
-		}
-	}
-
-	// Final command must not end with a line-continuation backtick.
-	if strings.HasSuffix(strings.TrimSpace(cmd), "`") {
-		t.Errorf("PowerShell command must not end with a backtick\ngot:\n%s", cmd)
-	}
-}
-
-func TestNewAzureConnectionArtifact(t *testing.T) {
-	accountID := valuer.GenerateUUID()
-	agentVersion := "v0.1.0"
-	creds := &Credentials{
-		SigNozAPIURL: "https://signoz.example.com",
-		SigNozAPIKey: "test-api-key",
-		IngestionURL: "https://ingest.example.com",
-		IngestionKey: "test-ingest-key",
-	}
-	cfg := &AzurePostableAccountConfig{
-		DeploymentRegion: "eastus",
-		ResourceGroups:   []string{"rg1"},
-	}
-
-	artifact, err := NewAzureConnectionArtifact(accountID, agentVersion, creds, cfg)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if artifact.CLICommand == "" {
-		t.Error("CLICommand must not be empty")
-	}
-	if artifact.CloudPowerShellCommand == "" {
-		t.Error("CloudPowerShellCommand must not be empty")
-	}
-	if !strings.Contains(artifact.CLICommand, accountID.StringValue()) {
-		t.Errorf("CLICommand must contain accountID %q", accountID.StringValue())
-	}
-	if !strings.Contains(artifact.CloudPowerShellCommand, accountID.StringValue()) {
-		t.Errorf("CloudPowerShellCommand must contain accountID %q", accountID.StringValue())
-	}
-}

pkg/types/cloudintegrationtypes/service.go

@@ -239,10 +239,6 @@ func (service *CloudIntegrationService) Update(provider CloudProviderType, servi
 		}
 
 		// other validations happen in newStorableServiceConfig
-	case CloudProviderTypeAzure:
-		if config.Azure == nil {
-			return errors.NewInvalidInputf(ErrCodeCloudProviderInvalidInput, "Azure config is required for Azure service")
-		}
 	default:
 		return errors.NewInvalidInputf(ErrCodeCloudProviderInvalidInput, "invalid cloud provider: %s", provider.StringValue())
 	}

pkg/types/inframonitoringtypes/hosts.go

@@ -49,7 +49,7 @@ type HostFilter struct {
 	FilterByStatus HostStatus `json:"filterByStatus"`
 }
 
-// Validate ensures HostsListRequest contains acceptable values.
+// Validate ensures PostableHosts contains acceptable values.
 func (req *PostableHosts) Validate() error {
 	if req == nil {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")

pkg/types/inframonitoringtypes/nodes.go

@@ -0,0 +1,103 @@
+package inframonitoringtypes
+
+import (
+	"encoding/json"
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+)
+
+type Nodes struct {
+	Type                   ResponseType           `json:"type" required:"true"`
+	Records                []NodeRecord           `json:"records" required:"true"`
+	Total                  int                    `json:"total" required:"true"`
+	RequiredMetricsCheck   RequiredMetricsCheck   `json:"requiredMetricsCheck" required:"true"`
+	EndTimeBeforeRetention bool                   `json:"endTimeBeforeRetention" required:"true"`
+	Warning                *qbtypes.QueryWarnData `json:"warning,omitempty"`
+}
+
+type NodeRecord struct {
+	NodeName              string                 `json:"nodeName" required:"true"`
+	Condition             NodeCondition          `json:"condition" required:"true"`
+	ReadyNodesCount       int                    `json:"readyNodesCount" required:"true"`
+	NotReadyNodesCount    int                    `json:"notReadyNodesCount" required:"true"`
+	NodeCPU               float64                `json:"nodeCPU" required:"true"`
+	NodeCPUAllocatable    float64                `json:"nodeCPUAllocatable" required:"true"`
+	NodeMemory            float64                `json:"nodeMemory" required:"true"`
+	NodeMemoryAllocatable float64                `json:"nodeMemoryAllocatable" required:"true"`
+	Meta                  map[string]interface{} `json:"meta" required:"true"`
+}
+
+// PostableNodes is the request body for the v2 nodes list API.
+type PostableNodes struct {
+	Start   int64                `json:"start" required:"true"`
+	End     int64                `json:"end" required:"true"`
+	Filter  *qbtypes.Filter      `json:"filter"`
+	GroupBy []qbtypes.GroupByKey `json:"groupBy"`
+	OrderBy *qbtypes.OrderBy     `json:"orderBy"`
+	Offset  int                  `json:"offset"`
+	Limit   int                  `json:"limit" required:"true"`
+}
+
+// Validate ensures PostableNodes contains acceptable values.
+func (req *PostableNodes) Validate() error {
+	if req == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
+	}
+
+	if req.Start <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid start time %d: start must be greater than 0",
+			req.Start,
+		)
+	}
+
+	if req.End <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid end time %d: end must be greater than 0",
+			req.End,
+		)
+	}
+
+	if req.Start >= req.End {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid time range: start (%d) must be less than end (%d)",
+			req.Start,
+			req.End,
+		)
+	}
+
+	if req.Limit < 1 || req.Limit > 5000 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be between 1 and 5000")
+	}
+
+	if req.Offset < 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset cannot be negative")
+	}
+
+	if req.OrderBy != nil {
+		if !slices.Contains(NodesValidOrderByKeys, req.OrderBy.Key.Name) {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by key: %s", req.OrderBy.Key.Name)
+		}
+		if req.OrderBy.Direction != qbtypes.OrderDirectionAsc && req.OrderBy.Direction != qbtypes.OrderDirectionDesc {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by direction: %s", req.OrderBy.Direction)
+		}
+	}
+
+	return nil
+}
+
+// UnmarshalJSON validates input immediately after decoding.
+func (req *PostableNodes) UnmarshalJSON(data []byte) error {
+	type raw PostableNodes
+	var decoded raw
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return err
+	}
+	*req = PostableNodes(decoded)
+	return req.Validate()
+}

pkg/types/inframonitoringtypes/nodes_constants.go

@@ -0,0 +1,42 @@
+package inframonitoringtypes
+
+import "github.com/SigNoz/signoz/pkg/valuer"
+
+type NodeCondition struct {
+	valuer.String
+}
+
+var (
+	NodeConditionReady    = NodeCondition{valuer.NewString("ready")}
+	NodeConditionNotReady = NodeCondition{valuer.NewString("not_ready")}
+	NodeConditionNone     = NodeCondition{valuer.NewString("")}
+)
+
+func (NodeCondition) Enum() []any {
+	return []any{
+		NodeConditionReady,
+		NodeConditionNotReady,
+		NodeConditionNone,
+	}
+}
+
+// Numeric values emitted by the k8s.node.condition_ready metric
+// (source: OTel kubeletstats receiver).
+const (
+	NodeConditionNumReady    = 1
+	NodeConditionNumNotReady = 0
+)
+
+const (
+	NodesOrderByCPU               = "cpu"
+	NodesOrderByCPUAllocatable    = "cpu_allocatable"
+	NodesOrderByMemory            = "memory"
+	NodesOrderByMemoryAllocatable = "memory_allocatable"
+)
+
+var NodesValidOrderByKeys = []string{
+	NodesOrderByCPU,
+	NodesOrderByCPUAllocatable,
+	NodesOrderByMemory,
+	NodesOrderByMemoryAllocatable,
+}

pkg/types/inframonitoringtypes/nodes_test.go

@@ -0,0 +1,255 @@
+package inframonitoringtypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostableNodes_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *PostableNodes
+		wantErr bool
+	}{
+		{
+			name: "valid request",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name:    "nil request",
+			req:     nil,
+			wantErr: true,
+		},
+		{
+			name: "start time zero",
+			req: &PostableNodes{
+				Start:  0,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time negative",
+			req: &PostableNodes{
+				Start:  -1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "end time zero",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    0,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time greater than end time",
+			req: &PostableNodes{
+				Start:  2000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time equal to end time",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit zero",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  0,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit negative",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  -10,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit exceeds max",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  5001,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "offset negative",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: -5,
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy nil is valid",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with valid key cpu and direction asc",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: NodesOrderByCPU,
+						},
+					},
+					Direction: qbtypes.OrderDirectionAsc,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with valid key cpu_allocatable and direction desc",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: NodesOrderByCPUAllocatable,
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with valid key memory_allocatable and direction asc",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: NodesOrderByMemoryAllocatable,
+						},
+					},
+					Direction: qbtypes.OrderDirectionAsc,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with condition key is rejected",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "condition",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with invalid key",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "unknown",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with valid key but invalid direction",
+			req: &PostableNodes{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: NodesOrderByMemory,
+						},
+					},
+					Direction: qbtypes.OrderDirection{String: valuer.NewString("invalid")},
+				},
+			},
+			wantErr: true,
+		},
+	}
+
+	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)
+			}
+		})
+	}
+}

pkg/types/inframonitoringtypes/pods.go

@@ -0,0 +1,109 @@
+package inframonitoringtypes
+
+import (
+	"encoding/json"
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+)
+
+type Pods struct {
+	Type                   ResponseType           `json:"type" required:"true"`
+	Records                []PodRecord            `json:"records" required:"true"`
+	Total                  int                    `json:"total" required:"true"`
+	RequiredMetricsCheck   RequiredMetricsCheck   `json:"requiredMetricsCheck" required:"true"`
+	EndTimeBeforeRetention bool                   `json:"endTimeBeforeRetention" required:"true"`
+	Warning                *qbtypes.QueryWarnData `json:"warning,omitempty"`
+}
+
+type PodRecord struct {
+	PodUID            string                 `json:"podUID" required:"true"`
+	PodCPU            float64                `json:"podCPU" required:"true"`
+	PodCPURequest     float64                `json:"podCPURequest" required:"true"`
+	PodCPULimit       float64                `json:"podCPULimit" required:"true"`
+	PodMemory         float64                `json:"podMemory" required:"true"`
+	PodMemoryRequest  float64                `json:"podMemoryRequest" required:"true"`
+	PodMemoryLimit    float64                `json:"podMemoryLimit" required:"true"`
+	PodPhase          PodPhase               `json:"podPhase" required:"true"`
+	PendingPodCount   int                    `json:"pendingPodCount" required:"true"`
+	RunningPodCount   int                    `json:"runningPodCount" required:"true"`
+	SucceededPodCount int                    `json:"succeededPodCount" required:"true"`
+	FailedPodCount    int                    `json:"failedPodCount" required:"true"`
+	UnknownPodCount   int                    `json:"unknownPodCount" required:"true"`
+	PodAge            int64                  `json:"podAge" required:"true"`
+	Meta              map[string]interface{} `json:"meta" required:"true"`
+}
+
+// PostablePods is the request body for the v2 pods list API.
+type PostablePods struct {
+	Start   int64                `json:"start" required:"true"`
+	End     int64                `json:"end" required:"true"`
+	Filter  *qbtypes.Filter      `json:"filter"`
+	GroupBy []qbtypes.GroupByKey `json:"groupBy"`
+	OrderBy *qbtypes.OrderBy     `json:"orderBy"`
+	Offset  int                  `json:"offset"`
+	Limit   int                  `json:"limit" required:"true"`
+}
+
+// Validate ensures PostablePods contains acceptable values.
+func (req *PostablePods) Validate() error {
+	if req == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
+	}
+
+	if req.Start <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid start time %d: start must be greater than 0",
+			req.Start,
+		)
+	}
+
+	if req.End <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid end time %d: end must be greater than 0",
+			req.End,
+		)
+	}
+
+	if req.Start >= req.End {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid time range: start (%d) must be less than end (%d)",
+			req.Start,
+			req.End,
+		)
+	}
+
+	if req.Limit < 1 || req.Limit > 5000 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be between 1 and 5000")
+	}
+
+	if req.Offset < 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset cannot be negative")
+	}
+
+	if req.OrderBy != nil {
+		if !slices.Contains(PodsValidOrderByKeys, req.OrderBy.Key.Name) {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by key: %s", req.OrderBy.Key.Name)
+		}
+		if req.OrderBy.Direction != qbtypes.OrderDirectionAsc && req.OrderBy.Direction != qbtypes.OrderDirectionDesc {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by direction: %s", req.OrderBy.Direction)
+		}
+	}
+
+	return nil
+}
+
+// UnmarshalJSON validates input immediately after decoding.
+func (req *PostablePods) UnmarshalJSON(data []byte) error {
+	type raw PostablePods
+	var decoded raw
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return err
+	}
+	*req = PostablePods(decoded)
+	return req.Validate()
+}

pkg/types/inframonitoringtypes/pods_constants.go

@@ -0,0 +1,55 @@
+package inframonitoringtypes
+
+import "github.com/SigNoz/signoz/pkg/valuer"
+
+type PodPhase struct {
+	valuer.String
+}
+
+var (
+	PodPhasePending   = PodPhase{valuer.NewString("pending")}
+	PodPhaseRunning   = PodPhase{valuer.NewString("running")}
+	PodPhaseSucceeded = PodPhase{valuer.NewString("succeeded")}
+	PodPhaseFailed    = PodPhase{valuer.NewString("failed")}
+	PodPhaseUnknown   = PodPhase{valuer.NewString("unknown")}
+	PodPhaseNone      = PodPhase{valuer.NewString("")}
+)
+
+func (PodPhase) Enum() []any {
+	return []any{
+		PodPhasePending,
+		PodPhaseRunning,
+		PodPhaseSucceeded,
+		PodPhaseFailed,
+		PodPhaseUnknown,
+		PodPhaseNone,
+	}
+}
+
+// Numeric pod phase values emitted by the k8s.pod.phase metric
+// (source: OTel kubeletstats receiver).
+const (
+	PodPhaseNumPending   = 1
+	PodPhaseNumRunning   = 2
+	PodPhaseNumSucceeded = 3
+	PodPhaseNumFailed    = 4
+	PodPhaseNumUnknown   = 5
+)
+
+const (
+	PodsOrderByCPU           = "cpu"
+	PodsOrderByCPURequest    = "cpu_request"
+	PodsOrderByCPULimit      = "cpu_limit"
+	PodsOrderByMemory        = "memory"
+	PodsOrderByMemoryRequest = "memory_request"
+	PodsOrderByMemoryLimit   = "memory_limit"
+)
+
+var PodsValidOrderByKeys = []string{
+	PodsOrderByCPU,
+	PodsOrderByCPURequest,
+	PodsOrderByCPULimit,
+	PodsOrderByMemory,
+	PodsOrderByMemoryRequest,
+	PodsOrderByMemoryLimit,
+}

pkg/types/inframonitoringtypes/pods_test.go

@@ -0,0 +1,219 @@
+package inframonitoringtypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostablePods_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *PostablePods
+		wantErr bool
+	}{
+		{
+			name: "valid request",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name:    "nil request",
+			req:     nil,
+			wantErr: true,
+		},
+		{
+			name: "start time zero",
+			req: &PostablePods{
+				Start:  0,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time negative",
+			req: &PostablePods{
+				Start:  -1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "end time zero",
+			req: &PostablePods{
+				Start:  1000,
+				End:    0,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time greater than end time",
+			req: &PostablePods{
+				Start:  2000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time equal to end time",
+			req: &PostablePods{
+				Start:  1000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit zero",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  0,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit negative",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  -10,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit exceeds max",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  5001,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "offset negative",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: -5,
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy nil is valid",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with valid key cpu and direction asc",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: PodsOrderByCPU,
+						},
+					},
+					Direction: qbtypes.OrderDirectionAsc,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with phase key is rejected",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "phase",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with invalid key",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "unknown",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with valid key but invalid direction",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: PodsOrderByMemory,
+						},
+					},
+					Direction: qbtypes.OrderDirection{String: valuer.NewString("invalid")},
+				},
+			},
+			wantErr: true,
+		},
+	}
+
+	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)
+			}
+		})
+	}
+}

pkg/types/promotetypes/types.go

@@ -10,10 +10,10 @@ import (
 )
 
 type WrappedIndex struct {
-	JSONDataType  telemetrytypes.JSONDataType  `json:"-"`
-	FieldDataType telemetrytypes.FieldDataType `json:"fieldDataType"`
-	Type          string                       `json:"type"`
-	Granularity   int                          `json:"granularity"`
+	JSONDataType telemetrytypes.JSONDataType `json:"-"`
+	ColumnType   string                      `json:"column_type"`
+	Type         string                      `json:"type"`
+	Granularity  int                         `json:"granularity"`
 }
 
 type PromotePath struct {
@@ -60,12 +60,12 @@ func (i *PromotePath) ValidateAndSetDefaults() error {
 			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index granularity must be greater than 0")
 		}
 
-		jsonDataType, ok := telemetrytypes.MappingFieldDataTypeToJSONDataType[index.FieldDataType]
+		jsonDataType, ok := telemetrytypes.MappingStringToJSONDataType[index.ColumnType]
 		if !ok {
-			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid column type: %s", index.FieldDataType)
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid column type: %s", index.ColumnType)
 		}
 		if !jsonDataType.IndexSupported {
-			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index is not supported for column type: %s", index.FieldDataType)
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index is not supported for column type: %s", index.ColumnType)
 		}
 
 		i.Indexes[idx].JSONDataType = jsonDataType

pkg/types/spantypes/mapper.go

@@ -1,137 +0,0 @@
-package spantypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMapperNotFound      = errors.MustNewCode("span_attribute_mapper_not_found")
-	ErrCodeMapperAlreadyExists = errors.MustNewCode("span_attribute_mapper_already_exists")
-	ErrCodeMappingInvalidInput = errors.MustNewCode("span_attribute_mapping_invalid_input")
-)
-
-// FieldContext is where the target attribute is written.
-type FieldContext struct {
-	valuer.String
-}
-
-var (
-	FieldContextSpanAttribute = FieldContext{valuer.NewString("attribute")}
-	FieldContextResource      = FieldContext{valuer.NewString("resource")}
-)
-
-// MapperOperation determines whether the source attribute is moved (deleted) or copied.
-type SpanMapperOperation struct {
-	valuer.String
-}
-
-var (
-	SpanMapperOperationMove = SpanMapperOperation{valuer.NewString("move")}
-	SpanMapperOperationCopy = SpanMapperOperation{valuer.NewString("copy")}
-)
-
-// MapperSource describes one candidate source for a target attribute.
-type SpanMapperSource struct {
-	Key       string              `json:"key" required:"true"`
-	Context   FieldContext        `json:"context" required:"true"`
-	Operation SpanMapperOperation `json:"operation" required:"true"`
-	Priority  int                 `json:"priority" required:"true"`
-}
-
-// MapperConfig holds the mapping logic for a single target attribute.
-// It implements driver.Valuer and sql.Scanner for JSON text column storage.
-type SpanMapperConfig struct {
-	Sources []SpanMapperSource `json:"sources" required:"true" nullable:"true"`
-}
-
-// SpanMapper is the domain model for a span attribute mapper.
-type SpanMapper struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID           valuer.UUID      `json:"id"            required:"true"`
-	GroupID      valuer.UUID      `json:"group_id"      required:"true"`
-	Name         string           `json:"name"          required:"true"`
-	FieldContext FieldContext     `json:"field_context" required:"true"`
-	Config       SpanMapperConfig `json:"config"        required:"true"`
-	Enabled      bool             `json:"enabled"       required:"true"`
-}
-
-type PostableSpanMapper struct {
-	Name         string           `json:"name"          required:"true"`
-	FieldContext FieldContext     `json:"field_context" required:"true"`
-	Config       SpanMapperConfig `json:"config"        required:"true"`
-	Enabled      bool             `json:"enabled"`
-}
-
-// UpdatableSpanMapper is the HTTP request body for updating a span mapper.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableSpanMapper struct {
-	FieldContext FieldContext      `json:"field_context,omitempty"`
-	Config       *SpanMapperConfig `json:"config,omitempty"`
-	Enabled      *bool             `json:"enabled,omitempty"`
-}
-
-type GettableSpanMapper = SpanMapper
-
-type GettableSpanMappers struct {
-	Items []*GettableSpanMapper `json:"items" required:"true" nullable:"false"`
-}
-
-func (FieldContext) Enum() []any {
-	return []any{FieldContextSpanAttribute, FieldContextResource}
-}
-
-func (SpanMapperOperation) Enum() []any {
-	return []any{SpanMapperOperationMove, SpanMapperOperationCopy}
-}
-
-func NewSpanMapperFromStorable(s *StorableSpanMapper) *SpanMapper {
-	return &SpanMapper{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		GroupID:       s.GroupID,
-		Name:          s.Name,
-		FieldContext:  s.FieldContext,
-		Config:        s.Config,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewSpanMapperFromPostable(req *PostableSpanMapper) *SpanMapper {
-	return &SpanMapper{
-		Name:         req.Name,
-		FieldContext: req.FieldContext,
-		Config:       req.Config,
-		Enabled:      req.Enabled,
-	}
-}
-
-func NewSpanMapperFromUpdatable(req *UpdatableSpanMapper) *SpanMapper {
-	m := &SpanMapper{}
-	if req.FieldContext != (FieldContext{}) {
-		m.FieldContext = req.FieldContext
-	}
-	if req.Config != nil {
-		m.Config = *req.Config
-	}
-	if req.Enabled != nil {
-		m.Enabled = *req.Enabled
-	}
-	return m
-}
-
-func NewSpanMappersFromStorableSpanMappers(ss []*StorableSpanMapper) []*SpanMapper {
-	mappers := make([]*SpanMapper, len(ss))
-	for i, s := range ss {
-		mappers[i] = NewSpanMapperFromStorable(s)
-	}
-	return mappers
-}
-
-func NewGettableSpanMappers(m []*SpanMapper) *GettableSpanMappers {
-	return &GettableSpanMappers{Items: m}
-}

pkg/types/spantypes/mappergroup.go

@@ -1,109 +0,0 @@
-package spantypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMappingGroupNotFound      = errors.MustNewCode("span_attribute_mapping_group_not_found")
-	ErrCodeMappingGroupAlreadyExists = errors.MustNewCode("span_attribute_mapping_group_already_exists")
-)
-
-// SpanMapperGroupCategory defaults will be llm, tool, agent but user can configure more as they want.
-type SpanMapperGroupCategory valuer.String
-
-// A group runs when any of the listed attribute/resource key patterns match.
-type SpanMapperGroupCondition struct {
-	Attributes []string `json:"attributes" required:"true" nullable:"true"`
-	Resource   []string `json:"resource" required:"true" nullable:"true"`
-}
-
-// SpanMapperGroup is the domain model for a span attribute mapping group.
-type SpanMapperGroup struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID        valuer.UUID              `json:"id" required:"true"`
-	OrgID     valuer.UUID              `json:"orgId" required:"true"`
-	Name      string                   `json:"name" required:"true"`
-	Category  SpanMapperGroupCategory  `json:"category" required:"true"`
-	Condition SpanMapperGroupCondition `json:"condition" required:"true"`
-	Enabled   bool                     `json:"enabled" required:"true"`
-}
-
-// GettableSpanMapperGroup is the HTTP response representation of a mapping group.
-type GettableSpanMapperGroup = SpanMapperGroup
-
-type PostableSpanMapperGroup struct {
-	Name      string                   `json:"name"      required:"true"`
-	Category  SpanMapperGroupCategory  `json:"category"  required:"true"`
-	Condition SpanMapperGroupCondition `json:"condition" required:"true"`
-	Enabled   bool                     `json:"enabled"`
-}
-
-// UpdatableSpanMapperGroup is the HTTP request body for updating a mapping group.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableSpanMapperGroup struct {
-	Name      *string                   `json:"name,omitempty"`
-	Condition *SpanMapperGroupCondition `json:"condition,omitempty"`
-	Enabled   *bool                     `json:"enabled,omitempty"`
-}
-
-type ListSpanMapperGroupsQuery struct {
-	Category *SpanMapperGroupCategory `query:"category"`
-	Enabled  *bool                    `query:"enabled"`
-}
-
-type GettableSpanMapperGroups struct {
-	Items []*GettableSpanMapperGroup `json:"items" required:"true" nullable:"false"`
-}
-
-func NewSpanMapperGroupFromStorable(s *StorableSpanMapperGroup) *SpanMapperGroup {
-	return &SpanMapperGroup{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		OrgID:         s.OrgID,
-		Name:          s.Name,
-		Category:      s.Category,
-		Condition:     s.Condition,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewSpanMapperGroupFromPostable(p *PostableSpanMapperGroup) *SpanMapperGroup {
-	return &SpanMapperGroup{
-		Name:      p.Name,
-		Category:  p.Category,
-		Condition: p.Condition,
-		Enabled:   p.Enabled,
-	}
-}
-
-func NewSpanMapperGroupFromUpdatable(u *UpdatableSpanMapperGroup) *SpanMapperGroup {
-	g := &SpanMapperGroup{}
-	if u.Name != nil {
-		g.Name = *u.Name
-	}
-	if u.Condition != nil {
-		g.Condition = *u.Condition
-	}
-	if u.Enabled != nil {
-		g.Enabled = *u.Enabled
-	}
-	return g
-}
-
-func NewSpanMapperGroupsFromStorableGroups(ss []*StorableSpanMapperGroup) []*SpanMapperGroup {
-	groups := make([]*SpanMapperGroup, len(ss))
-	for i, s := range ss {
-		groups[i] = NewSpanMapperGroupFromStorable(s)
-	}
-	return groups
-}
-
-func NewGettableSpanMapperGroups(g []*SpanMapperGroup) *GettableSpanMapperGroups {
-	return &GettableSpanMapperGroups{Items: g}
-}

pkg/types/spantypes/storable.go

@@ -1,87 +0,0 @@
-package spantypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-type StorableSpanMapperGroup struct {
-	bun.BaseModel `bun:"table:span_mapper_group,alias:span_attribute_mapping_group"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID     valuer.UUID              `bun:"org_id,type:text,notnull"`
-	Name      string                   `bun:"name,type:text,notnull"`
-	Category  SpanMapperGroupCategory  `bun:"category,type:text,notnull"`
-	Condition SpanMapperGroupCondition `bun:"condition,type:jsonb,notnull"`
-	Enabled   bool                     `bun:"enabled,notnull,default:true"`
-}
-
-type StorableSpanMapper struct {
-	bun.BaseModel `bun:"table:span_mapper,alias:span_attribute_mapping"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	GroupID      valuer.UUID      `bun:"group_id,type:text,notnull"`
-	Name         string           `bun:"name,type:text,notnull"`
-	FieldContext FieldContext     `bun:"field_context,type:text,notnull"`
-	Config       SpanMapperConfig `bun:"config,type:jsonb,notnull"`
-	Enabled      bool             `bun:"enabled,notnull,default:true"`
-}
-
-func (c SpanMapperGroupCondition) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (c *SpanMapperGroupCondition) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*c = SpanMapperGroupCondition{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanmapper: cannot scan %T into Condition", src)
-	}
-	return json.Unmarshal(raw, c)
-}
-
-func (m SpanMapperConfig) Value() (driver.Value, error) {
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (m *SpanMapperConfig) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*m = SpanMapperConfig{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanmapper: cannot scan %T into MapperConfig", src)
-	}
-	return json.Unmarshal(raw, m)
-}

pkg/types/spantypes/store.go

@@ -1,23 +0,0 @@
-package spantypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	// Group operations
-	ListSpanMapperGroups(ctx context.Context, orgID valuer.UUID, q *ListSpanMapperGroupsQuery) ([]*StorableSpanMapperGroup, error)
-	GetSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) (*StorableSpanMapperGroup, error)
-	CreateSpanMapperGroup(ctx context.Context, group *StorableSpanMapperGroup) error
-	UpdateSpanMapperGroup(ctx context.Context, group *StorableSpanMapperGroup) error
-	DeleteSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) error
-
-	// Mapper operations
-	ListSpanMappers(ctx context.Context, orgID, groupID valuer.UUID) ([]*StorableSpanMapper, error)
-	GetSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) (*StorableSpanMapper, error)
-	CreateSpanMapper(ctx context.Context, mapper *StorableSpanMapper) error
-	UpdateSpanMapper(ctx context.Context, mapper *StorableSpanMapper) error
-	DeleteSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) error
-}

pkg/types/telemetrytypes/field.go

@@ -37,9 +37,9 @@ type TelemetryFieldKey struct {
 	FieldContext  FieldContext  `json:"fieldContext,omitzero"`
 	FieldDataType FieldDataType `json:"fieldDataType,omitzero"`
 
-	JSONPlan     JSONAccessPlan               `json:"-"`
-	Indexes      []TelemetryFieldKeySkipIndex `json:"-"`
-	Materialized bool                         `json:"-"` // refers to promoted in case of body.... fields
+	JSONPlan     JSONAccessPlan      `json:"-"`
+	Indexes      []JSONDataTypeIndex `json:"-"`
+	Materialized bool                `json:"-"` // refers to promoted in case of body.... fields
 
 	Evolutions []*EvolutionEntry `json:"-"`
 }
@@ -102,7 +102,7 @@ func (f TelemetryFieldKey) String() string {
 			if i > 0 {
 				sb.WriteString("; ")
 			}
-			fmt.Fprintf(&sb, "{type=%s, indexExpr=%s}", MappingFieldDataTypeToJSONDataType[index.FieldDataType].StringValue(), index.IndexExpression)
+			fmt.Fprintf(&sb, "{type=%s, columnExpr=%s, indexExpr=%s}", index.Type.StringValue(), index.ColumnExpression, index.IndexExpression)
 		}
 		sb.WriteString("]")
 	}
@@ -400,14 +400,3 @@ func NewFieldValueSelectorFromPostableFieldValueParams(params PostableFieldValue
 
 	return fieldValueSelector
 }
-
-type TelemetryFieldKeySkipIndex struct {
-	Name            string        `json:"name"` // Name is TelemetryFieldKey.Name not IndexName from ClickHouse
-	FieldContext    FieldContext  `json:"fieldContext,omitzero"`
-	FieldDataType   FieldDataType `json:"fieldDataType,omitzero"`
-	BaseColumn      string        `json:"baseColumn"`
-	IndexName       string        `json:"indexName"`
-	IndexType       string        `json:"indexType"`
-	IndexExpression string        `json:"indexExpression"`
-	Granularity     int           `json:"granularity"`
-}

pkg/types/telemetrytypes/json_datatype.go

@@ -1,5 +1,11 @@
 package telemetrytypes
 
+type JSONDataTypeIndex struct {
+	Type             JSONDataType
+	ColumnExpression string
+	IndexExpression  string
+}
+
 type JSONDataType struct {
 	str            string // Store the correct case for ClickHouse
 	IsArray        bool
@@ -26,17 +32,18 @@ var (
 	ArrayJSON    = JSONDataType{"Array(JSON)", true, "JSON", false}
 )
 
-var MappingJSONDataTypeToFieldDataType = map[string]FieldDataType{
-	"String":                   FieldDataTypeString,
-	"Int64":                    FieldDataTypeInt64,
-	"Float64":                  FieldDataTypeFloat64,
-	"Bool":                     FieldDataTypeBool,
-	"Array(Nullable(String))":  FieldDataTypeArrayString,
-	"Array(Nullable(Int64))":   FieldDataTypeArrayInt64,
-	"Array(Nullable(Float64))": FieldDataTypeArrayFloat64,
-	"Array(Nullable(Bool))":    FieldDataTypeArrayBool,
-	"Array(Dynamic)":           FieldDataTypeArrayDynamic,
-	"Array(JSON)":              FieldDataTypeArrayJSON,
+var MappingStringToJSONDataType = map[string]JSONDataType{
+	"String":                   String,
+	"Int64":                    Int64,
+	"Float64":                  Float64,
+	"Bool":                     Bool,
+	"Dynamic":                  Dynamic,
+	"Array(Nullable(String))":  ArrayString,
+	"Array(Nullable(Int64))":   ArrayInt64,
+	"Array(Nullable(Float64))": ArrayFloat64,
+	"Array(Nullable(Bool))":    ArrayBool,
+	"Array(Dynamic)":           ArrayDynamic,
+	"Array(JSON)":              ArrayJSON,
 }
 
 var MappingFieldDataTypeToJSONDataType = map[FieldDataType]JSONDataType{

pkg/types/telemetrytypes/store.go

@@ -3,6 +3,7 @@ package telemetrytypes
 import (
 	"context"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 )
 
@@ -34,7 +35,7 @@ type MetadataStore interface {
 	FetchTemporalityAndTypeMulti(ctx context.Context, queryTimeRangeStartTs, queryTimeRangeEndTs uint64, metricNames ...string) (map[string]metrictypes.Temporality, map[string]metrictypes.Type, error)
 
 	// ListLogsJSONIndexes lists the JSON indexes for the logs table.
-	ListLogsJSONIndexes(ctx context.Context, filters ...string) ([]TelemetryFieldKeySkipIndex, error)
+	ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error)
 
 	// ListPromotedPaths lists the promoted paths.
 	GetPromotedPaths(ctx context.Context, paths ...string) (map[string]bool, error)

pkg/types/telemetrytypes/telemetrytypestest/metadata_store.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
@@ -17,7 +18,7 @@ type MockMetadataStore struct {
 	TemporalityMap             map[string]metrictypes.Temporality
 	TypeMap                    map[string]metrictypes.Type
 	PromotedPathsMap           map[string]bool
-	LogsJSONIndexes            []telemetrytypes.TelemetryFieldKeySkipIndex
+	LogsJSONIndexesMap         map[string][]schemamigrator.Index
 	ColumnEvolutionMetadataMap map[string][]*telemetrytypes.EvolutionEntry
 	LookupKeysMap              map[telemetrytypes.MetricMetadataLookupKey]int64
 	// StaticFields holds signal-specific intrinsic field definitions (e.g. telemetrylogs.IntrinsicFields).
@@ -33,7 +34,7 @@ func NewMockMetadataStore() *MockMetadataStore {
 		TemporalityMap:             make(map[string]metrictypes.Temporality),
 		TypeMap:                    make(map[string]metrictypes.Type),
 		PromotedPathsMap:           make(map[string]bool),
-		LogsJSONIndexes:            []telemetrytypes.TelemetryFieldKeySkipIndex{},
+		LogsJSONIndexesMap:         make(map[string][]schemamigrator.Index),
 		ColumnEvolutionMetadataMap: make(map[string][]*telemetrytypes.EvolutionEntry),
 		LookupKeysMap:              make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 		StaticFields:               make(map[string]telemetrytypes.TelemetryFieldKey),
@@ -368,8 +369,8 @@ func (m *MockMetadataStore) GetPromotedPaths(ctx context.Context, paths ...strin
 }
 
 // ListLogsJSONIndexes lists the JSON indexes for the logs table.
-func (m *MockMetadataStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) ([]telemetrytypes.TelemetryFieldKeySkipIndex, error) {
-	return m.LogsJSONIndexes, nil
+func (m *MockMetadataStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
+	return m.LogsJSONIndexesMap, nil
 }
 
 func (m *MockMetadataStore) updateColumnEvolutionMetadataForKeys(_ context.Context, keysToUpdate []*telemetrytypes.TelemetryFieldKey) map[string][]*telemetrytypes.EvolutionEntry {