Merge branch 'main' into field-map-condition-builder

ee/licensing/httplicensing/provider.go

@@ -3,6 +3,7 @@ package httplicensing
 import (
 	"context"
 	"encoding/json"
+	"github.com/SigNoz/signoz/ee/query-service/constants"
 	"time"
 
 	"github.com/SigNoz/signoz/ee/licensing/licensingstore/sqllicensingstore"
@@ -251,6 +252,13 @@ func (provider *provider) GetFeatureFlags(ctx context.Context) ([]*featuretypes.
 		}
 	}
 
+	if constants.IsDotMetricsEnabled {
+		gettableFeatures = append(gettableFeatures, &featuretypes.GettableFeature{
+			Name:   featuretypes.DotMetricsEnabled,
+			Active: true,
+		})
+	}
+
 	return gettableFeatures, nil
 }
 

ee/query-service/constants/constants.go

@@ -4,6 +4,10 @@ import (
 	"os"
 )
 
+const (
+	DefaultSiteURL = "https://localhost:8080"
+)
+
 var LicenseSignozIo = "https://license.signoz.io/api/v1"
 var LicenseAPIKey = GetOrDefaultEnv("SIGNOZ_LICENSE_API_KEY", "")
 var SaasSegmentKey = GetOrDefaultEnv("SIGNOZ_SAAS_SEGMENT_KEY", "")
@@ -20,3 +24,22 @@ func GetOrDefaultEnv(key string, fallback string) string {
 	}
 	return v
 }
+
+// constant functions that override env vars
+
+// GetDefaultSiteURL returns default site url, primarily
+// used to send saml request and allowing backend to
+// handle http redirect
+func GetDefaultSiteURL() string {
+	return GetOrDefaultEnv("SIGNOZ_SITE_URL", DefaultSiteURL)
+}
+
+const DotMetricsEnabled = "DOT_METRICS_ENABLED"
+
+var IsDotMetricsEnabled = false
+
+func init() {
+	if GetOrDefaultEnv(DotMetricsEnabled, "false") == "true" {
+		IsDotMetricsEnabled = true
+	}
+}

frontend/src/api/infraMonitoring/getK8sClustersList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sClustersListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -40,23 +42,80 @@ export interface K8sClustersListResponse {
 	};
 }
 
+export const clustersMetaMap = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.cluster.uid', under: 'k8s_cluster_uid' },
+] as const;
+
+export function mapClustersMeta(
+	raw: Record<string, unknown>,
+): K8sClustersData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	clustersMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sClustersData['meta'];
+}
+
 export const getK8sClustersList = async (
 	props: K8sClustersListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sClustersListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/clusters/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/clusters/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sClustersListResponse = response.data;
+
+		// one-liner meta mapping
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapClustersMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sDaemonSetsList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sDaemonSetsListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -46,23 +48,82 @@ export interface K8sDaemonSetsListResponse {
 	};
 }
 
+export const daemonSetsMetaMap = [
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+	{ dot: 'k8s.daemonset.name', under: 'k8s_daemonset_name' },
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+] as const;
+
+export function mapDaemonSetsMeta(
+	raw: Record<string, unknown>,
+): K8sDaemonSetsData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	daemonSetsMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sDaemonSetsData['meta'];
+}
+
 export const getK8sDaemonSetsList = async (
 	props: K8sDaemonSetsListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sDaemonSetsListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/daemonsets/list', props, {
+		// filter prep (unchanged)…
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/daemonsets/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sDaemonSetsListResponse = response.data;
+
+		// single-line meta mapping
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapDaemonSetsMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sDeploymentsList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sDeploymentsListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -46,23 +48,81 @@ export interface K8sDeploymentsListResponse {
 	};
 }
 
+export const deploymentsMetaMap = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.deployment.name', under: 'k8s_deployment_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+] as const;
+
+export function mapDeploymentsMeta(
+	raw: Record<string, unknown>,
+): K8sDeploymentsData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	deploymentsMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sDeploymentsData['meta'];
+}
+
 export const getK8sDeploymentsList = async (
 	props: K8sDeploymentsListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sDeploymentsListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/deployments/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/deployments/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sDeploymentsListResponse = response.data;
+
+		// single-line mapping
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapDeploymentsMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sJobsList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sJobsListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -48,23 +50,79 @@ export interface K8sJobsListResponse {
 	};
 }
 
+export const jobsMetaMap = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.job.name', under: 'k8s_job_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+] as const;
+
+export function mapJobsMeta(raw: Record<string, unknown>): K8sJobsData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	jobsMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sJobsData['meta'];
+}
+
 export const getK8sJobsList = async (
 	props: K8sJobsListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sJobsListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/jobs/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/jobs/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sJobsListResponse = response.data;
+
+		// one-liner meta mapping
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapJobsMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sNamespacesList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sNamespacesListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -38,23 +40,79 @@ export interface K8sNamespacesListResponse {
 	};
 }
 
+export const namespacesMetaMap = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+] as const;
+
+export function mapNamespacesMeta(
+	raw: Record<string, unknown>,
+): K8sNamespacesData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	namespacesMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sNamespacesData['meta'];
+}
+
 export const getK8sNamespacesList = async (
 	props: K8sNamespacesListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sNamespacesListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/namespaces/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/namespaces/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sNamespacesListResponse = response.data;
+
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapNamespacesMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sNodesList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sNodesListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -41,23 +43,81 @@ export interface K8sNodesListResponse {
 	};
 }
 
+export const nodesMetaMap = [
+	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
+	{ dot: 'k8s.node.uid', under: 'k8s_node_uid' },
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+] as const;
+
+export function mapNodesMeta(
+	raw: Record<string, unknown>,
+): K8sNodesData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	nodesMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sNodesData['meta'];
+}
+
 export const getK8sNodesList = async (
 	props: K8sNodesListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/nodes/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/nodes/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sNodesListResponse = response.data;
+
+		// one-liner to map dot→underscore
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapNodesMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sPodsList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sPodsListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -69,23 +71,87 @@ export interface K8sPodsListResponse {
 	};
 }
 
+export const podsMetaMap = [
+	{ dot: 'k8s.cronjob.name', under: 'k8s_cronjob_name' },
+	{ dot: 'k8s.daemonset.name', under: 'k8s_daemonset_name' },
+	{ dot: 'k8s.deployment.name', under: 'k8s_deployment_name' },
+	{ dot: 'k8s.job.name', under: 'k8s_job_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
+	{ dot: 'k8s.pod.name', under: 'k8s_pod_name' },
+	{ dot: 'k8s.pod.uid', under: 'k8s_pod_uid' },
+	{ dot: 'k8s.statefulset.name', under: 'k8s_statefulset_name' },
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+] as const;
+
+export function mapPodsMeta(raw: Record<string, unknown>): K8sPodsData['meta'] {
+	// clone everything
+	const out: Record<string, unknown> = { ...raw };
+	// overlay only the dot→under mappings
+	podsMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sPodsData['meta'];
+}
+
+// getK8sPodsList
 export const getK8sPodsList = async (
 	props: K8sPodsListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sPodsListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/pods/list', props, {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/pods/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sPodsListResponse = response.data;
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapPodsMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getK8sVolumesList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sVolumesListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -47,23 +49,92 @@ export interface K8sVolumesListResponse {
 	};
 }
 
+export const volumesMetaMap: Array<{
+	dot: keyof Record<string, unknown>;
+	under: keyof K8sVolumesData['meta'];
+}> = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
+	{
+		dot: 'k8s.persistentvolumeclaim.name',
+		under: 'k8s_persistentvolumeclaim_name',
+	},
+	{ dot: 'k8s.pod.name', under: 'k8s_pod_name' },
+	{ dot: 'k8s.pod.uid', under: 'k8s_pod_uid' },
+	{ dot: 'k8s.statefulset.name', under: 'k8s_statefulset_name' },
+];
+
+export function mapVolumesMeta(
+	rawMeta: Record<string, unknown>,
+): K8sVolumesData['meta'] {
+	// start with everything that was already there
+	const out: Record<string, unknown> = { ...rawMeta };
+
+	// for each dot→under rule, if the raw has the dot, overwrite the underscore
+	volumesMetaMap.forEach(({ dot, under }) => {
+		if (dot in rawMeta) {
+			const val = rawMeta[dot];
+			out[under] = typeof val === 'string' ? val : rawMeta[under];
+		}
+	});
+
+	return out as K8sVolumesData['meta'];
+}
+
 export const getK8sVolumesList = async (
 	props: K8sVolumesListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sVolumesListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/pvcs/list', props, {
+		// Prepare filters
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({ ...item, key: { ...item.key, key: mappedKey } });
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/pvcs/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sVolumesListResponse = response.data;
+
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapVolumesMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/infraMonitoring/getsK8sStatefulSetsList.ts

@@ -5,6 +5,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
+import { UnderscoreToDotMap } from '../utils';
+
 export interface K8sStatefulSetsListPayload {
 	filters: TagFilter;
 	groupBy?: BaseAutocompleteData[];
@@ -45,23 +47,78 @@ export interface K8sStatefulSetsListResponse {
 	};
 }
 
+export const statefulSetsMetaMap = [
+	{ dot: 'k8s.statefulset.name', under: 'k8s_statefulset_name' },
+	{ dot: 'k8s.namespace.name', under: 'k8s_namespace_name' },
+] as const;
+
+export function mapStatefulSetsMeta(
+	raw: Record<string, unknown>,
+): K8sStatefulSetsData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	statefulSetsMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sStatefulSetsData['meta'];
+}
+
 export const getK8sStatefulSetsList = async (
 	props: K8sStatefulSetsListPayload,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sStatefulSetsListResponse> | ErrorResponse> => {
 	try {
-		const response = await axios.post('/statefulsets/list', props, {
+		// Prepare filters
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) return acc;
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({ ...item, key: { ...item.key, key: mappedKey } });
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/statefulsets/list', requestProps, {
 			signal,
 			headers,
 		});
+		const payload: K8sStatefulSetsListResponse = response.data;
+
+		// apply our helper
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapStatefulSetsMeta(record.meta as Record<string, unknown>),
+		}));
 
 		return {
 			statusCode: 200,
 			error: null,
 			message: 'Success',
-			payload: response.data,
-			params: props,
+			payload,
+			params: requestProps,
 		};
 	} catch (error) {
 		return ErrorResponseHandler(error as AxiosError);

frontend/src/api/utils.ts

@@ -17,3 +17,19 @@ export const Logout = (): void => {
 
 	history.push(ROUTES.LOGIN);
 };
+
+export const UnderscoreToDotMap: Record<string, string> = {
+	k8s_cluster_name: 'k8s.cluster.name',
+	k8s_cluster_uid: 'k8s.cluster.uid',
+	k8s_namespace_name: 'k8s.namespace.name',
+	k8s_node_name: 'k8s.node.name',
+	k8s_node_uid: 'k8s.node.uid',
+	k8s_pod_name: 'k8s.pod.name',
+	k8s_pod_uid: 'k8s.pod.uid',
+	k8s_deployment_name: 'k8s.deployment.name',
+	k8s_daemonset_name: 'k8s.daemonset.name',
+	k8s_statefulset_name: 'k8s.statefulset.name',
+	k8s_cronjob_name: 'k8s.cronjob.name',
+	k8s_job_name: 'k8s.job.name',
+	k8s_persistentvolumeclaim_name: 'k8s.persistentvolumeclaim.name',
+};

frontend/src/components/HostMetricsDetail/Metrics/Metrics.tsx

@@ -23,6 +23,9 @@ import { useQueries, UseQueryResult } from 'react-query';
 import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+
 interface MetricsTabProps {
 	timeRange: {
 		startTime: number;
@@ -45,9 +48,20 @@ function Metrics({
 	handleTimeChange,
 	isModalTimeSelection,
 }: MetricsTabProps): JSX.Element {
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const queryPayloads = useMemo(
-		() => getHostQueryPayload(hostName, timeRange.startTime, timeRange.endTime),
-		[hostName, timeRange.startTime, timeRange.endTime],
+		() =>
+			getHostQueryPayload(
+				hostName,
+				timeRange.startTime,
+				timeRange.endTime,
+				dotMetricsEnabled,
+			),
+		[hostName, timeRange.startTime, timeRange.endTime, dotMetricsEnabled],
 	);
 
 	const queries = useQueries(

frontend/src/constants/features.ts

@@ -10,4 +10,5 @@ export enum FeatureKeys {
 	ONBOARDING_V3 = 'ONBOARDING_V3',
 	THIRD_PARTY_API = 'THIRD_PARTY_API',
 	TRACE_FUNNELS = 'TRACE_FUNNELS',
+	DOT_METRICS_ENABLED = 'DOT_METRICS_ENABLED',
 }

frontend/src/container/AllError/index.tsx

@@ -21,7 +21,10 @@ import ROUTES from 'constants/routes';
 import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
 import { useNotifications } from 'hooks/useNotifications';
 import useResourceAttribute from 'hooks/useResourceAttribute';
-import { convertCompositeQueryToTraceSelectedTags } from 'hooks/useResourceAttribute/utils';
+import {
+	convertCompositeQueryToTraceSelectedTags,
+	getResourceDeploymentKeys,
+} from 'hooks/useResourceAttribute/utils';
 import { TimestampInput } from 'hooks/useTimezoneFormatter/useTimezoneFormatter';
 import useUrlQuery from 'hooks/useUrlQuery';
 import createQueryParams from 'lib/createQueryParams';
@@ -38,6 +41,8 @@ import { ErrorResponse, SuccessResponse } from 'types/api';
 import { Exception, PayloadProps } from 'types/api/errors/getAll';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../constants/features';
+import { useAppContext } from '../../providers/App/App';
 import { FilterDropdownExtendsProps } from './types';
 import {
 	extractFilterValues,
@@ -405,6 +410,11 @@ function AllErrors(): JSX.Element {
 		},
 	];
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const onChangeHandler: TableProps<Exception>['onChange'] = useCallback(
 		(
 			paginations: TablePaginationConfig,
@@ -438,7 +448,7 @@ function AllErrors(): JSX.Element {
 	useEffect(() => {
 		if (!isUndefined(errorCountResponse.data?.payload)) {
 			const selectedEnvironments = queries.find(
-				(val) => val.tagKey === 'resource_deployment_environment',
+				(val) => val.tagKey === getResourceDeploymentKeys(dotMetricsEnabled),
 			)?.tagValue;
 
 			logEvent('Exception: List page visited', {

frontend/src/container/AllError/tests/AllError.test.tsx

@@ -10,6 +10,8 @@ import { Provider, useSelector } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import store from 'store';
 
+import * as appContextHooks from '../../../providers/App/App';
+import { LicenseEvent } from '../../../types/api/licensesV3/getActive';
 import AllErrors from '../index';
 import {
 	INIT_URL_WITH_COMMON_QUERY,
@@ -28,6 +30,30 @@ jest.mock('react-redux', () => ({
 	useSelector: jest.fn(),
 }));
 
+jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
+	user: {
+		role: 'admin',
+	},
+	activeLicenseV3: {
+		event_queue: {
+			created_at: '0',
+			event: LicenseEvent.NO_EVENT,
+			scheduled_at: '0',
+			status: '',
+			updated_at: '0',
+		},
+		license: {
+			license_key: 'test-license-key',
+			license_type: 'trial',
+			org_id: 'test-org-id',
+			plan_id: 'test-plan-id',
+			plan_name: 'test-plan-name',
+			plan_type: 'trial',
+			plan_version: 'test-plan-version',
+		},
+	},
+} as any);
+
 function Exceptions({ initUrl }: { initUrl?: string[] }): JSX.Element {
 	return (
 		<MemoryRouter initialEntries={initUrl ?? ['/exceptions']}>

frontend/src/container/Home/Home.tsx

@@ -10,6 +10,7 @@ import getAllUserPreferences from 'api/preferences/getAllUserPreference';
 import updateUserPreferenceAPI from 'api/preferences/updateUserPreference';
 import Header from 'components/Header/Header';
 import { DEFAULT_ENTITY_VERSION } from 'constants/app';
+import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
@@ -161,10 +162,20 @@ export default function Home(): JSX.Element {
 		enabled: !!query,
 	});
 
-	const { data: k8sPodsData } = useGetK8sPodsList(query as K8sPodsListPayload, {
-		queryKey: ['K8sPodsList', query],
-		enabled: !!query,
-	});
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
+	const { data: k8sPodsData } = useGetK8sPodsList(
+		query as K8sPodsListPayload,
+		{
+			queryKey: ['K8sPodsList', query],
+			enabled: !!query,
+		},
+		undefined,
+		dotMetricsEnabled,
+	);
 
 	const [isLogsIngestionActive, setIsLogsIngestionActive] = useState(false);
 	const [isTracesIngestionActive, setIsTracesIngestionActive] = useState(false);

frontend/src/container/Home/Services/ServiceMetrics.tsx

@@ -30,6 +30,7 @@ import { GlobalReducer } from 'types/reducer/globalTime';
 import { Tags } from 'types/reducer/trace';
 import { USER_ROLES } from 'types/roles';
 
+import { FeatureKeys } from '../../../constants/features';
 import { DOCS_LINKS } from '../constants';
 import { columns, TIME_PICKER_OPTIONS } from './constants';
 
@@ -210,6 +211,11 @@ function ServiceMetrics({
 
 	const topLevelOperations = useMemo(() => Object.entries(data || {}), [data]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const queryRangeRequestData = useMemo(
 		() =>
 			getQueryRangeRequestData({
@@ -217,12 +223,14 @@ function ServiceMetrics({
 				minTime: timeRange.startTime * 1e6,
 				maxTime: timeRange.endTime * 1e6,
 				globalSelectedInterval,
+				dotMetricsEnabled,
 			}),
 		[
 			globalSelectedInterval,
 			timeRange.endTime,
 			timeRange.startTime,
 			topLevelOperations,
+			dotMetricsEnabled,
 		],
 	);
 

frontend/src/container/InfraMonitoringHosts/HostsList.tsx

@@ -25,9 +25,11 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../constants/features';
+import { useAppContext } from '../../providers/App/App';
 import HostsListControls from './HostsListControls';
 import HostsListTable from './HostsListTable';
-import { getHostListsQuery, HostsQuickFiltersConfig } from './utils';
+import { getHostListsQuery, GetHostsQuickFiltersConfig } from './utils';
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function HostsList(): JSX.Element {
 	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
@@ -114,6 +116,11 @@ function HostsList(): JSX.Element {
 		entityVersion: '',
 	});
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const handleFiltersChange = useCallback(
 		(value: IBuilderQuery['filters']): void => {
 			const isNewFilterAdded = value.items.length !== filters.items.length;
@@ -182,7 +189,7 @@ function HostsList(): JSX.Element {
 						</div>
 						<QuickFilters
 							source={QuickFiltersSource.INFRA_MONITORING}
-							config={HostsQuickFiltersConfig}
+							config={GetHostsQuickFiltersConfig(dotMetricsEnabled)}
 							handleFilterVisibilityChange={handleFilterVisibilityChange}
 							onFilterChange={handleQuickFiltersChange}
 						/>

frontend/src/container/InfraMonitoringHosts/utils.tsx

@@ -198,3 +198,48 @@ export const HostsQuickFiltersConfig: IQuickFiltersConfig[] = [
 		defaultOpen: true,
 	},
 ];
+
+export function GetHostsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	// These keys don’t change with dotMetricsEnabled
+	const hostNameKey = dotMetricsEnabled ? 'host.name' : 'host_name';
+	const osTypeKey = dotMetricsEnabled ? 'os.type' : 'os_type';
+	// This metric stays the same regardless of notation
+	const metricName = dotMetricsEnabled
+		? 'system.cpu.load_average.15m'
+		: 'system_cpu_load_average_15m';
+
+	return [
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Host Name',
+			attributeKey: {
+				key: hostNameKey,
+				dataType: DataTypes.String,
+				type: 'resource',
+				isColumn: false,
+				isJSON: false,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: metricName,
+			dataSource: DataSource.METRICS,
+			defaultOpen: true,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'OS Type',
+			attributeKey: {
+				key: osTypeKey,
+				dataType: DataTypes.String,
+				type: 'resource',
+				isColumn: false,
+				isJSON: false,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: metricName,
+			dataSource: DataSource.METRICS,
+			defaultOpen: true,
+		},
+	];
+}

frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.tsx

@@ -28,11 +28,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -135,6 +137,11 @@ function K8sClustersList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sClustersRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -194,6 +201,8 @@ function K8sClustersList({
 			queryKey: ['clusterList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const {
@@ -202,8 +211,10 @@ function K8sClustersList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute:
-				K8sEntityToAggregateAttributeMapping[K8sCategory.CLUSTERS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.CLUSTERS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -249,6 +260,8 @@ function K8sClustersList({
 			queryKey: ['clusterList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const clustersData = useMemo(() => data?.payload?.data?.records || [], [data]);

frontend/src/container/InfraMonitoringK8s/Clusters/utils.tsx

@@ -136,6 +136,11 @@ export const getK8sClustersListColumns = (
 	return columnsConfig as ColumnType<K8sClustersRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sClustersData['meta']> = {
+	'k8s.cluster.name': 'k8s_cluster_name',
+	'k8s.cluster.uid': 'k8s_cluster_uid',
+};
+
 const getGroupByEle = (
 	cluster: K8sClustersData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -143,7 +148,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(cluster.meta[group.key as keyof typeof cluster.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof cluster.meta;
+		const value = cluster.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/DaemonSets/K8sDaemonSetsList.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -137,6 +139,11 @@ function K8sDaemonSetsList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sDaemonSetsRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -196,6 +203,8 @@ function K8sDaemonSetsList({
 			queryKey: ['daemonSetList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const {
@@ -204,8 +213,10 @@ function K8sDaemonSetsList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute:
-				K8sEntityToAggregateAttributeMapping[K8sCategory.DAEMONSETS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.DAEMONSETS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -246,6 +257,8 @@ function K8sDaemonSetsList({
 			queryKey: ['daemonSetList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const daemonSetsData = useMemo(() => data?.payload?.data?.records || [], [

frontend/src/container/InfraMonitoringK8s/DaemonSets/utils.tsx

@@ -236,6 +236,12 @@ export const getK8sDaemonSetsListColumns = (
 	return columnsConfig as ColumnType<K8sDaemonSetsRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sDaemonSetsData['meta']> = {
+	'k8s.daemonset.name': 'k8s_daemonset_name',
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+};
+
 const getGroupByEle = (
 	daemonSet: K8sDaemonSetsData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -243,7 +249,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(daemonSet.meta[group.key as keyof typeof daemonSet.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof daemonSet.meta;
+		const value = daemonSet.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/Deployments/K8sDeploymentsList.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -138,6 +140,11 @@ function K8sDeploymentsList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sDeploymentsRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -197,6 +204,8 @@ function K8sDeploymentsList({
 			queryKey: ['deploymentList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const {
@@ -205,8 +214,10 @@ function K8sDeploymentsList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute:
-				K8sEntityToAggregateAttributeMapping[K8sCategory.DEPLOYMENTS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.DEPLOYMENTS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -247,6 +258,8 @@ function K8sDeploymentsList({
 			queryKey: ['deploymentList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const deploymentsData = useMemo(() => data?.payload?.data?.records || [], [

frontend/src/container/InfraMonitoringK8s/Deployments/utils.tsx

@@ -226,6 +226,12 @@ export const getK8sDeploymentsListColumns = (
 	return columnsConfig as ColumnType<K8sDeploymentsRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sDeploymentsData['meta']> = {
+	'k8s.deployment.name': 'k8s_deployment_name',
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+};
+
 const getGroupByEle = (
 	deployment: K8sDeploymentsData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -233,9 +239,14 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(
-			deployment.meta[group.key as keyof typeof deployment.meta],
-		);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ??
+			rawKey) as keyof typeof deployment.meta;
+		const value = deployment.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityMetrics/EntityMetrics.tsx

@@ -29,6 +29,9 @@ import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { Options } from 'uplot';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
+
 interface EntityMetricsProps<T> {
 	timeRange: {
 		startTime: number;
@@ -49,6 +52,7 @@ interface EntityMetricsProps<T> {
 		node: T,
 		start: number,
 		end: number,
+		dotMetricsEnabled: boolean,
 	) => GetQueryResultsProps[];
 	queryKey: string;
 	category: K8sCategory;
@@ -65,9 +69,25 @@ function EntityMetrics<T>({
 	queryKey,
 	category,
 }: EntityMetricsProps<T>): JSX.Element {
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
 	const queryPayloads = useMemo(
-		() => getEntityQueryPayload(entity, timeRange.startTime, timeRange.endTime),
-		[getEntityQueryPayload, entity, timeRange.startTime, timeRange.endTime],
+		() =>
+			getEntityQueryPayload(
+				entity,
+				timeRange.startTime,
+				timeRange.endTime,
+				dotMetricsEnabled,
+			),
+		[
+			getEntityQueryPayload,
+			entity,
+			timeRange.startTime,
+			timeRange.endTime,
+			dotMetricsEnabled,
+		],
 	);
 
 	const queries = useQueries(

frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx

@@ -26,19 +26,21 @@ import { useState } from 'react';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
+import { FeatureKeys } from '../../constants/features';
+import { useAppContext } from '../../providers/App/App';
 import K8sClustersList from './Clusters/K8sClustersList';
 import {
-	ClustersQuickFiltersConfig,
-	DaemonSetsQuickFiltersConfig,
-	DeploymentsQuickFiltersConfig,
+	GetClustersQuickFiltersConfig,
+	GetDaemonsetsQuickFiltersConfig,
+	GetDeploymentsQuickFiltersConfig,
+	GetJobsQuickFiltersConfig,
+	GetNamespaceQuickFiltersConfig,
+	GetNodesQuickFiltersConfig,
+	GetPodsQuickFiltersConfig,
+	GetStatefulsetsQuickFiltersConfig,
+	GetVolumesQuickFiltersConfig,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	JobsQuickFiltersConfig,
 	K8sCategories,
-	NamespaceQuickFiltersConfig,
-	NodesQuickFiltersConfig,
-	PodsQuickFiltersConfig,
-	StatefulsetsQuickFiltersConfig,
-	VolumesQuickFiltersConfig,
 } from './constants';
 import K8sDaemonSetsList from './DaemonSets/K8sDaemonSetsList';
 import K8sDeploymentsList from './Deployments/K8sDeploymentsList';
@@ -74,6 +76,11 @@ export default function InfraMonitoringK8s(): JSX.Element {
 		entityVersion: '',
 	});
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const handleFilterChange = (query: Query): void => {
 		// update the current query with the new filters
 		// in infra monitoring k8s, we are using only one query, hence updating the 0th index of queryData
@@ -109,7 +116,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={PodsQuickFiltersConfig}
+					config={GetPodsQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -129,7 +136,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={NodesQuickFiltersConfig}
+					config={GetNodesQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -152,7 +159,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={NamespaceQuickFiltersConfig}
+					config={GetNamespaceQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -172,7 +179,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={ClustersQuickFiltersConfig}
+					config={GetClustersQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -192,7 +199,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={DeploymentsQuickFiltersConfig}
+					config={GetDeploymentsQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -212,7 +219,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={JobsQuickFiltersConfig}
+					config={GetJobsQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -232,7 +239,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={DaemonSetsQuickFiltersConfig}
+					config={GetDaemonsetsQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -255,7 +262,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={StatefulsetsQuickFiltersConfig}
+					config={GetStatefulsetsQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>
@@ -275,7 +282,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 			children: (
 				<QuickFilters
 					source={QuickFiltersSource.INFRA_MONITORING}
-					config={VolumesQuickFiltersConfig}
+					config={GetVolumesQuickFiltersConfig(dotMetricsEnabled)}
 					handleFilterVisibilityChange={handleFilterVisibilityChange}
 					onFilterChange={handleFilterChange}
 				/>

frontend/src/container/InfraMonitoringK8s/Jobs/JobDetails/constants.ts

@@ -30,395 +30,415 @@ export const getJobMetricsQueryPayload = (
 	job: K8sJobsData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
-	{
-		selectedTime: 'GLOBAL_TIME',
-		graphType: PANEL_TYPES.TIME_SERIES,
-		query: {
-			builder: {
-				queryData: [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const k8sPodCpuUtilizationKey = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+	const k8sPodMemoryUsageKey = dotMetricsEnabled
+		? 'k8s.pod.memory.usage'
+		: 'k8s_pod_memory_usage';
+	const k8sPodNetworkIoKey = dotMetricsEnabled
+		? 'k8s.pod.network.io'
+		: 'k8s_pod_network_io';
+	const k8sPodNetworkErrorsKey = dotMetricsEnabled
+		? 'k8s.pod.network.errors'
+		: 'k8s_pod_network_errors';
+	const k8sJobNameKey = dotMetricsEnabled ? 'k8s.job.name' : 'k8s_job_name';
+	const k8sNamespaceNameKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+
+	return [
+		{
+			selectedTime: 'GLOBAL_TIME',
+			graphType: PANEL_TYPES.TIME_SERIES,
+			query: {
+				builder: {
+					queryData: [
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								isColumn: true,
+								isJSON: false,
+								key: k8sPodCpuUtilizationKey,
+								type: 'Gauge',
+							},
+							aggregateOperator: 'avg',
+							dataSource: DataSource.METRICS,
+							disabled: false,
+							expression: 'A',
+							filters: {
+								items: [
+									{
+										id: '6b59b690',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_job_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sJobNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.jobName,
+									},
+									{
+										id: '47b3adae',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_namespace_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sNamespaceNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.meta.k8s_namespace_name,
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [],
+							having: [],
+							legend: 'usage',
+							limit: null,
+							orderBy: [],
+							queryName: 'A',
+							reduceTo: 'avg',
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'avg',
+						},
+					],
+					queryFormulas: [],
+				},
+				clickhouse_sql: [
 					{
-						aggregateAttribute: {
-							dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
-							isColumn: true,
-							isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
-							type: 'Gauge',
-						},
-						aggregateOperator: 'avg',
-						dataSource: DataSource.METRICS,
 						disabled: false,
-						expression: 'A',
-						filters: {
-							items: [
-								{
-									id: '6b59b690',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_job_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_job_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.jobName,
-								},
-								{
-									id: '47b3adae',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_namespace_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.meta.k8s_namespace_name,
-								},
-							],
-							op: 'AND',
-						},
-						functions: [],
-						groupBy: [],
-						having: [],
-						legend: 'usage',
-						limit: null,
-						orderBy: [],
-						queryName: 'A',
-						reduceTo: 'avg',
-						spaceAggregation: 'sum',
-						stepInterval: 60,
-						timeAggregation: 'avg',
+						legend: '',
+						name: 'A',
+						query: '',
 					},
 				],
-				queryFormulas: [],
-			},
-			clickhouse_sql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			id: v4(),
-			promql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			queryType: EQueryType.QUERY_BUILDER,
-		},
-		variables: {},
-		formatForWeb: false,
-		start,
-		end,
-	},
-	{
-		selectedTime: 'GLOBAL_TIME',
-		graphType: PANEL_TYPES.TIME_SERIES,
-		query: {
-			builder: {
-				queryData: [
+				id: v4(),
+				promql: [
 					{
-						aggregateAttribute: {
-							dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
-							isColumn: true,
-							isJSON: false,
-							key: 'k8s_pod_memory_usage',
-							type: 'Gauge',
-						},
-						aggregateOperator: 'avg',
-						dataSource: DataSource.METRICS,
 						disabled: false,
-						expression: 'A',
-						filters: {
-							items: [
-								{
-									id: '8c217f4d',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_job_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_job_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.jobName,
-								},
-								{
-									id: '47b3adae',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_namespace_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.meta.k8s_namespace_name,
-								},
-							],
-							op: 'AND',
-						},
-						functions: [],
-						groupBy: [],
-						having: [],
-						legend: 'usage',
-						limit: null,
-						orderBy: [],
-						queryName: 'A',
-						reduceTo: 'avg',
-						spaceAggregation: 'sum',
-						stepInterval: 60,
-						timeAggregation: 'avg',
+						legend: '',
+						name: 'A',
+						query: '',
 					},
 				],
-				queryFormulas: [],
+				queryType: EQueryType.QUERY_BUILDER,
 			},
-			clickhouse_sql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			id: v4(),
-			promql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			queryType: EQueryType.QUERY_BUILDER,
+			variables: {},
+			formatForWeb: false,
+			start,
+			end,
 		},
-		variables: {},
-		formatForWeb: false,
-		start,
-		end,
-	},
-	{
-		selectedTime: 'GLOBAL_TIME',
-		graphType: PANEL_TYPES.TIME_SERIES,
-		query: {
-			builder: {
-				queryData: [
+		{
+			selectedTime: 'GLOBAL_TIME',
+			graphType: PANEL_TYPES.TIME_SERIES,
+			query: {
+				builder: {
+					queryData: [
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								isColumn: true,
+								isJSON: false,
+								key: k8sPodMemoryUsageKey,
+								type: 'Gauge',
+							},
+							aggregateOperator: 'avg',
+							dataSource: DataSource.METRICS,
+							disabled: false,
+							expression: 'A',
+							filters: {
+								items: [
+									{
+										id: '8c217f4d',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_job_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sJobNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.jobName,
+									},
+									{
+										id: '47b3adae',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_namespace_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sNamespaceNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.meta.k8s_namespace_name,
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [],
+							having: [],
+							legend: 'usage',
+							limit: null,
+							orderBy: [],
+							queryName: 'A',
+							reduceTo: 'avg',
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'avg',
+						},
+					],
+					queryFormulas: [],
+				},
+				clickhouse_sql: [
 					{
-						aggregateAttribute: {
-							dataType: DataTypes.Float64,
-							id: 'k8s_pod_network_io--float64--Sum--true',
-							isColumn: true,
-							isJSON: false,
-							key: 'k8s_pod_network_io',
-							type: 'Sum',
-						},
-						aggregateOperator: 'rate',
-						dataSource: DataSource.METRICS,
 						disabled: false,
-						expression: 'A',
-						filters: {
-							items: [
-								{
-									id: '2bbf9d0c',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_job_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_job_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.jobName,
-								},
-								{
-									id: '47b3adae',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_namespace_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.meta.k8s_namespace_name,
-								},
-							],
-							op: 'AND',
-						},
-						functions: [],
-						groupBy: [
-							{
-								dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
-								isColumn: false,
-								isJSON: false,
-								key: 'direction',
-								type: 'tag',
-							},
-							{
-								dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
-								isColumn: false,
-								isJSON: false,
-								key: 'interface',
-								type: 'tag',
-							},
-						],
-						having: [],
-						legend: '{{direction}} :: {{interface}}',
-						limit: null,
-						orderBy: [],
-						queryName: 'A',
-						reduceTo: 'avg',
-						spaceAggregation: 'sum',
-						stepInterval: 60,
-						timeAggregation: 'rate',
+						legend: '',
+						name: 'A',
+						query: '',
 					},
 				],
-				queryFormulas: [],
-			},
-			clickhouse_sql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			id: v4(),
-			promql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			queryType: EQueryType.QUERY_BUILDER,
-		},
-		variables: {},
-		formatForWeb: false,
-		start,
-		end,
-	},
-	{
-		selectedTime: 'GLOBAL_TIME',
-		graphType: PANEL_TYPES.TIME_SERIES,
-		query: {
-			builder: {
-				queryData: [
+				id: v4(),
+				promql: [
 					{
-						aggregateAttribute: {
-							dataType: DataTypes.Float64,
-							id: 'k8s_pod_network_errors--float64--Sum--true',
-							isColumn: true,
-							isJSON: false,
-							key: 'k8s_pod_network_errors',
-							type: 'Sum',
-						},
-						aggregateOperator: 'increase',
-						dataSource: DataSource.METRICS,
 						disabled: false,
-						expression: 'A',
-						filters: {
-							items: [
-								{
-									id: '448e6cf7',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_job_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_job_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.jobName,
-								},
-								{
-									id: '47b3adae',
-									key: {
-										dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
-										isColumn: false,
-										isJSON: false,
-										key: 'k8s_namespace_name',
-										type: 'tag',
-									},
-									op: '=',
-									value: job.meta.k8s_namespace_name,
-								},
-							],
-							op: 'AND',
-						},
-						functions: [],
-						groupBy: [
-							{
-								dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
-								isColumn: false,
-								isJSON: false,
-								key: 'direction',
-								type: 'tag',
-							},
-							{
-								dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
-								isColumn: false,
-								isJSON: false,
-								key: 'interface',
-								type: 'tag',
-							},
-						],
-						having: [],
-						legend: '{{direction}} :: {{interface}}',
-						limit: null,
-						orderBy: [],
-						queryName: 'A',
-						reduceTo: 'avg',
-						spaceAggregation: 'sum',
-						stepInterval: 60,
-						timeAggregation: 'increase',
+						legend: '',
+						name: 'A',
+						query: '',
 					},
 				],
-				queryFormulas: [],
+				queryType: EQueryType.QUERY_BUILDER,
 			},
-			clickhouse_sql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			id: v4(),
-			promql: [
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
-			queryType: EQueryType.QUERY_BUILDER,
+			variables: {},
+			formatForWeb: false,
+			start,
+			end,
 		},
-		variables: {},
-		formatForWeb: false,
-		start,
-		end,
-	},
-];
+		{
+			selectedTime: 'GLOBAL_TIME',
+			graphType: PANEL_TYPES.TIME_SERIES,
+			query: {
+				builder: {
+					queryData: [
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'k8s_pod_network_io--float64--Sum--true',
+								isColumn: true,
+								isJSON: false,
+								key: k8sPodNetworkIoKey,
+								type: 'Sum',
+							},
+							aggregateOperator: 'rate',
+							dataSource: DataSource.METRICS,
+							disabled: false,
+							expression: 'A',
+							filters: {
+								items: [
+									{
+										id: '2bbf9d0c',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_job_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sJobNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.jobName,
+									},
+									{
+										id: '47b3adae',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_namespace_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sNamespaceNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.meta.k8s_namespace_name,
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [
+								{
+									dataType: DataTypes.String,
+									id: 'direction--string--tag--false',
+									isColumn: false,
+									isJSON: false,
+									key: 'direction',
+									type: 'tag',
+								},
+								{
+									dataType: DataTypes.String,
+									id: 'interface--string--tag--false',
+									isColumn: false,
+									isJSON: false,
+									key: 'interface',
+									type: 'tag',
+								},
+							],
+							having: [],
+							legend: '{{direction}} :: {{interface}}',
+							limit: null,
+							orderBy: [],
+							queryName: 'A',
+							reduceTo: 'avg',
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'rate',
+						},
+					],
+					queryFormulas: [],
+				},
+				clickhouse_sql: [
+					{
+						disabled: false,
+						legend: '',
+						name: 'A',
+						query: '',
+					},
+				],
+				id: v4(),
+				promql: [
+					{
+						disabled: false,
+						legend: '',
+						name: 'A',
+						query: '',
+					},
+				],
+				queryType: EQueryType.QUERY_BUILDER,
+			},
+			variables: {},
+			formatForWeb: false,
+			start,
+			end,
+		},
+		{
+			selectedTime: 'GLOBAL_TIME',
+			graphType: PANEL_TYPES.TIME_SERIES,
+			query: {
+				builder: {
+					queryData: [
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'k8s_pod_network_errors--float64--Sum--true',
+								isColumn: true,
+								isJSON: false,
+								key: k8sPodNetworkErrorsKey,
+								type: 'Sum',
+							},
+							aggregateOperator: 'increase',
+							dataSource: DataSource.METRICS,
+							disabled: false,
+							expression: 'A',
+							filters: {
+								items: [
+									{
+										id: '448e6cf7',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_job_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sJobNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.jobName,
+									},
+									{
+										id: '47b3adae',
+										key: {
+											dataType: DataTypes.String,
+											id: 'k8s_namespace_name--string--tag--false',
+											isColumn: false,
+											isJSON: false,
+											key: k8sNamespaceNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: job.meta.k8s_namespace_name,
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [
+								{
+									dataType: DataTypes.String,
+									id: 'direction--string--tag--false',
+									isColumn: false,
+									isJSON: false,
+									key: 'direction',
+									type: 'tag',
+								},
+								{
+									dataType: DataTypes.String,
+									id: 'interface--string--tag--false',
+									isColumn: false,
+									isJSON: false,
+									key: 'interface',
+									type: 'tag',
+								},
+							],
+							having: [],
+							legend: '{{direction}} :: {{interface}}',
+							limit: null,
+							orderBy: [],
+							queryName: 'A',
+							reduceTo: 'avg',
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'increase',
+						},
+					],
+					queryFormulas: [],
+				},
+				clickhouse_sql: [
+					{
+						disabled: false,
+						legend: '',
+						name: 'A',
+						query: '',
+					},
+				],
+				id: v4(),
+				promql: [
+					{
+						disabled: false,
+						legend: '',
+						name: 'A',
+						query: '',
+					},
+				],
+				queryType: EQueryType.QUERY_BUILDER,
+			},
+			variables: {},
+			formatForWeb: false,
+			start,
+			end,
+		},
+	];
+};

frontend/src/container/InfraMonitoringK8s/Jobs/K8sJobsList.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -132,6 +134,11 @@ function K8sJobsList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sJobsRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -185,10 +192,15 @@ function K8sJobsList({
 		isLoading: isLoadingGroupedByRowData,
 		isError: isErrorGroupedByRowData,
 		refetch: fetchGroupedByRowData,
-	} = useGetK8sJobsList(fetchGroupedByRowDataQuery as K8sJobsListPayload, {
-		queryKey: ['jobList', fetchGroupedByRowDataQuery],
-		enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-	});
+	} = useGetK8sJobsList(
+		fetchGroupedByRowDataQuery as K8sJobsListPayload,
+		{
+			queryKey: ['jobList', fetchGroupedByRowDataQuery],
+			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
+		},
+		undefined,
+		dotMetricsEnabled,
+	);
 
 	const {
 		data: groupByFiltersData,
@@ -196,7 +208,10 @@ function K8sJobsList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: K8sEntityToAggregateAttributeMapping[K8sCategory.JOBS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.JOBS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -242,6 +257,8 @@ function K8sJobsList({
 			queryKey: ['jobList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const jobsData = useMemo(() => data?.payload?.data?.records || [], [data]);

frontend/src/container/InfraMonitoringK8s/Jobs/utils.tsx

@@ -263,6 +263,12 @@ export const getK8sJobsListColumns = (
 	return columnsConfig as ColumnType<K8sJobsRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sJobsData['meta']> = {
+	'k8s.job.name': 'k8s_job_name',
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+};
+
 const getGroupByEle = (
 	job: K8sJobsData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -270,7 +276,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(job.meta[group.key as keyof typeof job.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof job.meta;
+		const value = job.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/Namespaces/K8sNamespacesList.tsx

@@ -28,11 +28,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -136,6 +138,11 @@ function K8sNamespacesList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sNamespacesRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -195,6 +202,8 @@ function K8sNamespacesList({
 			queryKey: ['namespaceList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const {
@@ -203,8 +212,10 @@ function K8sNamespacesList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute:
-				K8sEntityToAggregateAttributeMapping[K8sCategory.NAMESPACES],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.NAMESPACES,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -245,6 +256,8 @@ function K8sNamespacesList({
 			queryKey: ['namespaceList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const namespacesData = useMemo(() => data?.payload?.data?.records || [], [

frontend/src/container/InfraMonitoringK8s/Namespaces/utils.tsx

@@ -122,6 +122,11 @@ export const getK8sNamespacesListColumns = (
 	return columnsConfig as ColumnType<K8sNamespacesRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sNamespacesData['meta']> = {
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+};
+
 const getGroupByEle = (
 	namespace: K8sNamespacesData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -129,7 +134,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(namespace.meta[group.key as keyof typeof namespace.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof namespace.meta;
+		const value = namespace.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx

@@ -28,11 +28,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -130,6 +132,11 @@ function K8sNodesList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sNodesRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -183,10 +190,15 @@ function K8sNodesList({
 		isLoading: isLoadingGroupedByRowData,
 		isError: isErrorGroupedByRowData,
 		refetch: fetchGroupedByRowData,
-	} = useGetK8sNodesList(fetchGroupedByRowDataQuery as K8sNodesListPayload, {
-		queryKey: ['nodeList', fetchGroupedByRowDataQuery],
-		enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-	});
+	} = useGetK8sNodesList(
+		fetchGroupedByRowDataQuery as K8sNodesListPayload,
+		{
+			queryKey: ['nodeList', fetchGroupedByRowDataQuery],
+			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
+		},
+		undefined,
+		dotMetricsEnabled,
+	);
 
 	const {
 		data: groupByFiltersData,
@@ -194,7 +206,10 @@ function K8sNodesList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: K8sEntityToAggregateAttributeMapping[K8sCategory.NODES],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.NODES,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -240,6 +255,8 @@ function K8sNodesList({
 			queryKey: ['nodeList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const nodesData = useMemo(() => data?.payload?.data?.records || [], [data]);

frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx

@@ -152,6 +152,12 @@ export const getK8sNodesListColumns = (
 	return columnsConfig as ColumnType<K8sNodesRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sNodesData['meta']> = {
+	'k8s.node.name': 'k8s_node_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+	'k8s.node.uid': 'k8s_node_uid',
+};
+
 const getGroupByEle = (
 	node: K8sNodesData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -159,7 +165,14 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(node.meta[group.key as keyof typeof node.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof node.meta;
+
+		const value = node.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -118,13 +120,21 @@ function K8sPodsList({
 		[currentQuery?.builder?.queryData],
 	);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const {
 		data: groupByFiltersData,
 		isLoading: isLoadingGroupByFilters,
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: K8sEntityToAggregateAttributeMapping[K8sCategory.PODS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.PODS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -201,6 +211,8 @@ function K8sPodsList({
 			queryKey: ['hostList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const createFiltersForSelectedRowData = (
@@ -255,10 +267,15 @@ function K8sPodsList({
 		isLoading: isLoadingGroupedByRowData,
 		isError: isErrorGroupedByRowData,
 		refetch: fetchGroupedByRowData,
-	} = useGetK8sPodsList(fetchGroupedByRowDataQuery as K8sPodsListPayload, {
-		queryKey: ['hostList', fetchGroupedByRowDataQuery],
-		enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-	});
+	} = useGetK8sPodsList(
+		fetchGroupedByRowDataQuery as K8sPodsListPayload,
+		{
+			queryKey: ['hostList', fetchGroupedByRowDataQuery],
+			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
+		},
+		undefined,
+		dotMetricsEnabled,
+	);
 
 	const podsData = useMemo(() => data?.payload?.data?.records || [], [data]);
 	const totalCount = data?.payload?.data?.total || 0;

frontend/src/container/InfraMonitoringK8s/StatefulSets/K8sStatefulSetsList.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -137,6 +139,11 @@ function K8sStatefulSetsList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sStatefulSetsRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -196,6 +203,8 @@ function K8sStatefulSetsList({
 			queryKey: ['statefulSetList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const {
@@ -204,8 +213,10 @@ function K8sStatefulSetsList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute:
-				K8sEntityToAggregateAttributeMapping[K8sCategory.STATEFULSETS],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.STATEFULSETS,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -251,6 +262,8 @@ function K8sStatefulSetsList({
 			queryKey: ['statefulSetList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const statefulSetsData = useMemo(() => data?.payload?.data?.records || [], [

frontend/src/container/InfraMonitoringK8s/StatefulSets/utils.tsx

@@ -236,6 +236,11 @@ export const getK8sStatefulSetsListColumns = (
 	return columnsConfig as ColumnType<K8sStatefulSetsRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sStatefulSetsData['meta']> = {
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.statefulset.name': 'k8s_statefulset_name',
+};
+
 const getGroupByEle = (
 	statefulSet: K8sStatefulSetsData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -243,9 +248,14 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(
-			statefulSet.meta[group.key as keyof typeof statefulSet.meta],
-		);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ??
+			rawKey) as keyof typeof statefulSet.meta;
+		const value = statefulSet.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/Volumes/K8sVolumesList.tsx

@@ -29,11 +29,13 @@ import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { getOrderByFromParams } from '../commonUtils';
 import {
+	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from '../constants';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
@@ -137,6 +139,11 @@ function K8sVolumesList({
 		}
 	}, [quickFiltersLastUpdated]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const createFiltersForSelectedRowData = (
 		selectedRowData: K8sVolumesRowData,
 		groupBy: IBuilderQuery['groupBy'],
@@ -190,10 +197,15 @@ function K8sVolumesList({
 		isLoading: isLoadingGroupedByRowData,
 		isError: isErrorGroupedByRowData,
 		refetch: fetchGroupedByRowData,
-	} = useGetK8sVolumesList(fetchGroupedByRowDataQuery as K8sVolumesListPayload, {
-		queryKey: ['volumeList', fetchGroupedByRowDataQuery],
-		enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-	});
+	} = useGetK8sVolumesList(
+		fetchGroupedByRowDataQuery as K8sVolumesListPayload,
+		{
+			queryKey: ['volumeList', fetchGroupedByRowDataQuery],
+			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
+		},
+		undefined,
+		dotMetricsEnabled,
+	);
 
 	const {
 		data: groupByFiltersData,
@@ -201,7 +213,10 @@ function K8sVolumesList({
 	} = useGetAggregateKeys(
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: K8sEntityToAggregateAttributeMapping[K8sCategory.NODES],
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				K8sCategory.NODES,
+				dotMetricsEnabled,
+			),
 			aggregateOperator: 'noop',
 			searchText: '',
 			tagType: '',
@@ -247,6 +262,8 @@ function K8sVolumesList({
 			queryKey: ['volumeList', query],
 			enabled: !!query,
 		},
+		undefined,
+		dotMetricsEnabled,
 	);
 
 	const volumesData = useMemo(() => data?.payload?.data?.records || [], [data]);

frontend/src/container/InfraMonitoringK8s/Volumes/utils.tsx

@@ -142,6 +142,16 @@ export const getK8sVolumesListColumns = (
 	return columnsConfig as ColumnType<K8sVolumesRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sVolumesData['meta']> = {
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.node.name': 'k8s_node_name',
+	'k8s.pod.name': 'k8s_pod_name',
+	'k8s.pod.uid': 'k8s_pod_uid',
+	'k8s.statefulset.name': 'k8s_statefulset_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+	'k8s.persistentvolumeclaim.name': 'k8s_persistentvolumeclaim_name',
+};
+
 const getGroupByEle = (
 	volume: K8sVolumesData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -149,7 +159,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(volume.meta[group.key as keyof typeof volume.meta]);
+		const rawKey = group.key as string;
+
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof volume.meta;
+
+		const value = volume.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/InfraMonitoringK8s/utils.tsx

@@ -299,6 +299,19 @@ export const getK8sPodsListColumns = (
 	return updatedColumnsConfig as ColumnType<K8sPodsRowData>[];
 };
 
+const dotToUnder: Record<string, keyof K8sPodsData['meta']> = {
+	'k8s.cronjob.name': 'k8s_cronjob_name',
+	'k8s.daemonset.name': 'k8s_daemonset_name',
+	'k8s.deployment.name': 'k8s_deployment_name',
+	'k8s.job.name': 'k8s_job_name',
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.node.name': 'k8s_node_name',
+	'k8s.pod.name': 'k8s_pod_name',
+	'k8s.pod.uid': 'k8s_pod_uid',
+	'k8s.statefulset.name': 'k8s_statefulset_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+};
+
 const getGroupByEle = (
 	pod: K8sPodsData,
 	groupBy: IBuilderQuery['groupBy'],
@@ -306,7 +319,13 @@ const getGroupByEle = (
 	const groupByValues: string[] = [];
 
 	groupBy.forEach((group) => {
-		groupByValues.push(pod.meta[group.key as keyof typeof pod.meta]);
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof pod.meta;
+		const value = pod.meta[metaKey];
+
+		groupByValues.push(value);
 	});
 
 	return (

frontend/src/container/LogDetailedView/InfraMetrics/NodeMetrics.tsx

@@ -15,6 +15,8 @@ import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import uPlot from 'uplot';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import {
 	getHostQueryPayload,
 	getNodeQueryPayload,
@@ -49,12 +51,23 @@ function NodeMetrics({
 		};
 	}, [logLineTimestamp]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const queryPayloads = useMemo(() => {
 		if (nodeName) {
-			return getNodeQueryPayload(clusterName, nodeName, start, end);
+			return getNodeQueryPayload(
+				clusterName,
+				nodeName,
+				start,
+				end,
+				dotMetricsEnabled,
+			);
 		}
-		return getHostQueryPayload(hostName, start, end);
-	}, [nodeName, hostName, clusterName, start, end]);
+		return getHostQueryPayload(hostName, start, end, dotMetricsEnabled);
+	}, [nodeName, hostName, clusterName, start, end, dotMetricsEnabled]);
 
 	const widgetInfo = nodeName ? nodeWidgetInfo : hostWidgetInfo;
 	const queries = useQueries(

frontend/src/container/LogDetailedView/InfraMetrics/PodMetrics.tsx

@@ -8,6 +8,7 @@ import { useResizeObserver } from 'hooks/useDimensions';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
 import { getUPlotChartOptions } from 'lib/uPlotLib/getUplotChartOptions';
 import { getUPlotChartData } from 'lib/uPlotLib/utils/getUplotChartData';
+import { useAppContext } from 'providers/App/App';
 import { useTimezone } from 'providers/Timezone';
 import { useMemo, useRef } from 'react';
 import { useQueries, UseQueryResult } from 'react-query';
@@ -15,6 +16,7 @@ import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import uPlot from 'uplot';
 
+import { FeatureKeys } from '../../../constants/features';
 import { getPodQueryPayload, podWidgetInfo } from './constants';
 
 function PodMetrics({
@@ -41,9 +43,15 @@ function PodMetrics({
 			verticalLineTimestamp: logTimestamp.unix(),
 		};
 	}, [logLineTimestamp]);
+
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const queryPayloads = useMemo(
-		() => getPodQueryPayload(clusterName, podName, start, end),
-		[clusterName, end, podName, start],
+		() => getPodQueryPayload(clusterName, podName, start, end, dotMetricsEnabled),
+		[clusterName, end, podName, start, dotMetricsEnabled],
 	);
 	const queries = useQueries(
 		queryPayloads.map((payload) => ({

frontend/src/container/MetricsApplication/MetricsPageQueries/DBCallQueries.ts

@@ -21,6 +21,7 @@ export const databaseCallsRPS = ({
 	servicename,
 	legend,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: DatabaseCallsRPSProps): QueryBuilderData => {
 	const autocompleteData: BaseAutocompleteData[] = [
 		{
@@ -34,7 +35,7 @@ export const databaseCallsRPS = ({
 		{
 			dataType: DataTypes.String,
 			isColumn: false,
-			key: 'db_system',
+			key: dotMetricsEnabled ? WidgetKeys.Db_system : WidgetKeys.Db_system_norm,
 			type: 'tag',
 		},
 	];
@@ -43,7 +44,9 @@ export const databaseCallsRPS = ({
 			{
 				id: '',
 				key: {
-					key: WidgetKeys.Service_name,
+					key: dotMetricsEnabled
+						? WidgetKeys.Service_name
+						: WidgetKeys.Service_name_norm,
 					dataType: DataTypes.String,
 					isColumn: false,
 					type: MetricsType.Resource,
@@ -75,6 +78,7 @@ export const databaseCallsRPS = ({
 export const databaseCallsAvgDuration = ({
 	servicename,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: DatabaseCallProps): QueryBuilderData => {
 	const autocompleteDataA: BaseAutocompleteData = {
 		key: WidgetKeys.SignozDbLatencySum,
@@ -93,7 +97,9 @@ export const databaseCallsAvgDuration = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,

frontend/src/container/MetricsApplication/MetricsPageQueries/ExternalQueries.ts

@@ -33,6 +33,7 @@ export const externalCallErrorPercent = ({
 	servicename,
 	legend,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: ExternalCallDurationByAddressProps): QueryBuilderData => {
 	const autocompleteDataA: BaseAutocompleteData = {
 		key: WidgetKeys.SignozExternalCallLatencyCount,
@@ -51,7 +52,9 @@ export const externalCallErrorPercent = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,
@@ -62,7 +65,7 @@ export const externalCallErrorPercent = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled ? WidgetKeys.StatusCode : WidgetKeys.StatusCodeNorm,
 				dataType: DataTypes.Int64,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -76,7 +79,9 @@ export const externalCallErrorPercent = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,
@@ -121,6 +126,7 @@ export const externalCallErrorPercent = ({
 export const externalCallDuration = ({
 	servicename,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: ExternalCallProps): QueryBuilderData => {
 	const autocompleteDataA: BaseAutocompleteData = {
 		dataType: DataTypes.Float64,
@@ -144,7 +150,9 @@ export const externalCallDuration = ({
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -184,6 +192,7 @@ export const externalCallRpsByAddress = ({
 	servicename,
 	legend,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: ExternalCallDurationByAddressProps): QueryBuilderData => {
 	const autocompleteData: BaseAutocompleteData[] = [
 		{
@@ -200,7 +209,9 @@ export const externalCallRpsByAddress = ({
 				key: {
 					dataType: DataTypes.String,
 					isColumn: false,
-					key: WidgetKeys.Service_name,
+					key: dotMetricsEnabled
+						? WidgetKeys.Service_name
+						: WidgetKeys.Service_name_norm,
 					type: MetricsType.Resource,
 				},
 				op: OPERATORS.IN,
@@ -231,6 +242,7 @@ export const externalCallDurationByAddress = ({
 	servicename,
 	legend,
 	tagFilterItems,
+	dotMetricsEnabled,
 }: ExternalCallDurationByAddressProps): QueryBuilderData => {
 	const autocompleteDataA: BaseAutocompleteData = {
 		dataType: DataTypes.Float64,
@@ -253,7 +265,9 @@ export const externalCallDurationByAddress = ({
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,

frontend/src/container/MetricsApplication/MetricsPageQueries/OverviewQueries.ts

@@ -37,10 +37,18 @@ export const latency = ({
 	tagFilterItems,
 	isSpanMetricEnable = false,
 	topLevelOperationsRoute,
+	dotMetricsEnabled,
 }: LatencyProps): QueryBuilderData => {
+	const signozLatencyBucketMetrics = dotMetricsEnabled
+		? WidgetKeys.Signoz_latency_bucket
+		: WidgetKeys.Signoz_latency_bucket_norm;
+
+	const signozMetricsServiceName = dotMetricsEnabled
+		? WidgetKeys.Service_name
+		: WidgetKeys.Service_name_norm;
 	const newAutoCompleteData: BaseAutocompleteData = {
 		key: isSpanMetricEnable
-			? WidgetKeys.Signoz_latency_bucket
+			? signozLatencyBucketMetrics
 			: WidgetKeys.DurationNano,
 		dataType: DataTypes.Float64,
 		isColumn: true,
@@ -53,7 +61,7 @@ export const latency = ({
 		{
 			id: '',
 			key: {
-				key: isSpanMetricEnable ? WidgetKeys.Service_name : WidgetKeys.ServiceName,
+				key: isSpanMetricEnable ? signozMetricsServiceName : WidgetKeys.ServiceName,
 				dataType: DataTypes.String,
 				type: isSpanMetricEnable ? MetricsType.Resource : MetricsType.Tag,
 				isColumn: !isSpanMetricEnable,
@@ -295,23 +303,30 @@ export const apDexMetricsQueryBuilderQueries = ({
 	threashold,
 	delta,
 	metricsBuckets,
+	dotMetricsEnabled,
 }: ApDexMetricsQueryBuilderQueriesProps): QueryBuilderData => {
 	const autoCompleteDataA: BaseAutocompleteData = {
-		key: WidgetKeys.SignozLatencyCount,
+		key: dotMetricsEnabled
+			? WidgetKeys.SignozLatencyCount
+			: WidgetKeys.SignozLatencyCountNorm,
 		dataType: DataTypes.Float64,
 		isColumn: true,
 		type: '',
 	};
 
 	const autoCompleteDataB: BaseAutocompleteData = {
-		key: WidgetKeys.Signoz_latency_bucket,
+		key: dotMetricsEnabled
+			? WidgetKeys.Signoz_latency_bucket
+			: WidgetKeys.Signoz_latency_bucket_norm,
 		dataType: DataTypes.Float64,
 		isColumn: true,
 		type: '',
 	};
 
 	const autoCompleteDataC: BaseAutocompleteData = {
-		key: WidgetKeys.Signoz_latency_bucket,
+		key: dotMetricsEnabled
+			? WidgetKeys.Signoz_latency_bucket
+			: WidgetKeys.Signoz_latency_bucket_norm,
 		dataType: DataTypes.Float64,
 		isColumn: true,
 		type: '',
@@ -321,7 +336,9 @@ export const apDexMetricsQueryBuilderQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -347,7 +364,7 @@ export const apDexMetricsQueryBuilderQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled ? WidgetKeys.StatusCode : WidgetKeys.StatusCodeNorm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -369,7 +386,9 @@ export const apDexMetricsQueryBuilderQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -406,7 +425,7 @@ export const apDexMetricsQueryBuilderQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled ? WidgetKeys.StatusCode : WidgetKeys.StatusCodeNorm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -417,7 +436,9 @@ export const apDexMetricsQueryBuilderQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -482,10 +503,13 @@ export const operationPerSec = ({
 	servicename,
 	tagFilterItems,
 	topLevelOperations,
+	dotMetricsEnabled,
 }: OperationPerSecProps): QueryBuilderData => {
 	const autocompleteData: BaseAutocompleteData[] = [
 		{
-			key: WidgetKeys.SignozLatencyCount,
+			key: dotMetricsEnabled
+				? WidgetKeys.SignozLatencyCount
+				: WidgetKeys.SignozLatencyCountNorm,
 			dataType: DataTypes.Float64,
 			isColumn: true,
 			type: '',
@@ -497,7 +521,9 @@ export const operationPerSec = ({
 			{
 				id: '',
 				key: {
-					key: WidgetKeys.Service_name,
+					key: dotMetricsEnabled
+						? WidgetKeys.Service_name
+						: WidgetKeys.Service_name_norm,
 					dataType: DataTypes.String,
 					isColumn: false,
 					type: MetricsType.Resource,
@@ -540,6 +566,7 @@ export const errorPercentage = ({
 	servicename,
 	tagFilterItems,
 	topLevelOperations,
+	dotMetricsEnabled,
 }: OperationPerSecProps): QueryBuilderData => {
 	const autocompleteDataA: BaseAutocompleteData = {
 		key: WidgetKeys.SignozCallsTotal,
@@ -560,7 +587,9 @@ export const errorPercentage = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,
@@ -582,7 +611,9 @@ export const errorPercentage = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.StatusCodeNorm,
 				dataType: DataTypes.Int64,
 				isColumn: false,
 				type: MetricsType.Tag,
@@ -597,7 +628,9 @@ export const errorPercentage = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,

frontend/src/container/MetricsApplication/MetricsPageQueries/TopOperationQueries.ts

@@ -21,9 +21,12 @@ import { getQueryBuilderQuerieswithFormula } from './MetricsPageQueriesFactory';
 
 export const topOperationQueries = ({
 	servicename,
+	dotMetricsEnabled,
 }: TopOperationQueryFactoryProps): QueryBuilderData => {
 	const latencyAutoCompleteData: BaseAutocompleteData = {
-		key: WidgetKeys.Signoz_latency_bucket,
+		key: dotMetricsEnabled
+			? WidgetKeys.Signoz_latency_bucket
+			: WidgetKeys.Signoz_latency_bucket_norm,
 		dataType: DataTypes.Float64,
 		isColumn: true,
 		type: '',
@@ -37,7 +40,9 @@ export const topOperationQueries = ({
 	};
 
 	const numOfCallAutoCompleteData: BaseAutocompleteData = {
-		key: WidgetKeys.SignozLatencyCount,
+		key: dotMetricsEnabled
+			? WidgetKeys.SignozLatencyCount
+			: WidgetKeys.SignozLatencyCountNorm,
 		dataType: DataTypes.Float64,
 		isColumn: true,
 		type: '',
@@ -47,7 +52,9 @@ export const topOperationQueries = ({
 		{
 			id: '',
 			key: {
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				dataType: DataTypes.String,
 				isColumn: false,
 				type: MetricsType.Resource,
@@ -63,7 +70,9 @@ export const topOperationQueries = ({
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -74,7 +83,7 @@ export const topOperationQueries = ({
 			key: {
 				dataType: DataTypes.Int64,
 				isColumn: false,
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled ? WidgetKeys.StatusCode : WidgetKeys.StatusCodeNorm,
 				type: MetricsType.Tag,
 			},
 			op: OPERATORS.IN,

frontend/src/container/MetricsApplication/Tabs/DBCall.tsx

@@ -11,6 +11,7 @@ import {
 import useResourceAttribute from 'hooks/useResourceAttribute';
 import {
 	convertRawQueriesToTraceSelectedTags,
+	getResourceDeploymentKeys,
 	resourceAttributesToTagFilterItems,
 } from 'hooks/useResourceAttribute/utils';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
@@ -26,6 +27,8 @@ import { TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { GraphTitle, MENU_ITEMS, SERVICE_CHART_ID } from '../constant';
 import { getWidgetQueryBuilder } from '../MetricsApplication.factory';
 import { Card, GraphContainer, Row } from '../styles';
@@ -80,7 +83,12 @@ function DBCall(): JSX.Element {
 		[queries],
 	);
 
-	const legend = '{{db_system}}';
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
+	const legend = dotMetricsEnabled ? '{{db.system}}' : '{{db_system}}';
 
 	const databaseCallsRPSWidget = useMemo(
 		() =>
@@ -92,6 +100,7 @@ function DBCall(): JSX.Element {
 						servicename,
 						legend,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -102,7 +111,7 @@ function DBCall(): JSX.Element {
 				id: SERVICE_CHART_ID.dbCallsRPS,
 				fillSpans: false,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled, legend],
 	);
 	const databaseCallsAverageDurationWidget = useMemo(
 		() =>
@@ -113,6 +122,7 @@ function DBCall(): JSX.Element {
 					builder: databaseCallsAvgDuration({
 						servicename,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -123,7 +133,7 @@ function DBCall(): JSX.Element {
 				id: GraphTitle.DATABASE_CALLS_AVG_DURATION,
 				fillSpans: true,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled],
 	);
 
 	const stepInterval = useMemo(
@@ -141,7 +151,7 @@ function DBCall(): JSX.Element {
 	useEffect(() => {
 		if (!logEventCalledRef.current) {
 			const selectedEnvironments = queries.find(
-				(val) => val.tagKey === 'resource_deployment_environment',
+				(val) => val.tagKey === getResourceDeploymentKeys(dotMetricsEnabled),
 			)?.tagValue;
 
 			logEvent('APM: Service detail page visited', {

frontend/src/container/MetricsApplication/Tabs/External.tsx

@@ -13,6 +13,7 @@ import {
 import useResourceAttribute from 'hooks/useResourceAttribute';
 import {
 	convertRawQueriesToTraceSelectedTags,
+	getResourceDeploymentKeys,
 	resourceAttributesToTagFilterItems,
 } from 'hooks/useResourceAttribute/utils';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
@@ -28,6 +29,8 @@ import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { EQueryType } from 'types/common/dashboard';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { GraphTitle, legend, MENU_ITEMS } from '../constant';
 import { getWidgetQueryBuilder } from '../MetricsApplication.factory';
 import { Card, GraphContainer, Row } from '../styles';
@@ -75,6 +78,10 @@ function External(): JSX.Element {
 			handleNonInQueryRange(resourceAttributesToTagFilterItems(queries)) || [],
 		[queries],
 	);
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
 
 	const externalCallErrorWidget = useMemo(
 		() =>
@@ -86,6 +93,7 @@ function External(): JSX.Element {
 						servicename,
 						legend: legend.address,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -95,7 +103,7 @@ function External(): JSX.Element {
 				yAxisUnit: '%',
 				id: GraphTitle.EXTERNAL_CALL_ERROR_PERCENTAGE,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled],
 	);
 
 	const selectedTraceTags = useMemo(
@@ -112,6 +120,7 @@ function External(): JSX.Element {
 					builder: externalCallDuration({
 						servicename,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -122,7 +131,7 @@ function External(): JSX.Element {
 				id: GraphTitle.EXTERNAL_CALL_DURATION,
 				fillSpans: true,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled],
 	);
 
 	const errorApmToTraceQuery = useGetAPMToTracesQueries({
@@ -158,7 +167,7 @@ function External(): JSX.Element {
 	useEffect(() => {
 		if (!logEventCalledRef.current) {
 			const selectedEnvironments = queries.find(
-				(val) => val.tagKey === 'resource_deployment_environment',
+				(val) => val.tagKey === getResourceDeploymentKeys(dotMetricsEnabled),
 			)?.tagValue;
 
 			logEvent('APM: Service detail page visited', {
@@ -181,6 +190,7 @@ function External(): JSX.Element {
 						servicename,
 						legend: legend.address,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -191,7 +201,7 @@ function External(): JSX.Element {
 				id: GraphTitle.EXTERNAL_CALL_RPS_BY_ADDRESS,
 				fillSpans: true,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled],
 	);
 
 	const externalCallDurationAddressWidget = useMemo(
@@ -204,6 +214,7 @@ function External(): JSX.Element {
 						servicename,
 						legend: legend.address,
 						tagFilterItems,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -214,7 +225,7 @@ function External(): JSX.Element {
 				id: GraphTitle.EXTERNAL_CALL_DURATION_BY_ADDRESS,
 				fillSpans: true,
 			}),
-		[servicename, tagFilterItems],
+		[servicename, tagFilterItems, dotMetricsEnabled],
 	);
 
 	const apmToTraceQuery = useGetAPMToTracesQueries({

frontend/src/container/MetricsApplication/Tabs/Overview.tsx

@@ -11,6 +11,7 @@ import { getQueryString } from 'container/SideNav/helper';
 import useResourceAttribute from 'hooks/useResourceAttribute';
 import {
 	convertRawQueriesToTraceSelectedTags,
+	getResourceDeploymentKeys,
 	resourceAttributesToTagFilterItems,
 } from 'hooks/useResourceAttribute/utils';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
@@ -92,12 +93,15 @@ function Application(): JSX.Element {
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 		[handleSetTimeStamp],
 	);
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
 
 	const logEventCalledRef = useRef(false);
 	useEffect(() => {
 		if (!logEventCalledRef.current) {
 			const selectedEnvironments = queries.find(
-				(val) => val.tagKey === 'resource_deployment_environment',
+				(val) => val.tagKey === getResourceDeploymentKeys(dotMetricsEnabled),
 			)?.tagValue;
 
 			logEvent('APM: Service detail page visited', {
@@ -155,6 +159,7 @@ function Application(): JSX.Element {
 						servicename,
 						tagFilterItems,
 						topLevelOperations: topLevelOperationsRoute,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -164,7 +169,7 @@ function Application(): JSX.Element {
 				yAxisUnit: 'ops',
 				id: SERVICE_CHART_ID.rps,
 			}),
-		[servicename, tagFilterItems, topLevelOperationsRoute],
+		[servicename, tagFilterItems, topLevelOperationsRoute, dotMetricsEnabled],
 	);
 
 	const errorPercentageWidget = useMemo(
@@ -177,6 +182,7 @@ function Application(): JSX.Element {
 						servicename,
 						tagFilterItems,
 						topLevelOperations: topLevelOperationsRoute,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -187,7 +193,7 @@ function Application(): JSX.Element {
 				id: SERVICE_CHART_ID.errorPercentage,
 				fillSpans: true,
 			}),
-		[servicename, tagFilterItems, topLevelOperationsRoute],
+		[servicename, tagFilterItems, topLevelOperationsRoute, dotMetricsEnabled],
 	);
 
 	const stepInterval = useMemo(

frontend/src/container/MetricsApplication/Tabs/Overview/ApDex/ApDexMetrics.tsx

@@ -20,6 +20,8 @@ import { useParams } from 'react-router-dom';
 import { EQueryType } from 'types/common/dashboard';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../../../../constants/features';
+import { useAppContext } from '../../../../../providers/App/App';
 import { IServiceName } from '../../types';
 import { ApDexMetricsProps } from './types';
 
@@ -34,7 +36,10 @@ function ApDexMetrics({
 }: ApDexMetricsProps): JSX.Element {
 	const { servicename: encodedServiceName } = useParams<IServiceName>();
 	const servicename = decodeURIComponent(encodedServiceName);
-
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
 	const apDexMetricsWidget = useMemo(
 		() =>
 			getWidgetQueryBuilder({
@@ -48,6 +53,7 @@ function ApDexMetrics({
 						threashold: thresholdValue || 0,
 						delta: delta || false,
 						metricsBuckets: metricsBuckets || [],
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -73,6 +79,7 @@ function ApDexMetrics({
 			tagFilterItems,
 			thresholdValue,
 			topLevelOperationsRoute,
+			dotMetricsEnabled,
 		],
 	);
 

frontend/src/container/MetricsApplication/Tabs/Overview/ServiceOverview.tsx

@@ -56,6 +56,10 @@ function ServiceOverview({
 		[isSpanMetricEnable, queries],
 	);
 
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const latencyWidget = useMemo(
 		() =>
 			getWidgetQueryBuilder({
@@ -67,6 +71,7 @@ function ServiceOverview({
 						tagFilterItems,
 						isSpanMetricEnable,
 						topLevelOperationsRoute,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
@@ -76,7 +81,13 @@ function ServiceOverview({
 				yAxisUnit: 'ns',
 				id: SERVICE_CHART_ID.latency,
 			}),
-		[isSpanMetricEnable, servicename, tagFilterItems, topLevelOperationsRoute],
+		[
+			isSpanMetricEnable,
+			servicename,
+			tagFilterItems,
+			topLevelOperationsRoute,
+			dotMetricsEnabled,
+		],
 	);
 
 	const isQueryEnabled =

frontend/src/container/MetricsApplication/Tabs/Overview/TopOperationMetrics.tsx

@@ -18,6 +18,8 @@ import { EQueryType } from 'types/common/dashboard';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
 import { IServiceName } from '../types';
 import { title } from './config';
 import ColumnWithLink from './TableRenderer/ColumnWithLink';
@@ -40,6 +42,11 @@ function TopOperationMetrics(): JSX.Element {
 		convertRawQueriesToTraceSelectedTags(queries) || [],
 	);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const keyOperationWidget = useMemo(
 		() =>
 			getWidgetQueryBuilder({
@@ -48,13 +55,14 @@ function TopOperationMetrics(): JSX.Element {
 					promql: [],
 					builder: topOperationQueries({
 						servicename,
+						dotMetricsEnabled,
 					}),
 					clickhouse_sql: [],
 					id: uuid(),
 				},
 				panelTypes: PANEL_TYPES.TABLE,
 			}),
-		[servicename],
+		[servicename, dotMetricsEnabled],
 	);
 
 	const updatedQuery = useStepInterval(keyOperationWidget.query);

frontend/src/container/MetricsApplication/Tabs/types.ts

@@ -10,6 +10,7 @@ export interface IServiceName {
 
 export interface TopOperationQueryFactoryProps {
 	servicename: IServiceName['servicename'];
+	dotMetricsEnabled: boolean;
 }
 
 export interface ExternalCallDurationByAddressProps extends ExternalCallProps {
@@ -19,6 +20,7 @@ export interface ExternalCallDurationByAddressProps extends ExternalCallProps {
 export interface ExternalCallProps {
 	servicename: IServiceName['servicename'];
 	tagFilterItems: TagFilterItem[];
+	dotMetricsEnabled: boolean;
 }
 
 export interface BuilderQueriesProps {
@@ -50,6 +52,7 @@ export interface OperationPerSecProps {
 	servicename: IServiceName['servicename'];
 	tagFilterItems: TagFilterItem[];
 	topLevelOperations: string[];
+	dotMetricsEnabled: boolean;
 }
 
 export interface LatencyProps {
@@ -57,6 +60,7 @@ export interface LatencyProps {
 	tagFilterItems: TagFilterItem[];
 	isSpanMetricEnable?: boolean;
 	topLevelOperationsRoute: string[];
+	dotMetricsEnabled: boolean;
 }
 
 export interface ApDexProps {
@@ -74,4 +78,5 @@ export interface TableRendererProps {
 export interface ApDexMetricsQueryBuilderQueriesProps extends ApDexProps {
 	delta: boolean;
 	metricsBuckets: number[];
+	dotMetricsEnabled: boolean;
 }

frontend/src/container/MetricsApplication/constant.ts

@@ -85,12 +85,15 @@ export enum WidgetKeys {
 	HasError = 'hasError',
 	Address = 'address',
 	DurationNano = 'durationNano',
-	StatusCode = 'status_code',
+	StatusCodeNorm = 'status_code',
+	StatusCode = 'status.code',
 	Operation = 'operation',
 	OperationName = 'operationName',
-	Service_name = 'service_name',
+	Service_name_norm = 'service_name',
+	Service_name = 'service.name',
 	ServiceName = 'serviceName',
-	SignozLatencyCount = 'signoz_latency_count',
+	SignozLatencyCountNorm = 'signoz_latency_count',
+	SignozLatencyCount = 'signoz_latency.count',
 	SignozDBLatencyCount = 'signoz_db_latency_count',
 	DatabaseCallCount = 'signoz_database_call_count',
 	DatabaseCallLatencySum = 'signoz_database_call_latency_sum',
@@ -98,7 +101,10 @@ export enum WidgetKeys {
 	SignozCallsTotal = 'signoz_calls_total',
 	SignozExternalCallLatencyCount = 'signoz_external_call_latency_count',
 	SignozExternalCallLatencySum = 'signoz_external_call_latency_sum',
-	Signoz_latency_bucket = 'signoz_latency_bucket',
+	Signoz_latency_bucket_norm = 'signoz_latency_bucket',
+	Signoz_latency_bucket = 'signoz_latency.bucket',
+	Db_system = 'db.system',
+	Db_system_norm = 'db_system',
 }
 
 export const topOperationMetricsDownloadOptions: DownloadOptions = {

frontend/src/container/MetricsApplication/types.ts

@@ -25,10 +25,11 @@ export interface NavigateToTraceProps {
 }
 
 export interface DatabaseCallsRPSProps extends DatabaseCallProps {
-	legend: '{{db_system}}';
+	legend: string;
 }
 
 export interface DatabaseCallProps {
 	servicename: IServiceName['servicename'];
 	tagFilterItems: TagFilterItem[];
+	dotMetricsEnabled: boolean;
 }

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

@@ -5,11 +5,13 @@ import { InspectMetricsSeries } from 'api/metricsExplorer/getInspectMetricsDetai
 import { MetricType } from 'api/metricsExplorer/getMetricsList';
 import * as useInspectMetricsHooks from 'hooks/metricsExplorer/useGetInspectMetricsDetails';
 import * as useGetMetricDetailsHooks from 'hooks/metricsExplorer/useGetMetricDetails';
+import * as appContextHooks from 'providers/App/App';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { Provider } from 'react-redux';
 import store from 'store';
 
 import ROUTES from '../../../../constants/routes';
+import { LicenseEvent } from '../../../../types/api/licensesV3/getActive';
 import Inspect from '../Inspect';
 import { InspectionStep } from '../types';
 
@@ -27,6 +29,30 @@ const mockTimeSeries: InspectMetricsSeries[] = [
 	},
 ];
 
+jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
+	user: {
+		role: 'admin',
+	},
+	activeLicenseV3: {
+		event_queue: {
+			created_at: '0',
+			event: LicenseEvent.NO_EVENT,
+			scheduled_at: '0',
+			status: '',
+			updated_at: '0',
+		},
+		license: {
+			license_key: 'test-license-key',
+			license_type: 'trial',
+			org_id: 'test-org-id',
+			plan_id: 'test-plan-id',
+			plan_name: 'test-plan-name',
+			plan_type: 'trial',
+			plan_version: 'test-plan-version',
+		},
+	},
+} as any);
+
 jest.spyOn(useGetMetricDetailsHooks, 'useGetMetricDetails').mockReturnValue({
 	data: {
 		metricDetails: {

frontend/src/container/MetricsExplorer/Inspect/__tests__/QueryBuilder.test.tsx

@@ -1,11 +1,13 @@
 /* eslint-disable react/jsx-props-no-spreading */
 import { render, screen } from '@testing-library/react';
 import { MetricType } from 'api/metricsExplorer/getMetricsList';
+import * as appContextHooks from 'providers/App/App';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { Provider } from 'react-redux';
 import store from 'store';
 
 import ROUTES from '../../../../constants/routes';
+import { LicenseEvent } from '../../../../types/api/licensesV3/getActive';
 import QueryBuilder from '../QueryBuilder';
 import {
 	InspectionStep,
@@ -20,6 +22,30 @@ jest.mock('react-router-dom', () => ({
 	}),
 }));
 
+jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
+	user: {
+		role: 'admin',
+	},
+	activeLicenseV3: {
+		event_queue: {
+			created_at: '0',
+			event: LicenseEvent.NO_EVENT,
+			scheduled_at: '0',
+			status: '',
+			updated_at: '0',
+		},
+		license: {
+			license_key: 'test-license-key',
+			license_type: 'trial',
+			org_id: 'test-org-id',
+			plan_id: 'test-plan-id',
+			plan_name: 'test-plan-name',
+			plan_type: 'trial',
+			plan_version: 'test-plan-version',
+		},
+	},
+} as any);
+
 const queryClient = new QueryClient();
 
 describe('QueryBuilder', () => {

frontend/src/container/MetricsExplorer/Views/Views.tsx

@@ -1,12 +0,0 @@
-import * as Sentry from '@sentry/react';
-import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
-
-function Views(): JSX.Element {
-	return (
-		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
-			Views
-		</Sentry.ErrorBoundary>
-	);
-}
-
-export default Views;

frontend/src/container/MetricsExplorer/Views/index.ts

@@ -1,3 +0,0 @@
-import Views from './Views';
-
-export default Views;

frontend/src/container/PipelinePage/PipelineListsView/AddNewPipeline/index.tsx

@@ -1,6 +1,6 @@
-import { Button, Divider, Form, Modal } from 'antd';
+import { Button, Divider, Form, FormInstance, Modal } from 'antd';
 import { useAppContext } from 'providers/App/App';
-import React, { useCallback, useEffect, useMemo } from 'react';
+import React, { useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { ActionMode, ActionType, PipelineData } from 'types/api/pipeline/def';
 import { v4 } from 'uuid';
@@ -10,6 +10,7 @@ import { getEditedDataSource, getRecordIndex } from '../utils';
 import { renderPipelineForm } from './utils';
 
 function AddNewPipeline({
+	form,
 	isActionType,
 	setActionType,
 	selectedPipelineData,
@@ -17,22 +18,12 @@ function AddNewPipeline({
 	setCurrPipelineData,
 	currPipelineData,
 }: AddNewPipelineProps): JSX.Element {
-	const [form] = Form.useForm();
 	const { t } = useTranslation('pipeline');
 	const { user } = useAppContext();
 
 	const isEdit = isActionType === 'edit-pipeline';
 	const isAdd = isActionType === 'add-pipeline';
 
-	useEffect(() => {
-		if (isEdit) {
-			form.setFieldsValue(selectedPipelineData);
-		}
-		if (isAdd) {
-			form.resetFields();
-		}
-	}, [form, isEdit, isAdd, selectedPipelineData]);
-
 	const onFinish = (values: PipelineData): void => {
 		const newPipeLineData: PipelineData = {
 			id: v4(),
@@ -135,6 +126,7 @@ function AddNewPipeline({
 }
 
 interface AddNewPipelineProps {
+	form: FormInstance<PipelineData>;
 	isActionType: string;
 	setActionType: (actionType?: ActionType) => void;
 	selectedPipelineData: PipelineData | undefined;

frontend/src/container/PipelinePage/PipelineListsView/PipelineListsView.tsx

@@ -1,7 +1,7 @@
 import './styles.scss';
 
 import { ExclamationCircleOutlined, PlusOutlined } from '@ant-design/icons';
-import { Card, Modal, Table, Typography } from 'antd';
+import { Card, Form, Modal, Table, Typography } from 'antd';
 import { ExpandableConfig } from 'antd/es/table/interface';
 import logEvent from 'api/common/logEvent';
 import savePipeline from 'api/pipeline/post';
@@ -95,6 +95,7 @@ function PipelineListsView({
 	pipelineData,
 	refetchPipelineLists,
 }: PipelineListsViewProps): JSX.Element {
+	const [pipelineForm] = Form.useForm<PipelineData>();
 	const { t } = useTranslation(['pipeline', 'common']);
 	const [modal, contextHolder] = Modal.useModal();
 	const { notifications } = useNotifications();
@@ -179,8 +180,9 @@ function PipelineListsView({
 		(record: PipelineData) => (): void => {
 			setActionType(ActionType.EditPipeline);
 			setSelectedPipelineData(record);
+			pipelineForm.setFieldsValue(record);
 		},
-		[setActionType],
+		[setActionType, pipelineForm],
 	);
 
 	const pipelineDeleteHandler = useCallback(
@@ -382,12 +384,13 @@ function PipelineListsView({
 
 	const addNewPipelineHandler = useCallback((): void => {
 		setActionType(ActionType.AddPipeline);
+		pipelineForm.resetFields();
 
 		logEvent('Logs: Pipelines: Clicked Add New Pipeline', {
 			source: 'signoz-ui',
 		});
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [setActionType]);
+	}, [setActionType, pipelineForm]);
 
 	const footer = useCallback((): JSX.Element | undefined => {
 		if (isEditingActionMode) {
@@ -495,6 +498,7 @@ function PipelineListsView({
 		<>
 			{contextHolder}
 			<AddNewPipeline
+				form={pipelineForm}
 				isActionType={isActionType}
 				setActionType={setActionType}
 				selectedPipelineData={selectedPipelineData}

frontend/src/container/PipelinePage/tests/AddNewPipeline.test.tsx

@@ -1,4 +1,6 @@
+import { Form } from 'antd';
 import { render } from 'tests/test-utils';
+import { PipelineData } from 'types/api/pipeline/def';
 
 import { pipelineMockData } from '../mocks/pipeline';
 import AddNewPipeline from '../PipelineListsView/AddNewPipeline';
@@ -36,22 +38,28 @@ beforeAll(() => {
 	matchMedia();
 });
 
+function AddNewPipelineWrapper(): JSX.Element {
+	const setActionType = jest.fn();
+	const selectedPipelineData = pipelineMockData[0];
+	const isActionType = 'add-pipeline';
+	const [pipelineForm] = Form.useForm<PipelineData>();
+
+	return (
+		<AddNewPipeline
+			isActionType={isActionType}
+			setActionType={setActionType}
+			selectedPipelineData={selectedPipelineData}
+			setShowSaveButton={jest.fn()}
+			setCurrPipelineData={jest.fn()}
+			currPipelineData={pipelineMockData}
+			form={pipelineForm}
+		/>
+	);
+}
+
 describe('PipelinePage container test', () => {
 	it('should render AddNewPipeline section', () => {
-		const setActionType = jest.fn();
-		const selectedPipelineData = pipelineMockData[0];
-		const isActionType = 'add-pipeline';
-
-		const { asFragment } = render(
-			<AddNewPipeline
-				isActionType={isActionType}
-				setActionType={setActionType}
-				selectedPipelineData={selectedPipelineData}
-				setShowSaveButton={jest.fn()}
-				setCurrPipelineData={jest.fn()}
-				currPipelineData={pipelineMockData}
-			/>,
-		);
+		const { asFragment } = render(<AddNewPipelineWrapper />);
 		expect(asFragment()).toMatchSnapshot();
 	});
 });

frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx

@@ -1,4 +1,5 @@
 /* eslint-disable sonarjs/no-duplicate-string */
+import { screen } from '@testing-library/react';
 import { findByText, fireEvent, render, waitFor } from 'tests/test-utils';
 
 import { pipelineApiResponseMockData } from '../mocks/pipeline';
@@ -243,4 +244,34 @@ describe('PipelinePage container test', () => {
 		expect(saveBtn).toBeInTheDocument();
 		await fireEvent.click(saveBtn);
 	});
+
+	it('should have populated form fields when edit pipeline is clicked', async () => {
+		render(
+			<PipelineListsView
+				setActionType={jest.fn()}
+				isActionMode="editing-mode"
+				setActionMode={jest.fn()}
+				pipelineData={pipelineApiResponseMockData}
+				isActionType="edit-pipeline"
+				refetchPipelineLists={jest.fn()}
+			/>,
+		);
+
+		// content assertion
+		expect(document.querySelectorAll('[data-icon="edit"]').length).toBe(2);
+
+		// expand action
+		const expandIcon = document.querySelectorAll(
+			'.ant-table-row-expand-icon-cell > span[class*="anticon-right"]',
+		);
+		expect(expandIcon.length).toBe(2);
+		await fireEvent.click(expandIcon[0]);
+
+		const editBtn = document.querySelectorAll('[data-icon="edit"]');
+		// click on edit btn
+		await fireEvent.click(editBtn[0] as HTMLElement);
+
+		// to have length 2
+		expect(screen.queryAllByText('source = nginx').length).toBe(2);
+	});
 });

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/index.tsx

@@ -51,6 +51,8 @@ import { getUserOperatingSystem, UserOperatingSystem } from 'utils/getUserOS';
 import { popupContainer } from 'utils/selectPopupContainer';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
 import { selectStyle } from './config';
 import { PLACEHOLDER } from './constant';
 import ExampleQueriesRendererForLogs from './ExampleQueriesRendererForLogs';
@@ -85,6 +87,11 @@ function QueryBuilderSearch({
 
 	const [isEditingTag, setIsEditingTag] = useState(false);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const {
 		updateTag,
 		handleClearTag,
@@ -104,6 +111,7 @@ function QueryBuilderSearch({
 		exampleQueries,
 	} = useAutoComplete(
 		query,
+		dotMetricsEnabled,
 		whereClauseConfig,
 		isLogsExplorerPage,
 		isInfraMonitoring,
@@ -121,6 +129,7 @@ function QueryBuilderSearch({
 	const { sourceKeys, handleRemoveSourceKey } = useFetchKeysAndValues(
 		searchValue,
 		query,
+		dotMetricsEnabled,
 		searchKey,
 		isLogsExplorerPage,
 		isInfraMonitoring,

frontend/src/container/ResourceAttributesFilter/ResourceAttributesFilter.tsx

@@ -9,12 +9,15 @@ import {
 	convertMetricKeyToTrace,
 	getEnvironmentTagKeys,
 	getEnvironmentTagValues,
+	getResourceDeploymentKeys,
 } from 'hooks/useResourceAttribute/utils';
 import { ReactNode, useEffect, useMemo, useState } from 'react';
 import { SelectOption } from 'types/common/select';
 import { popupContainer } from 'utils/selectPopupContainer';
 import { v4 as uuid } from 'uuid';
 
+import { FeatureKeys } from '../../constants/features';
+import { useAppContext } from '../../providers/App/App';
 import QueryChip from './components/QueryChip';
 import { QueryChipItem, SearchContainer } from './styles';
 
@@ -39,24 +42,27 @@ function ResourceAttributesFilter({
 		SelectOption<string, string>[]
 	>([]);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
+	const resourceDeploymentKey = getResourceDeploymentKeys(dotMetricsEnabled);
+
 	const [selectedEnvironments, setSelectedEnvironments] = useState<string[]>([]);
 
 	const queriesExcludingEnvironment = useMemo(
-		() =>
-			queries.filter(
-				(query) => query.tagKey !== 'resource_deployment_environment',
-			),
-		[queries],
+		() => queries.filter((query) => query.tagKey !== resourceDeploymentKey),
+		[queries, resourceDeploymentKey],
 	);
 
 	const isEmpty = useMemo(
 		() => isResourceEmpty(queriesExcludingEnvironment, staging, selectedQuery),
 		[queriesExcludingEnvironment, selectedQuery, staging],
 	);
-
 	useEffect(() => {
 		const resourceDeploymentEnvironmentQuery = queries.filter(
-			(query) => query.tagKey === 'resource_deployment_environment',
+			(query) => query.tagKey === resourceDeploymentKey,
 		);
 
 		if (resourceDeploymentEnvironmentQuery?.length > 0) {
@@ -64,17 +70,17 @@ function ResourceAttributesFilter({
 		} else {
 			setSelectedEnvironments([]);
 		}
-	}, [queries]);
+	}, [queries, resourceDeploymentKey]);
 
 	useEffect(() => {
-		getEnvironmentTagKeys().then((tagKeys) => {
+		getEnvironmentTagKeys(dotMetricsEnabled).then((tagKeys) => {
 			if (tagKeys && Array.isArray(tagKeys) && tagKeys.length > 0) {
-				getEnvironmentTagValues().then((tagValues) => {
+				getEnvironmentTagValues(dotMetricsEnabled).then((tagValues) => {
 					setEnvironments(tagValues);
 				});
 			}
 		});
-	}, []);
+	}, [dotMetricsEnabled]);
 
 	return (
 		<div className="resourceAttributesFilter-container">

frontend/src/container/ResourceAttributesFilter/components/QueryChip/QueryChip.tsx

@@ -1,5 +1,10 @@
-import { convertMetricKeyToTrace } from 'hooks/useResourceAttribute/utils';
+import {
+	convertMetricKeyToTrace,
+	getResourceDeploymentKeys,
+} from 'hooks/useResourceAttribute/utils';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
 import { QueryChipContainer, QueryChipItem } from '../../styles';
 import { IQueryChipProps } from './types';
 
@@ -8,12 +13,17 @@ function QueryChip({ queryData, onClose }: IQueryChipProps): JSX.Element {
 		onClose(queryData.id);
 	};
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	return (
 		<QueryChipContainer>
 			<QueryChipItem>{convertMetricKeyToTrace(queryData.tagKey)}</QueryChipItem>
 			<QueryChipItem>{queryData.operator}</QueryChipItem>
 			<QueryChipItem
-				closable={queryData.tagKey !== 'resource_deployment_environment'}
+				closable={queryData.tagKey !== getResourceDeploymentKeys(dotMetricsEnabled)}
 				onClose={onCloseHandler}
 			>
 				{queryData.tagValue.join(', ')}

frontend/src/container/ServiceApplication/ServiceMetrics/ServiceMetricsApplication.tsx

@@ -3,6 +3,8 @@ import { useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { ServiceMetricsProps } from '../types';
 import { getQueryRangeRequestData } from '../utils';
 import ServiceMetricTable from './ServiceMetricTable';
@@ -15,6 +17,11 @@ function ServiceMetricsApplication({
 		GlobalReducer
 	>((state) => state.globalTime);
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const queryRangeRequestData = useMemo(
 		() =>
 			getQueryRangeRequestData({
@@ -22,8 +29,15 @@ function ServiceMetricsApplication({
 				minTime,
 				maxTime,
 				globalSelectedInterval,
+				dotMetricsEnabled,
 			}),
-		[globalSelectedInterval, maxTime, minTime, topLevelOperations],
+		[
+			globalSelectedInterval,
+			maxTime,
+			minTime,
+			topLevelOperations,
+			dotMetricsEnabled,
+		],
 	);
 	return (
 		<ServiceMetricTable

frontend/src/container/ServiceApplication/ServiceMetrics/ServiceMetricsQuery.ts

@@ -19,11 +19,14 @@ import {
 
 export const serviceMetricsQuery = (
 	topLevelOperation: [keyof ServiceDataProps, string[]],
+	dotMetricsEnabled: boolean,
 ): QueryBuilderData => {
 	const p99AutoCompleteData: BaseAutocompleteData = {
 		dataType: DataTypes.Float64,
 		isColumn: true,
-		key: WidgetKeys.Signoz_latency_bucket,
+		key: dotMetricsEnabled
+			? WidgetKeys.Signoz_latency_bucket
+			: WidgetKeys.Signoz_latency_bucket_norm,
 		type: '',
 	};
 
@@ -54,7 +57,9 @@ export const serviceMetricsQuery = (
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -79,7 +84,9 @@ export const serviceMetricsQuery = (
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -90,7 +97,7 @@ export const serviceMetricsQuery = (
 			key: {
 				dataType: DataTypes.Int64,
 				isColumn: false,
-				key: WidgetKeys.StatusCode,
+				key: dotMetricsEnabled ? WidgetKeys.StatusCode : WidgetKeys.StatusCodeNorm,
 				type: MetricsType.Tag,
 			},
 			op: OPERATORS.IN,
@@ -115,7 +122,9 @@ export const serviceMetricsQuery = (
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -140,7 +149,9 @@ export const serviceMetricsQuery = (
 			key: {
 				dataType: DataTypes.String,
 				isColumn: false,
-				key: WidgetKeys.Service_name,
+				key: dotMetricsEnabled
+					? WidgetKeys.Service_name
+					: WidgetKeys.Service_name_norm,
 				type: MetricsType.Resource,
 			},
 			op: OPERATORS.IN,
@@ -195,7 +206,9 @@ export const serviceMetricsQuery = (
 		{
 			dataType: DataTypes.String,
 			isColumn: false,
-			key: WidgetKeys.Service_name,
+			key: dotMetricsEnabled
+				? WidgetKeys.Service_name
+				: WidgetKeys.Service_name_norm,
 			type: MetricsType.Tag,
 		},
 	];

frontend/src/container/ServiceApplication/ServiceTraces/index.tsx

@@ -5,7 +5,10 @@ import { SKIP_ONBOARDING } from 'constants/onboarding';
 import useErrorNotification from 'hooks/useErrorNotification';
 import { useQueryService } from 'hooks/useQueryService';
 import useResourceAttribute from 'hooks/useResourceAttribute';
-import { convertRawQueriesToTraceSelectedTags } from 'hooks/useResourceAttribute/utils';
+import {
+	convertRawQueriesToTraceSelectedTags,
+	getResourceDeploymentKeys,
+} from 'hooks/useResourceAttribute/utils';
 import { isUndefined } from 'lodash-es';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { useSelector } from 'react-redux';
@@ -13,6 +16,8 @@ import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { Tags } from 'types/reducer/trace';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import SkipOnBoardingModal from '../SkipOnBoardModal';
 import ServiceTraceTable from './ServiceTracesTable';
 
@@ -34,6 +39,11 @@ function ServiceTraces(): JSX.Element {
 		selectedTags,
 	});
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	useErrorNotification(error);
 
 	const services = data || [];
@@ -51,7 +61,7 @@ function ServiceTraces(): JSX.Element {
 	useEffect(() => {
 		if (!logEventCalledRef.current && !isUndefined(data)) {
 			const selectedEnvironments = queries.find(
-				(val) => val.tagKey === 'resource_deployment_environment',
+				(val) => val.tagKey === getResourceDeploymentKeys(dotMetricsEnabled),
 			)?.tagValue;
 
 			const rps = data.reduce((total, service) => total + service.callRate, 0);

frontend/src/container/ServiceApplication/types.ts

@@ -29,6 +29,7 @@ export interface GetQueryRangeRequestDataProps {
 	maxTime: number;
 	minTime: number;
 	globalSelectedInterval: Time | TimeV2 | CustomTimeType;
+	dotMetricsEnabled: boolean;
 }
 
 export interface GetServiceListFromQueryProps {

frontend/src/container/ServiceApplication/utils.ts

@@ -28,6 +28,7 @@ export const getQueryRangeRequestData = ({
 	maxTime,
 	minTime,
 	globalSelectedInterval,
+	dotMetricsEnabled,
 }: GetQueryRangeRequestDataProps): GetQueryResultsProps[] => {
 	const requestData: GetQueryResultsProps[] = [];
 	topLevelOperations.forEach((operation) => {
@@ -35,7 +36,7 @@ export const getQueryRangeRequestData = ({
 			query: {
 				queryType: EQueryType.QUERY_BUILDER,
 				promql: [],
-				builder: serviceMetricsQuery(operation),
+				builder: serviceMetricsQuery(operation, dotMetricsEnabled),
 				clickhouse_sql: [],
 				id: uuid(),
 			},

frontend/src/hooks/infraMonitoring/useGetK8sClustersList.ts

@@ -17,6 +17,7 @@ type UseGetK8sClustersList = (
 	>,
 
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sClustersListResponse> | ErrorResponse,
 	Error
@@ -28,6 +29,7 @@ export const useGetK8sClustersList: UseGetK8sClustersList = (
 	options,
 
 	headers,
+	dotMetricsEnabled?: boolean,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -45,7 +47,8 @@ export const useGetK8sClustersList: UseGetK8sClustersList = (
 		SuccessResponse<K8sClustersListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sClustersList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sClustersList(requestData, signal, headers, dotMetricsEnabled),
 
 		...options,
 

frontend/src/hooks/infraMonitoring/useGetK8sDaemonSetsList.ts

@@ -17,6 +17,7 @@ type UseGetK8sDaemonSetsList = (
 	>,
 
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sDaemonSetsListResponse> | ErrorResponse,
 	Error
@@ -28,6 +29,7 @@ export const useGetK8sDaemonSetsList: UseGetK8sDaemonSetsList = (
 	options,
 
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -45,7 +47,8 @@ export const useGetK8sDaemonSetsList: UseGetK8sDaemonSetsList = (
 		SuccessResponse<K8sDaemonSetsListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sDaemonSetsList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sDaemonSetsList(requestData, signal, headers, dotMetricsEnabled),
 
 		...options,
 

frontend/src/hooks/infraMonitoring/useGetK8sDeploymentsList.ts

@@ -15,6 +15,7 @@ type UseGetK8sDeploymentsList = (
 		Error
 	>,
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sDeploymentsListResponse> | ErrorResponse,
 	Error
@@ -24,6 +25,7 @@ export const useGetK8sDeploymentsList: UseGetK8sDeploymentsList = (
 	requestData,
 	options,
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -41,7 +43,8 @@ export const useGetK8sDeploymentsList: UseGetK8sDeploymentsList = (
 		SuccessResponse<K8sDeploymentsListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sDeploymentsList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sDeploymentsList(requestData, signal, headers, dotMetricsEnabled),
 		...options,
 		queryKey,
 	});

frontend/src/hooks/infraMonitoring/useGetK8sJobsList.ts

@@ -17,6 +17,7 @@ type UseGetK8sJobsList = (
 	>,
 
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sJobsListResponse> | ErrorResponse,
 	Error
@@ -28,6 +29,7 @@ export const useGetK8sJobsList: UseGetK8sJobsList = (
 	options,
 
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -42,7 +44,8 @@ export const useGetK8sJobsList: UseGetK8sJobsList = (
 	}, [options?.queryKey, requestData]);
 
 	return useQuery<SuccessResponse<K8sJobsListResponse> | ErrorResponse, Error>({
-		queryFn: ({ signal }) => getK8sJobsList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sJobsList(requestData, signal, headers, dotMetricsEnabled),
 
 		...options,
 

frontend/src/hooks/infraMonitoring/useGetK8sNamespacesList.ts

@@ -15,6 +15,7 @@ type UseGetK8sNamespacesList = (
 		Error
 	>,
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sNamespacesListResponse> | ErrorResponse,
 	Error
@@ -24,6 +25,7 @@ export const useGetK8sNamespacesList: UseGetK8sNamespacesList = (
 	requestData,
 	options,
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -41,7 +43,8 @@ export const useGetK8sNamespacesList: UseGetK8sNamespacesList = (
 		SuccessResponse<K8sNamespacesListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sNamespacesList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sNamespacesList(requestData, signal, headers, dotMetricsEnabled),
 		...options,
 		queryKey,
 	});

frontend/src/hooks/infraMonitoring/useGetK8sNodesList.ts

@@ -15,6 +15,7 @@ type UseGetK8sNodesList = (
 		Error
 	>,
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sNodesListResponse> | ErrorResponse,
 	Error
@@ -24,6 +25,7 @@ export const useGetK8sNodesList: UseGetK8sNodesList = (
 	requestData,
 	options,
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -38,7 +40,8 @@ export const useGetK8sNodesList: UseGetK8sNodesList = (
 	}, [options?.queryKey, requestData]);
 
 	return useQuery<SuccessResponse<K8sNodesListResponse> | ErrorResponse, Error>({
-		queryFn: ({ signal }) => getK8sNodesList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sNodesList(requestData, signal, headers, dotMetricsEnabled),
 		...options,
 		queryKey,
 	});

frontend/src/hooks/infraMonitoring/useGetK8sPodsList.ts

@@ -15,6 +15,7 @@ type UseGetK8sPodsList = (
 		Error
 	>,
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sPodsListResponse> | ErrorResponse,
 	Error
@@ -24,6 +25,7 @@ export const useGetK8sPodsList: UseGetK8sPodsList = (
 	requestData,
 	options,
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -38,7 +40,8 @@ export const useGetK8sPodsList: UseGetK8sPodsList = (
 	}, [options?.queryKey, requestData]);
 
 	return useQuery<SuccessResponse<K8sPodsListResponse> | ErrorResponse, Error>({
-		queryFn: ({ signal }) => getK8sPodsList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sPodsList(requestData, signal, headers, dotMetricsEnabled),
 		...options,
 		queryKey,
 	});

frontend/src/hooks/infraMonitoring/useGetK8sStatefulSetsList.ts

@@ -17,6 +17,7 @@ type UseGetK8sStatefulSetsList = (
 	>,
 
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sStatefulSetsListResponse> | ErrorResponse,
 	Error
@@ -28,6 +29,7 @@ export const useGetK8sStatefulSetsList: UseGetK8sStatefulSetsList = (
 	options,
 
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -45,7 +47,8 @@ export const useGetK8sStatefulSetsList: UseGetK8sStatefulSetsList = (
 		SuccessResponse<K8sStatefulSetsListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sStatefulSetsList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sStatefulSetsList(requestData, signal, headers, dotMetricsEnabled),
 
 		...options,
 

frontend/src/hooks/infraMonitoring/useGetK8sVolumesList.ts

@@ -15,6 +15,7 @@ type UseGetK8sVolumesList = (
 		Error
 	>,
 	headers?: Record<string, string>,
+	dotMetricsEnabled?: boolean,
 ) => UseQueryResult<
 	SuccessResponse<K8sVolumesListResponse> | ErrorResponse,
 	Error
@@ -24,6 +25,7 @@ export const useGetK8sVolumesList: UseGetK8sVolumesList = (
 	requestData,
 	options,
 	headers,
+	dotMetricsEnabled,
 ) => {
 	const queryKey = useMemo(() => {
 		if (options?.queryKey && Array.isArray(options.queryKey)) {
@@ -41,7 +43,8 @@ export const useGetK8sVolumesList: UseGetK8sVolumesList = (
 		SuccessResponse<K8sVolumesListResponse> | ErrorResponse,
 		Error
 	>({
-		queryFn: ({ signal }) => getK8sVolumesList(requestData, signal, headers),
+		queryFn: ({ signal }) =>
+			getK8sVolumesList(requestData, signal, headers, dotMetricsEnabled),
 		...options,
 		queryKey,
 	});

frontend/src/hooks/queryBuilder/useAutoComplete.ts

@@ -27,6 +27,7 @@ export type WhereClauseConfig = {
 
 export const useAutoComplete = (
 	query: IBuilderQuery,
+	dotMetricsEnabled: boolean,
 	whereClauseConfig?: WhereClauseConfig,
 	shouldUseSuggestions?: boolean,
 	isInfraMonitoring?: boolean,
@@ -39,6 +40,7 @@ export const useAutoComplete = (
 	const { keys, results, isFetching, exampleQueries } = useFetchKeysAndValues(
 		searchValue,
 		query,
+		dotMetricsEnabled,
 		searchKey,
 		shouldUseSuggestions,
 		isInfraMonitoring,

frontend/src/hooks/queryBuilder/useFetchKeysAndValues.ts

@@ -4,8 +4,8 @@ import { getAttributesValues } from 'api/queryBuilder/getAttributesValues';
 import { DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY } from 'constants/queryBuilder';
 import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
 import {
+	GetK8sEntityToAggregateAttribute,
 	K8sCategory,
-	K8sEntityToAggregateAttributeMapping,
 } from 'container/InfraMonitoringK8s/constants';
 import {
 	getRemovePrefixFromKey,
@@ -50,6 +50,7 @@ type IuseFetchKeysAndValues = {
 export const useFetchKeysAndValues = (
 	searchValue: string,
 	query: IBuilderQuery,
+	dotMetricsEnabled: boolean,
 	searchKey: string,
 	shouldUseSuggestions?: boolean,
 	isInfraMonitoring?: boolean,
@@ -123,7 +124,7 @@ export const useFetchKeysAndValues = (
 			aggregateOperator: query.aggregateOperator,
 			aggregateAttribute:
 				isInfraMonitoring && entity
-					? K8sEntityToAggregateAttributeMapping[entity]
+					? GetK8sEntityToAggregateAttribute(entity, dotMetricsEnabled)
 					: query.aggregateAttribute.key,
 			tagType: query.aggregateAttribute.type ?? null,
 		},
@@ -219,7 +220,7 @@ export const useFetchKeysAndValues = (
 					aggregateOperator: 'noop',
 					dataSource: query.dataSource,
 					aggregateAttribute:
-						K8sEntityToAggregateAttributeMapping[entity] ||
+						GetK8sEntityToAggregateAttribute(entity, dotMetricsEnabled) ||
 						query.aggregateAttribute.key,
 					attributeKey: filterAttributeKey?.key ?? tagKey,
 					filterAttributeKeyDataType:

frontend/src/hooks/useResourceAttribute/ResourceProvider.tsx

@@ -7,6 +7,8 @@ import { encode } from 'js-base64';
 import { ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 
+import { FeatureKeys } from '../../constants/features';
+import { useAppContext } from '../../providers/App/App';
 import { whilelistedKeys } from './config';
 import { ResourceContext } from './context';
 import { ResourceAttributesFilterMachine } from './machine';
@@ -18,6 +20,7 @@ import {
 import {
 	createQuery,
 	getResourceAttributeQueriesFromURL,
+	getResourceDeploymentKeys,
 	GetTagKeys,
 	GetTagValues,
 	mappingWithRoutesAndKeys,
@@ -53,6 +56,11 @@ function ResourceProvider({ children }: Props): JSX.Element {
 		}
 	};
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const dispatchQueries = useCallback(
 		(queries: IResourceAttribute[]): void => {
 			urlQuery.set(
@@ -70,7 +78,7 @@ function ResourceProvider({ children }: Props): JSX.Element {
 		actions: {
 			onSelectTagKey: () => {
 				handleLoading(true);
-				GetTagKeys()
+				GetTagKeys(dotMetricsEnabled)
 					.then((tagKeys) => {
 						const options = mappingWithRoutesAndKeys(pathname, tagKeys);
 
@@ -141,10 +149,10 @@ function ResourceProvider({ children }: Props): JSX.Element {
 
 	const handleEnvironmentChange = useCallback(
 		(environments: string[]): void => {
-			const staging = ['resource_deployment_environment', 'IN'];
+			const staging = [getResourceDeploymentKeys(dotMetricsEnabled), 'IN'];
 
 			const queriesCopy = queries.filter(
-				(query) => query.tagKey !== 'resource_deployment_environment',
+				(query) => query.tagKey !== getResourceDeploymentKeys(dotMetricsEnabled),
 			);
 
 			if (environments && Array.isArray(environments) && environments.length > 0) {
@@ -159,7 +167,7 @@ function ResourceProvider({ children }: Props): JSX.Element {
 
 			send('RESET');
 		},
-		[dispatchQueries, queries, send],
+		[dispatchQueries, dotMetricsEnabled, queries, send],
 	);
 
 	const handleClose = useCallback(

frontend/src/hooks/useResourceAttribute/__tests__/useResourceAttribute.test.tsx

@@ -1,10 +1,14 @@
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { createMemoryHistory } from 'history';
+import { AppProvider } from 'providers/App/App';
+import { QueryClient, QueryClientProvider } from 'react-query';
 import { Router } from 'react-router-dom';
 
 import ResourceProvider from '../ResourceProvider';
 import useResourceAttribute from '../useResourceAttribute';
 
+const queryClient = new QueryClient();
+
 jest.mock('hooks/useSafeNavigate', () => ({
 	useSafeNavigate: (): any => ({
 		safeNavigate: jest.fn(),
@@ -17,9 +21,13 @@ describe('useResourceAttribute component hook', () => {
 			initialEntries: ['/inital-url?tab=overview'],
 		});
 		const wrapper = ({ children }: { children: any }): JSX.Element => (
-			<Router history={history}>
-				<ResourceProvider>{children}</ResourceProvider>
-			</Router>
+			<QueryClientProvider client={queryClient}>
+				<AppProvider>
+					<Router history={history}>
+						<ResourceProvider>{children}</ResourceProvider>
+					</Router>
+				</AppProvider>
+			</QueryClientProvider>
 		);
 		const { result } = renderHook(() => useResourceAttribute(), { wrapper });
 

frontend/src/hooks/useResourceAttribute/utils.ts

@@ -146,7 +146,17 @@ export const OperatorSchema: IOption[] = OperatorConversions.map(
 	}),
 );
 
-export const GetTagKeys = async (): Promise<IOption[]> => {
+export const getResourceDeploymentKeys = (
+	dotMetricsEnabled: boolean,
+): string => {
+	if (dotMetricsEnabled) return 'resource_deployment.environment';
+	return 'resource_deployment_environment';
+};
+
+export const GetTagKeys = async (
+	dotMetricsEnabled: boolean,
+): Promise<IOption[]> => {
+	const resourceDeploymentKey = getResourceDeploymentKeys(dotMetricsEnabled);
 	const { payload } = await getResourceAttributesTagKeys({
 		metricName: 'signoz_calls_total',
 		match: 'resource_',
@@ -159,17 +169,19 @@ export const GetTagKeys = async (): Promise<IOption[]> => {
 		payload.data.attributeKeys?.map((attributeKey) => attributeKey.key) || [];
 
 	return keys
-		.filter((tagKey: string) => tagKey !== 'resource_deployment_environment')
+		.filter((tagKey: string) => tagKey !== resourceDeploymentKey)
 		.map((tagKey: string) => ({
 			label: convertMetricKeyToTrace(tagKey),
 			value: tagKey,
 		}));
 };
 
-export const getEnvironmentTagKeys = async (): Promise<IOption[]> => {
+export const getEnvironmentTagKeys = async (
+	dotMetricsEnabled: boolean,
+): Promise<IOption[]> => {
 	const { payload } = await getResourceAttributesTagKeys({
 		metricName: 'signoz_calls_total',
-		match: 'resource_deployment_environment',
+		match: getResourceDeploymentKeys(dotMetricsEnabled),
 	});
 	if (!payload || !payload?.data) {
 		return [];
@@ -182,9 +194,11 @@ export const getEnvironmentTagKeys = async (): Promise<IOption[]> => {
 	}));
 };
 
-export const getEnvironmentTagValues = async (): Promise<IOption[]> => {
+export const getEnvironmentTagValues = async (
+	dotMetricsEnabled: boolean,
+): Promise<IOption[]> => {
 	const { payload } = await getResourceAttributesTagValues({
-		tagKey: 'resource_deployment_environment',
+		tagKey: getResourceDeploymentKeys(dotMetricsEnabled),
 		metricName: 'signoz_calls_total',
 	});
 

frontend/src/pages/MessagingQueues/MQDetails/MetricPage/MetricColumnGraphs.tsx

@@ -4,22 +4,24 @@ import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useTranslation } from 'react-i18next';
 import { Widgets } from 'types/api/dashboard/getAll';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
 import MetricPageGridGraph from './MetricPageGraph';
 import {
-	averageRequestLatencyWidgetData,
-	brokerCountWidgetData,
-	brokerNetworkThroughputWidgetData,
-	bytesConsumedWidgetData,
-	consumerFetchRateWidgetData,
-	consumerGroupMemberWidgetData,
-	consumerLagByGroupWidgetData,
-	consumerOffsetWidgetData,
-	ioWaitTimeWidgetData,
-	kafkaProducerByteRateWidgetData,
-	messagesConsumedWidgetData,
-	producerFetchRequestPurgatoryWidgetData,
-	requestResponseWidgetData,
-	requestTimesWidgetData,
+	getAverageRequestLatencyWidgetData,
+	getBrokerCountWidgetData,
+	getBrokerNetworkThroughputWidgetData,
+	getBytesConsumedWidgetData,
+	getConsumerFetchRateWidgetData,
+	getConsumerGroupMemberWidgetData,
+	getConsumerLagByGroupWidgetData,
+	getConsumerOffsetWidgetData,
+	getIoWaitTimeWidgetData,
+	getKafkaProducerByteRateWidgetData,
+	getMessagesConsumedWidgetData,
+	getProducerFetchRequestPurgatoryWidgetData,
+	getRequestResponseWidgetData,
+	getRequestTimesWidgetData,
 } from './MetricPageUtil';
 
 interface MetricSectionProps {
@@ -71,15 +73,20 @@ function MetricColumnGraphs({
 }): JSX.Element {
 	const { t } = useTranslation('messagingQueues');
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const metricsData = [
 		{
 			title: t('metricGraphCategory.brokerMetrics.title'),
 			description: t('metricGraphCategory.brokerMetrics.description'),
 			graphCount: [
-				brokerCountWidgetData,
-				requestTimesWidgetData,
-				producerFetchRequestPurgatoryWidgetData,
-				brokerNetworkThroughputWidgetData,
+				getBrokerCountWidgetData(dotMetricsEnabled),
+				getRequestTimesWidgetData(dotMetricsEnabled),
+				getProducerFetchRequestPurgatoryWidgetData(dotMetricsEnabled),
+				getBrokerNetworkThroughputWidgetData(dotMetricsEnabled),
 			],
 			id: 'broker-metrics',
 		},
@@ -87,11 +94,11 @@ function MetricColumnGraphs({
 			title: t('metricGraphCategory.producerMetrics.title'),
 			description: t('metricGraphCategory.producerMetrics.description'),
 			graphCount: [
-				ioWaitTimeWidgetData,
-				requestResponseWidgetData,
-				averageRequestLatencyWidgetData,
-				kafkaProducerByteRateWidgetData,
-				bytesConsumedWidgetData,
+				getIoWaitTimeWidgetData(dotMetricsEnabled),
+				getRequestResponseWidgetData(dotMetricsEnabled),
+				getAverageRequestLatencyWidgetData(dotMetricsEnabled),
+				getKafkaProducerByteRateWidgetData(dotMetricsEnabled),
+				getBytesConsumedWidgetData(dotMetricsEnabled),
 			],
 			id: 'producer-metrics',
 		},
@@ -99,11 +106,11 @@ function MetricColumnGraphs({
 			title: t('metricGraphCategory.consumerMetrics.title'),
 			description: t('metricGraphCategory.consumerMetrics.description'),
 			graphCount: [
-				consumerOffsetWidgetData,
-				consumerGroupMemberWidgetData,
-				consumerLagByGroupWidgetData,
-				consumerFetchRateWidgetData,
-				messagesConsumedWidgetData,
+				getConsumerOffsetWidgetData(dotMetricsEnabled),
+				getConsumerGroupMemberWidgetData(dotMetricsEnabled),
+				getConsumerLagByGroupWidgetData(dotMetricsEnabled),
+				getConsumerFetchRateWidgetData(dotMetricsEnabled),
+				getMessagesConsumedWidgetData(dotMetricsEnabled),
 			],
 			id: 'consumer-metrics',
 		},

frontend/src/pages/MessagingQueues/MQDetails/MetricPage/MetricPage.tsx

@@ -10,17 +10,19 @@ import { useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Widgets } from 'types/api/dashboard/getAll';
 
+import { FeatureKeys } from '../../../../constants/features';
+import { useAppContext } from '../../../../providers/App/App';
 import MetricColumnGraphs from './MetricColumnGraphs';
 import MetricPageGridGraph from './MetricPageGraph';
 import {
-	cpuRecentUtilizationWidgetData,
-	currentOffsetPartitionWidgetData,
-	insyncReplicasWidgetData,
-	jvmGcCollectionsElapsedWidgetData,
-	jvmGCCountWidgetData,
-	jvmMemoryHeapWidgetData,
-	oldestOffsetWidgetData,
-	partitionCountPerTopicWidgetData,
+	getCpuRecentUtilizationWidgetData,
+	getCurrentOffsetPartitionWidgetData,
+	getInsyncReplicasWidgetData,
+	getJvmGcCollectionsElapsedWidgetData,
+	getJvmGCCountWidgetData,
+	getJvmMemoryHeapWidgetData,
+	getOldestOffsetWidgetData,
+	getPartitionCountPerTopicWidgetData,
 } from './MetricPageUtil';
 
 interface CollapsibleMetricSectionProps {
@@ -95,6 +97,11 @@ function MetricPage(): JSX.Element {
 		}));
 	};
 
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const { t } = useTranslation('messagingQueues');
 
 	const metricSections = [
@@ -103,10 +110,10 @@ function MetricPage(): JSX.Element {
 			title: t('metricGraphCategory.brokerJVMMetrics.title'),
 			description: t('metricGraphCategory.brokerJVMMetrics.description'),
 			graphCount: [
-				jvmGCCountWidgetData,
-				jvmGcCollectionsElapsedWidgetData,
-				cpuRecentUtilizationWidgetData,
-				jvmMemoryHeapWidgetData,
+				getJvmGCCountWidgetData(dotMetricsEnabled),
+				getJvmGcCollectionsElapsedWidgetData(dotMetricsEnabled),
+				getCpuRecentUtilizationWidgetData(dotMetricsEnabled),
+				getJvmMemoryHeapWidgetData(dotMetricsEnabled),
 			],
 		},
 		{
@@ -114,10 +121,10 @@ function MetricPage(): JSX.Element {
 			title: t('metricGraphCategory.partitionMetrics.title'),
 			description: t('metricGraphCategory.partitionMetrics.description'),
 			graphCount: [
-				partitionCountPerTopicWidgetData,
-				currentOffsetPartitionWidgetData,
-				oldestOffsetWidgetData,
-				insyncReplicasWidgetData,
+				getPartitionCountPerTopicWidgetData(dotMetricsEnabled),
+				getCurrentOffsetPartitionWidgetData(dotMetricsEnabled),
+				getOldestOffsetWidgetData(dotMetricsEnabled),
+				getInsyncReplicasWidgetData(dotMetricsEnabled),
 			],
 		},
 	];

frontend/src/pages/MessagingQueues/MQGraph/MQConfigOptions.tsx

@@ -13,6 +13,8 @@ import { useState } from 'react';
 import { useHistory, useLocation } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
 import { useGetAllConfigOptions } from './useGetAllConfigOptions';
 
 type ConfigOptionType = 'group' | 'topic' | 'partition';
@@ -38,11 +40,19 @@ const useConfigOptions = (
 	isFetching: boolean;
 	options: DefaultOptionType[];
 } => {
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
 	const [searchText, setSearchText] = useState<string>('');
-	const { isFetching, options } = useGetAllConfigOptions({
-		attributeKey: type,
-		searchText,
-	});
+	const { isFetching, options } = useGetAllConfigOptions(
+		{
+			attributeKey: type,
+			searchText,
+		},
+		dotMetricsEnabled,
+	);
 	const handleDebouncedSearch = useDebouncedFn((searchText): void => {
 		setSearchText(searchText as string);
 	}, 500);