Merge branch 'main' into SIG-7395-1

.gitignore

@@ -66,6 +66,7 @@ e2e/.auth
 # go
 vendor/
 **/main/**
+__debug_bin**
 
 # git-town
 .git-branches.toml

conf/example.yaml

@@ -207,3 +207,11 @@ emailing:
       key_file_path:
       # The path to the certificate file.
       cert_file_path:
+
+##################### Sharder (experimental) #####################
+sharder:
+  # Specifies the sharder provider to use.
+  provider: noop
+  single:
+    # The org id to which this instance belongs to.
+    org_id: org_id

deploy/docker-swarm/docker-compose.ha.yaml

@@ -174,7 +174,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.85.2
+    image: signoz/signoz:v0.85.3
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker-swarm/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.85.2
+    image: signoz/signoz:v0.85.3
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker/docker-compose.ha.yaml

@@ -177,7 +177,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.85.2}
+    image: signoz/signoz:${VERSION:-v0.85.3}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

deploy/docker/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.85.2}
+    image: signoz/signoz:${VERSION:-v0.85.3}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

ee/licensing/httplicensing/provider.go

@@ -5,10 +5,13 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/SigNoz/signoz/ee/query-service/constants"
+
 	"github.com/SigNoz/signoz/ee/licensing/licensingstore/sqllicensingstore"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/licensetypes"
@@ -22,19 +25,27 @@ type provider struct {
 	zeus      zeus.Zeus
 	config    licensing.Config
 	settings  factory.ScopedProviderSettings
+	orgGetter organization.Getter
 	stopChan  chan struct{}
 }
 
-func NewProviderFactory(store sqlstore.SQLStore, zeus zeus.Zeus) factory.ProviderFactory[licensing.Licensing, licensing.Config] {
+func NewProviderFactory(store sqlstore.SQLStore, zeus zeus.Zeus, orgGetter organization.Getter) factory.ProviderFactory[licensing.Licensing, licensing.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("http"), func(ctx context.Context, providerSettings factory.ProviderSettings, config licensing.Config) (licensing.Licensing, error) {
-		return New(ctx, providerSettings, config, store, zeus)
+		return New(ctx, providerSettings, config, store, zeus, orgGetter)
 	})
 }
 
-func New(ctx context.Context, ps factory.ProviderSettings, config licensing.Config, sqlstore sqlstore.SQLStore, zeus zeus.Zeus) (licensing.Licensing, error) {
+func New(ctx context.Context, ps factory.ProviderSettings, config licensing.Config, sqlstore sqlstore.SQLStore, zeus zeus.Zeus, orgGetter organization.Getter) (licensing.Licensing, error) {
 	settings := factory.NewScopedProviderSettings(ps, "github.com/SigNoz/signoz/ee/licensing/httplicensing")
 	licensestore := sqllicensingstore.New(sqlstore)
-	return &provider{store: licensestore, zeus: zeus, config: config, settings: settings, stopChan: make(chan struct{})}, nil
+	return &provider{
+		store:     licensestore,
+		zeus:      zeus,
+		config:    config,
+		settings:  settings,
+		orgGetter: orgGetter,
+		stopChan:  make(chan struct{}),
+	}, nil
 }
 
 func (provider *provider) Start(ctx context.Context) error {
@@ -66,13 +77,13 @@ func (provider *provider) Stop(ctx context.Context) error {
 }
 
 func (provider *provider) Validate(ctx context.Context) error {
-	organizations, err := provider.store.ListOrganizations(ctx)
+	organizations, err := provider.orgGetter.ListByOwnedKeyRange(ctx)
 	if err != nil {
 		return err
 	}
 
-	for _, organizationID := range organizations {
+	for _, organization := range organizations {
-		err := provider.Refresh(ctx, organizationID)
+		err := provider.Refresh(ctx, organization.ID)
 		if err != nil {
 			return err
 		}
@@ -167,6 +178,11 @@ func (provider *provider) Refresh(ctx context.Context, organizationID valuer.UUI
 		return err
 	}
 
+	err = provider.InitFeatures(ctx, activeLicense.Features)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -251,6 +267,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/licensing/licensingstore/sqllicensingstore/store.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/licensetypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -82,31 +81,6 @@ func (store *store) Update(ctx context.Context, organizationID valuer.UUID, stor
 	return nil
 }
 
-func (store *store) ListOrganizations(ctx context.Context) ([]valuer.UUID, error) {
-	orgIDStrs := make([]string, 0)
-	err := store.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(new(types.Organization)).
-		Column("id").
-		Scan(ctx, &orgIDStrs)
-	if err != nil {
-		return nil, err
-	}
-
-	orgIDs := make([]valuer.UUID, len(orgIDStrs))
-	for idx, orgIDStr := range orgIDStrs {
-		orgID, err := valuer.NewUUID(orgIDStr)
-		if err != nil {
-			return nil, err
-		}
-		orgIDs[idx] = orgID
-	}
-
-	return orgIDs, nil
-
-}
-
 func (store *store) CreateFeature(ctx context.Context, storableFeature *featuretypes.StorableFeature) error {
 	_, err := store.
 		sqlstore.

ee/query-service/app/api/api.go

@@ -96,13 +96,7 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// note: add ee override methods first
 
 	// routes available only in ee version
-
 	router.HandleFunc("/api/v1/featureFlags", am.OpenAccess(ah.getFeatureFlags)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/loginPrecheck", am.OpenAccess(ah.Signoz.Handlers.User.LoginPrecheck)).Methods(http.MethodGet)
-
-	// invite
-	router.HandleFunc("/api/v1/invite/{token}", am.OpenAccess(ah.Signoz.Handlers.User.GetInvite)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/invite/accept", am.OpenAccess(ah.Signoz.Handlers.User.AcceptInvite)).Methods(http.MethodPost)
 
 	// paid plans specific routes
 	router.HandleFunc("/api/v1/complete/saml", am.OpenAccess(ah.receiveSAML)).Methods(http.MethodPost)
@@ -114,9 +108,6 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/billing", am.AdminAccess(ah.getBilling)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/portal", am.AdminAccess(ah.LicensingAPI.Portal)).Methods(http.MethodPost)
 
-	router.HandleFunc("/api/v1/dashboards/{uuid}/lock", am.EditAccess(ah.lockDashboard)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/dashboards/{uuid}/unlock", am.EditAccess(ah.unlockDashboard)).Methods(http.MethodPut)
-
 	// v3
 	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Activate)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Refresh)).Methods(http.MethodPut)

ee/query-service/app/api/dashboard.go

@@ -1,62 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/gorilla/mux"
-)
-
-func (ah *APIHandler) lockDashboard(w http.ResponseWriter, r *http.Request) {
-	ah.lockUnlockDashboard(w, r, true)
-}
-
-func (ah *APIHandler) unlockDashboard(w http.ResponseWriter, r *http.Request) {
-	ah.lockUnlockDashboard(w, r, false)
-}
-
-func (ah *APIHandler) lockUnlockDashboard(w http.ResponseWriter, r *http.Request, lock bool) {
-	// Locking can only be done by the owner of the dashboard
-	// or an admin
-
-	// - Fetch the dashboard
-	// - Check if the user is the owner or an admin
-	// - If yes, lock/unlock the dashboard
-	// - If no, return 403
-
-	// Get the dashboard UUID from the request
-	uuid := mux.Vars(r)["uuid"]
-	if strings.HasPrefix(uuid, "integration") {
-		render.Error(w, errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "dashboards created by integrations cannot be modified"))
-		return
-	}
-
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-
-	dashboard, err := ah.Signoz.Modules.Dashboard.Get(r.Context(), claims.OrgID, uuid)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if err := claims.IsAdmin(); err != nil && (dashboard.CreatedBy != claims.Email) {
-		render.Error(w, errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "You are not authorized to lock/unlock this dashboard"))
-		return
-	}
-
-	// Lock/Unlock the dashboard
-	err = ah.Signoz.Modules.Dashboard.LockUnlock(r.Context(), claims.OrgID, uuid, lock)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	ah.Respond(w, "Dashboard updated successfully")
-}

ee/query-service/app/server.go

@@ -20,6 +20,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -113,6 +114,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		serverOptions.SigNoz.SQLStore,
 		serverOptions.SigNoz.TelemetryStore,
 		serverOptions.SigNoz.Prometheus,
+		serverOptions.SigNoz.Modules.OrgGetter,
 	)
 
 	if err != nil {
@@ -157,7 +159,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	// start the usagemanager
-	usageManager, err := usage.New(serverOptions.SigNoz.Licensing, serverOptions.SigNoz.TelemetryStore.ClickhouseDB(), serverOptions.SigNoz.Zeus, serverOptions.SigNoz.Modules.Organization)
+	usageManager, err := usage.New(serverOptions.SigNoz.Licensing, serverOptions.SigNoz.TelemetryStore.ClickhouseDB(), serverOptions.SigNoz.Zeus, serverOptions.SigNoz.Modules.OrgGetter)
 	if err != nil {
 		return nil, err
 	}
@@ -225,7 +227,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		&opAmpModel.AllAgents, agentConfMgr,
 	)
 
-	orgs, err := apiHandler.Signoz.Modules.Organization.GetAll(context.Background())
+	orgs, err := apiHandler.Signoz.Modules.OrgGetter.ListByOwnedKeyRange(context.Background())
 	if err != nil {
 		return nil, err
 	}
@@ -240,11 +242,10 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 }
 
 func (s *Server) createPrivateServer(apiHandler *api.APIHandler) (*http.Server, error) {
-
 	r := baseapp.NewRouter()
 
-	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
+	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}, s.serverOptions.SigNoz.Sharder, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
-	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger(), s.serverOptions.SigNoz.Sharder).Wrap)
 	r.Use(middleware.NewTimeout(s.serverOptions.SigNoz.Instrumentation.Logger(),
 		s.serverOptions.Config.APIServer.Timeout.ExcludedRoutes,
 		s.serverOptions.Config.APIServer.Timeout.Default,
@@ -275,8 +276,8 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	r := baseapp.NewRouter()
 	am := middleware.NewAuthZ(s.serverOptions.SigNoz.Instrumentation.Logger())
 
-	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
+	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}, s.serverOptions.SigNoz.Sharder, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
-	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger(), s.serverOptions.SigNoz.Sharder).Wrap)
 	r.Use(middleware.NewTimeout(s.serverOptions.SigNoz.Instrumentation.Logger(),
 		s.serverOptions.Config.APIServer.Timeout.ExcludedRoutes,
 		s.serverOptions.Config.APIServer.Timeout.Default,
@@ -297,6 +298,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterMessagingQueuesRoutes(r, am)
 	apiHandler.RegisterThirdPartyApiRoutes(r, am)
 	apiHandler.MetricExplorerRoutes(r, am)
+	apiHandler.RegisterTraceFunnelsRoutes(r, am)
 
 	c := cors.New(cors.Options{
 		AllowedOrigins: []string{"*"},
@@ -450,6 +452,7 @@ func makeRulesManager(
 	sqlstore sqlstore.SQLStore,
 	telemetryStore telemetrystore.TelemetryStore,
 	prometheus prometheus.Prometheus,
+	orgGetter organization.Getter,
 ) (*baserules.Manager, error) {
 	// create manager opts
 	managerOpts := &baserules.ManagerOptions{
@@ -465,6 +468,7 @@ func makeRulesManager(
 		PrepareTestRuleFunc: rules.TestNotification,
 		Alertmanager:        alertmanager,
 		SQLStore:            sqlstore,
+		OrgGetter:           orgGetter,
 	}
 
 	// create Manager

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
+	}
+}

ee/query-service/main.go

@@ -17,6 +17,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/config/fileprovider"
 	"github.com/SigNoz/signoz/pkg/factory"
 	pkglicensing "github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -133,8 +134,8 @@ func main() {
 		zeus.Config(),
 		httpzeus.NewProviderFactory(),
 		licensing.Config(24*time.Hour, 3),
-		func(sqlstore sqlstore.SQLStore, zeus pkgzeus.Zeus) factory.ProviderFactory[pkglicensing.Licensing, pkglicensing.Config] {
+		func(sqlstore sqlstore.SQLStore, zeus pkgzeus.Zeus, orgGetter organization.Getter) factory.ProviderFactory[pkglicensing.Licensing, pkglicensing.Config] {
-			return httplicensing.NewProviderFactory(sqlstore, zeus)
+			return httplicensing.NewProviderFactory(sqlstore, zeus, orgGetter)
 		},
 		signoz.NewEmailingProviderFactories(),
 		signoz.NewCacheProviderFactories(),

ee/query-service/usage/manager.go

@@ -41,16 +41,16 @@ type Manager struct {
 
 	zeus zeus.Zeus
 
-	organizationModule organization.Module
+	orgGetter organization.Getter
 }
 
-func New(licenseService licensing.Licensing, clickhouseConn clickhouse.Conn, zeus zeus.Zeus, organizationModule organization.Module) (*Manager, error) {
+func New(licenseService licensing.Licensing, clickhouseConn clickhouse.Conn, zeus zeus.Zeus, orgGetter organization.Getter) (*Manager, error) {
 	m := &Manager{
 		clickhouseConn: clickhouseConn,
 		licenseService: licenseService,
 		scheduler:      gocron.NewScheduler(time.UTC).Every(1).Day().At("00:00"), // send usage every at 00:00 UTC
 		zeus:           zeus,
-		organizationModule: organizationModule,
+		orgGetter:      orgGetter,
 	}
 	return m, nil
 }
@@ -74,8 +74,7 @@ func (lm *Manager) Start(ctx context.Context) error {
 	return nil
 }
 func (lm *Manager) UploadUsage(ctx context.Context) {
-
+	organizations, err := lm.orgGetter.ListByOwnedKeyRange(ctx)
-	organizations, err := lm.organizationModule.GetAll(context.Background())
 	if err != nil {
 		zap.L().Error("failed to get organizations", zap.Error(err))
 		return

frontend/src/AppRoutes/index.tsx

@@ -28,6 +28,7 @@ import { QueryBuilderProvider } from 'providers/QueryBuilder';
 import { Suspense, useCallback, useEffect, useState } from 'react';
 import { Route, Router, Switch } from 'react-router-dom';
 import { CompatRouter } from 'react-router-dom-v5-compat';
+import { LicenseStatus } from 'types/api/licensesV3/getActive';
 import { Userpilot } from 'userpilot';
 import { extractDomain } from 'utils/app';
 
@@ -171,11 +172,13 @@ function App(): JSX.Element {
 			user &&
 			!!user.email
 		) {
+			// either the active API returns error with 404 or 501 and if it returns a terminated license means it's on basic plan
 			const isOnBasicPlan =
-				activeLicenseFetchError &&
+				(activeLicenseFetchError &&
 					[StatusCodes.NOT_FOUND, StatusCodes.NOT_IMPLEMENTED].includes(
 						activeLicenseFetchError?.getHttpStatusCode(),
-				);
+					)) ||
+				(activeLicense?.status && activeLicense.status === LicenseStatus.INVALID);
 			const isIdentifiedUser = getLocalStorageApi(LOCALSTORAGE.IS_IDENTIFIED_USER);
 
 			if (isLoggedInState && user && user.id && user.email && !isIdentifiedUser) {
@@ -190,6 +193,10 @@ function App(): JSX.Element {
 					updatedRoutes = updatedRoutes.filter(
 						(route) => route?.path !== ROUTES.BILLING,
 					);
+
+					if (isEnterpriseSelfHostedUser) {
+						updatedRoutes.push(LIST_LICENSES);
+					}
 				}
 				// always add support route for cloud users
 				updatedRoutes = [...updatedRoutes, SUPPORT_ROUTE];

frontend/src/api/dashboard/create.ts

@@ -1,27 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/dashboard/create';
-
-const createDashboard = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const url = props.uploadedGrafana ? '/dashboards/grafana' : '/dashboards';
-	try {
-		const response = await axios.post(url, {
-			...props,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default createDashboard;

frontend/src/api/dashboard/delete.ts

@@ -1,9 +0,0 @@
-import axios from 'api';
-import { PayloadProps, Props } from 'types/api/dashboard/delete';
-
-const deleteDashboard = (props: Props): Promise<PayloadProps> =>
-	axios
-		.delete<PayloadProps>(`/dashboards/${props.uuid}`)
-		.then((response) => response.data);
-
-export default deleteDashboard;

frontend/src/api/dashboard/get.ts

@@ -1,11 +0,0 @@
-import axios from 'api';
-import { ApiResponse } from 'types/api';
-import { Props } from 'types/api/dashboard/get';
-import { Dashboard } from 'types/api/dashboard/getAll';
-
-const getDashboard = (props: Props): Promise<Dashboard> =>
-	axios
-		.get<ApiResponse<Dashboard>>(`/dashboards/${props.uuid}`)
-		.then((res) => res.data.data);
-
-export default getDashboard;

frontend/src/api/dashboard/getAll.ts

@@ -1,8 +0,0 @@
-import axios from 'api';
-import { ApiResponse } from 'types/api';
-import { Dashboard } from 'types/api/dashboard/getAll';
-
-export const getAllDashboardList = (): Promise<Dashboard[]> =>
-	axios
-		.get<ApiResponse<Dashboard[]>>('/dashboards')
-		.then((res) => res.data.data);

frontend/src/api/dashboard/lockDashboard.ts

@@ -1,11 +0,0 @@
-import axios from 'api';
-import { AxiosResponse } from 'axios';
-
-interface LockDashboardProps {
-	uuid: string;
-}
-
-const lockDashboard = (props: LockDashboardProps): Promise<AxiosResponse> =>
-	axios.put(`/dashboards/${props.uuid}/lock`);
-
-export default lockDashboard;

frontend/src/api/dashboard/unlockDashboard.ts

@@ -1,11 +0,0 @@
-import axios from 'api';
-import { AxiosResponse } from 'axios';
-
-interface UnlockDashboardProps {
-	uuid: string;
-}
-
-const unlockDashboard = (props: UnlockDashboardProps): Promise<AxiosResponse> =>
-	axios.put(`/dashboards/${props.uuid}/unlock`);
-
-export default unlockDashboard;

frontend/src/api/dashboard/update.ts

@@ -1,20 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/dashboard/update';
-
-const updateDashboard = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.put(`/dashboards/${props.uuid}`, {
-		...props.data,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default updateDashboard;

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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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,
+			payload,
-			params: props,
+			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/api/v1/dashboards/create.ts

@@ -0,0 +1,23 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/dashboard/create';
+import { Dashboard } from 'types/api/dashboard/getAll';
+
+const create = async (props: Props): Promise<SuccessResponseV2<Dashboard>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/dashboards', {
+			...props,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default create;

frontend/src/api/v1/dashboards/getAll.ts

@@ -0,0 +1,19 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { Dashboard, PayloadProps } from 'types/api/dashboard/getAll';
+
+const getAll = async (): Promise<SuccessResponseV2<Dashboard[]>> => {
+	try {
+		const response = await axios.get<PayloadProps>('/dashboards');
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getAll;

frontend/src/api/v1/dashboards/id/delete.ts

@@ -0,0 +1,21 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/dashboard/delete';
+
+const deleteDashboard = async (
+	props: Props,
+): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.delete<PayloadProps>(`/dashboards/${props.id}`);
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default deleteDashboard;

frontend/src/api/v1/dashboards/id/get.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/dashboard/get';
+import { Dashboard } from 'types/api/dashboard/getAll';
+
+const get = async (props: Props): Promise<SuccessResponseV2<Dashboard>> => {
+	try {
+		const response = await axios.get<PayloadProps>(`/dashboards/${props.id}`);
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default get;

frontend/src/api/v1/dashboards/id/lock.ts

@@ -0,0 +1,23 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/dashboard/lockUnlock';
+
+const lock = async (props: Props): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.put<PayloadProps>(
+			`/dashboards/${props.id}/lock`,
+			{ lock: props.lock },
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default lock;

frontend/src/api/v1/dashboards/id/update.ts

@@ -0,0 +1,23 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { Dashboard } from 'types/api/dashboard/getAll';
+import { PayloadProps, Props } from 'types/api/dashboard/update';
+
+const update = async (props: Props): Promise<SuccessResponseV2<Dashboard>> => {
+	try {
+		const response = await axios.put<PayloadProps>(`/dashboards/${props.id}`, {
+			...props.data,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default update;

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/components/LogDetail/index.tsx

@@ -16,6 +16,7 @@ import JSONView from 'container/LogDetailedView/JsonView';
 import Overview from 'container/LogDetailedView/Overview';
 import {
 	aggregateAttributesResourcesToString,
+	escapeHtml,
 	removeEscapeCharacters,
 	unescapeString,
 } from 'container/LogDetailedView/utils';
@@ -118,7 +119,7 @@ function LogDetail({
 	const htmlBody = useMemo(
 		() => ({
 			__html: convert.toHtml(
-				dompurify.sanitize(unescapeString(log?.body || ''), {
+				dompurify.sanitize(unescapeString(escapeHtml(log?.body || '')), {
 					FORBID_TAGS: [...FORBID_DOM_PURIFY_TAGS],
 				}),
 			),

frontend/src/components/Logs/ListLogView/index.tsx

@@ -7,7 +7,7 @@ import cx from 'classnames';
 import LogDetail from 'components/LogDetail';
 import { VIEW_TYPES } from 'components/LogDetail/constants';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import { unescapeString } from 'container/LogDetailedView/utils';
+import { escapeHtml, unescapeString } from 'container/LogDetailedView/utils';
 import { FontSize } from 'container/OptionsMenu/types';
 import dompurify from 'dompurify';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
@@ -58,7 +58,7 @@ function LogGeneralField({
 	const html = useMemo(
 		() => ({
 			__html: convert.toHtml(
-				dompurify.sanitize(unescapeString(fieldValue), {
+				dompurify.sanitize(unescapeString(escapeHtml(fieldValue)), {
 					FORBID_TAGS: [...FORBID_DOM_PURIFY_TAGS],
 				}),
 			),

frontend/src/components/Logs/RawLogView/index.tsx

@@ -5,7 +5,7 @@ import { DrawerProps } from 'antd';
 import LogDetail from 'components/LogDetail';
 import { VIEW_TYPES, VIEWS } from 'components/LogDetail/constants';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import { unescapeString } from 'container/LogDetailedView/utils';
+import { escapeHtml, unescapeString } from 'container/LogDetailedView/utils';
 import LogsExplorerContext from 'container/LogsExplorerContext';
 import dompurify from 'dompurify';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
@@ -177,7 +177,7 @@ function RawLogView({
 	const html = useMemo(
 		() => ({
 			__html: convert.toHtml(
-				dompurify.sanitize(unescapeString(text), {
+				dompurify.sanitize(unescapeString(escapeHtml(text)), {
 					FORBID_TAGS: [...FORBID_DOM_PURIFY_TAGS],
 				}),
 			),

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/ExportPanel/ExportPanelContainer.tsx

@@ -1,11 +1,12 @@
 import { Button, Typography } from 'antd';
-import createDashboard from 'api/dashboard/create';
+import createDashboard from 'api/v1/dashboards/create';
 import { ENTITY_VERSION_V4 } from 'constants/app';
 import { useGetAllDashboard } from 'hooks/dashboard/useGetAllDashboard';
-import useAxiosError from 'hooks/useAxiosError';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { useCallback, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMutation } from 'react-query';
+import APIError from 'types/api/error';
 
 import { ExportPanelProps } from '.';
 import {
@@ -33,26 +34,28 @@ function ExportPanelContainer({
 		refetch,
 	} = useGetAllDashboard();
 
-	const handleError = useAxiosError();
+	const { showErrorModal } = useErrorModal();
 
 	const {
 		mutate: createNewDashboard,
 		isLoading: createDashboardLoading,
 	} = useMutation(createDashboard, {
 		onSuccess: (data) => {
-			if (data.payload) {
+			if (data.data) {
-				onExport(data?.payload, true);
+				onExport(data?.data, true);
 			}
 			refetch();
 		},
-		onError: handleError,
+		onError: (error) => {
+			showErrorModal(error as APIError);
+		},
 	});
 
-	const options = useMemo(() => getSelectOptions(data || []), [data]);
+	const options = useMemo(() => getSelectOptions(data?.data || []), [data]);
 
 	const handleExportClick = useCallback((): void => {
-		const currentSelectedDashboard = data?.find(
+		const currentSelectedDashboard = data?.data?.find(
-			({ uuid }) => uuid === selectedDashboardId,
+			({ id }) => id === selectedDashboardId,
 		);
 
 		onExport(currentSelectedDashboard || null, false);
@@ -66,14 +69,18 @@ function ExportPanelContainer({
 	);
 
 	const handleNewDashboard = useCallback(async () => {
-		createNewDashboard({
+		try {
+			await createNewDashboard({
 				title: t('new_dashboard_title', {
 					ns: 'dashboard',
 				}),
 				uploadedGrafana: false,
 				version: ENTITY_VERSION_V4,
 			});
-	}, [t, createNewDashboard]);
+		} catch (error) {
+			showErrorModal(error as APIError);
+		}
+	}, [createNewDashboard, t, showErrorModal]);
 
 	const isDashboardLoading = isAllDashboardsLoading || createDashboardLoading;
 

frontend/src/container/ExportPanel/utils.ts

@@ -1,12 +1,10 @@
 import { SelectProps } from 'antd';
-import { PayloadProps as AllDashboardsData } from 'types/api/dashboard/getAll';
+import { Dashboard } from 'types/api/dashboard/getAll';
 
-export const getSelectOptions = (
+export const getSelectOptions = (data: Dashboard[]): SelectProps['options'] =>
-	data: AllDashboardsData,
+	data.map(({ id, data }) => ({
-): SelectProps['options'] =>
-	data.map(({ uuid, data }) => ({
 		label: data.title,
-		value: uuid,
+		value: id,
 	}));
 
 export const filterOptions: SelectProps['filterOption'] = (

frontend/src/container/GridCardLayout/DashboardEmptyState/DashboardEmptyState.tsx

@@ -38,7 +38,7 @@ export default function DashboardEmptyState(): JSX.Element {
 		setSelectedRowWidgetId(null);
 		handleToggleDashboardSlider(true);
 		logEvent('Dashboard Detail: Add new panel clicked', {
-			dashboardId: selectedDashboard?.uuid,
+			dashboardId: selectedDashboard?.id,
 			dashboardName: selectedDashboard?.data.title,
 			numberOfPanels: selectedDashboard?.data.widgets?.length,
 		});

frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.test.tsx

@@ -2,6 +2,7 @@ import { fireEvent, render, screen } from '@testing-library/react';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { AppProvider } from 'providers/App/App';
+import { ErrorModalProvider } from 'providers/ErrorModalProvider';
 import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
 import { Provider } from 'react-redux';
 import store from 'store';
@@ -189,6 +190,7 @@ describe('WidgetGraphComponent', () => {
 	it('should show correct menu items when hovering over more options while loading', async () => {
 		const { getByTestId, findByRole, getByText, container } = render(
 			<MockQueryClientProvider>
+				<ErrorModalProvider>
 					<Provider store={store}>
 						<AppProvider>
 							<WidgetGraphComponent
@@ -207,6 +209,7 @@ describe('WidgetGraphComponent', () => {
 							/>
 						</AppProvider>
 					</Provider>
+				</ErrorModalProvider>
 			</MockQueryClientProvider>,
 		);
 

frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.tsx

@@ -4,7 +4,6 @@ import { Skeleton, Tooltip, Typography } from 'antd';
 import cx from 'classnames';
 import { useNavigateToExplorer } from 'components/CeleryTask/useNavigateToExplorer';
 import { ToggleGraphProps } from 'components/Graph/types';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { placeWidgetAtBottom } from 'container/NewWidget/utils';
@@ -31,7 +30,7 @@ import {
 	useState,
 } from 'react';
 import { useLocation } from 'react-router-dom';
-import { Dashboard } from 'types/api/dashboard/getAll';
+import { Props } from 'types/api/dashboard/update';
 import { DataSource } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
@@ -119,29 +118,23 @@ function WidgetGraphComponent({
 		const updatedLayout =
 			selectedDashboard.data.layout?.filter((e) => e.i !== widget.id) || [];
 
-		const updatedSelectedDashboard: Dashboard = {
+		const updatedSelectedDashboard: Props = {
-			...selectedDashboard,
 			data: {
 				...selectedDashboard.data,
 				widgets: updatedWidgets,
 				layout: updatedLayout,
 			},
-			uuid: selectedDashboard.uuid,
+			id: selectedDashboard.id,
 		};
 
 		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
 			onSuccess: (updatedDashboard) => {
-				if (setLayouts) setLayouts(updatedDashboard.payload?.data?.layout || []);
+				if (setLayouts) setLayouts(updatedDashboard.data?.data?.layout || []);
-				if (setSelectedDashboard && updatedDashboard.payload) {
+				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.payload);
+					setSelectedDashboard(updatedDashboard.data);
 				}
 				setDeleteModal(false);
 			},
-			onError: () => {
-				notifications.error({
-					message: SOMETHING_WENT_WRONG,
-				});
-			},
 		});
 	};
 
@@ -166,7 +159,8 @@ function WidgetGraphComponent({
 
 		updateDashboardMutation.mutateAsync(
 			{
-				...selectedDashboard,
+				id: selectedDashboard.id,
+
 				data: {
 					...selectedDashboard.data,
 					layout,
@@ -183,9 +177,9 @@ function WidgetGraphComponent({
 			},
 			{
 				onSuccess: (updatedDashboard) => {
-					if (setLayouts) setLayouts(updatedDashboard.payload?.data?.layout || []);
+					if (setLayouts) setLayouts(updatedDashboard.data?.data?.layout || []);
-					if (setSelectedDashboard && updatedDashboard.payload) {
+					if (setSelectedDashboard && updatedDashboard.data) {
-						setSelectedDashboard(updatedDashboard.payload);
+						setSelectedDashboard(updatedDashboard.data);
 					}
 					notifications.success({
 						message: 'Panel cloned successfully, redirecting to new copy.',

frontend/src/container/GridCardLayout/GridCardLayout.tsx

@@ -6,7 +6,6 @@ import { Button, Form, Input, Modal, Typography } from 'antd';
 import { useForm } from 'antd/es/form/Form';
 import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { QueryParams } from 'constants/query';
 import { PANEL_GROUP_TYPES, PANEL_TYPES } from 'constants/queryBuilder';
 import { themeColors } from 'constants/theme';
@@ -14,7 +13,6 @@ import { DEFAULT_ROW_NAME } from 'container/NewDashboard/DashboardDescription/ut
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { defaultTo, isUndefined } from 'lodash-es';
@@ -36,7 +34,8 @@ import { ItemCallback, Layout } from 'react-grid-layout';
 import { useDispatch } from 'react-redux';
 import { useLocation } from 'react-router-dom';
 import { UpdateTimeInterval } from 'store/actions';
-import { Dashboard, Widgets } from 'types/api/dashboard/getAll';
+import { Widgets } from 'types/api/dashboard/getAll';
+import { Props } from 'types/api/dashboard/update';
 import { ROLES, USER_ROLES } from 'types/roles';
 import { ComponentTypes } from 'utils/permission';
 
@@ -107,7 +106,6 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 
 	const updateDashboardMutation = useUpdateDashboard();
 
-	const { notifications } = useNotifications();
 	const urlQuery = useUrlQuery();
 
 	let permissions: ComponentTypes[] = ['save_layout', 'add_panel'];
@@ -158,20 +156,20 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	useEffect(() => {
 		if (!logEventCalledRef.current && !isUndefined(data)) {
 			logEvent('Dashboard Detail: Opened', {
-				dashboardId: data.uuid,
+				dashboardId: selectedDashboard?.id,
 				dashboardName: data.title,
 				numberOfPanels: data.widgets?.length,
 				numberOfVariables: Object.keys(data?.variables || {}).length || 0,
 			});
 			logEventCalledRef.current = true;
 		}
-	}, [data]);
+	}, [data, selectedDashboard?.id]);
 
 	const onSaveHandler = (): void => {
 		if (!selectedDashboard) return;
 
-		const updatedDashboard: Dashboard = {
+		const updatedDashboard: Props = {
-			...selectedDashboard,
+			id: selectedDashboard.id,
 			data: {
 				...selectedDashboard.data,
 				panelMap: { ...currentPanelMap },
@@ -186,24 +184,18 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 					return widget;
 				}),
 			},
-			uuid: selectedDashboard.uuid,
 		};
 
 		updateDashboardMutation.mutate(updatedDashboard, {
 			onSuccess: (updatedDashboard) => {
 				setSelectedRowWidgetId(null);
-				if (updatedDashboard.payload) {
+				if (updatedDashboard.data) {
-					if (updatedDashboard.payload.data.layout)
+					if (updatedDashboard.data.data.layout)
-						setLayouts(sortLayout(updatedDashboard.payload.data.layout));
+						setLayouts(sortLayout(updatedDashboard.data.data.layout));
-					setSelectedDashboard(updatedDashboard.payload);
+					setSelectedDashboard(updatedDashboard.data);
-					setPanelMap(updatedDashboard.payload?.data?.panelMap || {});
+					setPanelMap(updatedDashboard.data?.data?.panelMap || {});
 				}
 			},
-			onError: () => {
-				notifications.error({
-					message: SOMETHING_WENT_WRONG,
-				});
-			},
 		});
 	};
 
@@ -286,33 +278,25 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 
 		updatedWidgets?.push(currentWidget);
 
-		const updatedSelectedDashboard: Dashboard = {
+		const updatedSelectedDashboard: Props = {
-			...selectedDashboard,
+			id: selectedDashboard.id,
 			data: {
 				...selectedDashboard.data,
 				widgets: updatedWidgets,
 			},
-			uuid: selectedDashboard.uuid,
 		};
 
 		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
 			onSuccess: (updatedDashboard) => {
-				if (setLayouts) setLayouts(updatedDashboard.payload?.data?.layout || []);
+				if (setLayouts) setLayouts(updatedDashboard.data?.data?.layout || []);
-				if (setSelectedDashboard && updatedDashboard.payload) {
+				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.payload);
+					setSelectedDashboard(updatedDashboard.data);
 				}
-				if (setPanelMap)
+				if (setPanelMap) setPanelMap(updatedDashboard.data?.data?.panelMap || {});
-					setPanelMap(updatedDashboard.payload?.data?.panelMap || {});
 				form.setFieldValue('title', '');
 				setIsSettingsModalOpen(false);
 				setCurrentSelectRowId(null);
 			},
-			// eslint-disable-next-line sonarjs/no-identical-functions
-			onError: () => {
-				notifications.error({
-					message: SOMETHING_WENT_WRONG,
-				});
-			},
 		});
 	};
 
@@ -447,34 +431,26 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 		const updatedPanelMap = { ...currentPanelMap };
 		delete updatedPanelMap[currentSelectRowId];
 
-		const updatedSelectedDashboard: Dashboard = {
+		const updatedSelectedDashboard: Props = {
-			...selectedDashboard,
+			id: selectedDashboard.id,
 			data: {
 				...selectedDashboard.data,
 				widgets: updatedWidgets,
 				layout: updatedLayout,
 				panelMap: updatedPanelMap,
 			},
-			uuid: selectedDashboard.uuid,
 		};
 
 		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
 			onSuccess: (updatedDashboard) => {
-				if (setLayouts) setLayouts(updatedDashboard.payload?.data?.layout || []);
+				if (setLayouts) setLayouts(updatedDashboard.data?.data?.layout || []);
-				if (setSelectedDashboard && updatedDashboard.payload) {
+				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.payload);
+					setSelectedDashboard(updatedDashboard.data);
 				}
-				if (setPanelMap)
+				if (setPanelMap) setPanelMap(updatedDashboard.data?.data?.panelMap || {});
-					setPanelMap(updatedDashboard.payload?.data?.panelMap || {});
 				setIsDeleteModalOpen(false);
 				setCurrentSelectRowId(null);
 			},
-			// eslint-disable-next-line sonarjs/no-identical-functions
-			onError: () => {
-				notifications.error({
-					message: SOMETHING_WENT_WRONG,
-				});
-			},
 		});
 	};
 	const isDashboardEmpty = useMemo(

frontend/src/container/Home/Dashboards/Dashboards.tsx

@@ -33,7 +33,7 @@ export default function Dashboards({
 	useEffect(() => {
 		if (!dashboardsList) return;
 
-		const sortedDashboards = dashboardsList.sort((a, b) => {
+		const sortedDashboards = dashboardsList.data.sort((a, b) => {
 			const aUpdateAt = new Date(a.updatedAt).getTime();
 			const bUpdateAt = new Date(b.updatedAt).getTime();
 			return bUpdateAt - aUpdateAt;
@@ -103,7 +103,7 @@ export default function Dashboards({
 		<div className="home-dashboards-list-container home-data-item-container">
 			<div className="dashboards-list">
 				{sortedDashboards.slice(0, 5).map((dashboard) => {
-					const getLink = (): string => `${ROUTES.ALL_DASHBOARD}/${dashboard.uuid}`;
+					const getLink = (): string => `${ROUTES.ALL_DASHBOARD}/${dashboard.id}`;
 
 					const onClickHandler = (event: React.MouseEvent<HTMLElement>): void => {
 						event.stopPropagation();
@@ -134,7 +134,7 @@ export default function Dashboards({
 							<div className="dashboard-item-name-container home-data-item-name-container">
 								<img
 									src={
-										dashboard.id % 2 === 0
+										Math.random() % 2 === 0
 											? '/Icons/eight-ball.svg'
 											: '/Icons/circus-tent.svg'
 									}

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, {
+	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:
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sEntityToAggregateAttributeMapping[K8sCategory.CLUSTERS],
+				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/DaemonSetDetails/constants.ts

@@ -30,7 +30,51 @@ export const getDaemonSetMetricsQueryPayload = (
 	daemonSet: K8sDaemonSetsData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const k8sPodCpuUtilizationKey = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	const k8sContainerCpuRequestKey = dotMetricsEnabled
+		? 'k8s.container.cpu_request'
+		: 'k8s_container_cpu_request';
+
+	const k8sContainerCpuLimitKey = dotMetricsEnabled
+		? 'k8s.container.cpu_limit'
+		: 'k8s_container_cpu_limit';
+
+	const k8sPodMemoryUsageKey = dotMetricsEnabled
+		? 'k8s.pod.memory.usage'
+		: 'k8s_pod_memory_usage';
+
+	const k8sContainerMemoryRequestKey = dotMetricsEnabled
+		? 'k8s.container.memory_request'
+		: 'k8s_container_memory_request';
+
+	const k8sContainerMemoryLimitKey = dotMetricsEnabled
+		? 'k8s.container.memory_limit'
+		: 'k8s_container_memory_limit';
+
+	const k8sPodNetworkIoKey = dotMetricsEnabled
+		? 'k8s.pod.network.io'
+		: 'k8s_pod_network_io';
+
+	const k8sPodNetworkErrorsKey = dotMetricsEnabled
+		? 'k8s.pod.network.errors'
+		: 'k8s_pod_network_errors';
+
+	const k8sDaemonSetNameKey = dotMetricsEnabled
+		? 'k8s.daemonset.name'
+		: 'k8s_daemonset_name';
+
+	const k8sPodNameKey = dotMetricsEnabled ? 'k8s.pod.name' : 'k8s_pod_name';
+
+	const k8sNamespaceNameKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -43,7 +87,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -59,7 +103,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_daemonset_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_daemonset_name',
+											key: k8sDaemonSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -72,7 +116,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -99,7 +143,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_container_cpu_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -115,7 +159,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -128,7 +172,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -155,7 +199,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_container_cpu_limit--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_limit',
+								key: k8sContainerCpuLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -171,7 +215,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -184,7 +228,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -244,7 +288,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_pod_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -260,7 +304,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_daemonset_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_daemonset_name',
+											key: k8sDaemonSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -273,7 +317,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -300,7 +344,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_container_memory_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemoryRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -316,7 +360,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -329,7 +373,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -356,7 +400,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_container_memory_limit--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_limit',
+								key: k8sContainerMemoryLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -372,7 +416,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -385,7 +429,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -445,7 +489,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_pod_network_io--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_io',
+								key: k8sPodNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -461,7 +505,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_daemonset_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_daemonset_name',
+											key: k8sDaemonSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -474,7 +518,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -551,7 +595,7 @@ export const getDaemonSetMetricsQueryPayload = (
 								id: 'k8s_pod_network_errors--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_errors',
+								key: k8sPodNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -567,7 +611,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_daemonset_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_daemonset_name',
+											key: k8sDaemonSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -580,7 +624,7 @@ export const getDaemonSetMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -646,3 +690,4 @@ export const getDaemonSetMetricsQueryPayload = (
 			end,
 		},
 	];
+};

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:
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sEntityToAggregateAttributeMapping[K8sCategory.DAEMONSETS],
+				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/DeploymentDetails/constants.ts

@@ -30,7 +30,47 @@ export const getDeploymentMetricsQueryPayload = (
 	deployment: K8sDeploymentsData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const k8sPodCpuUtilizationKey = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	const k8sContainerCpuRequestKey = dotMetricsEnabled
+		? 'k8s.container.cpu_request'
+		: 'k8s_container_cpu_request';
+
+	const k8sContainerCpuLimitKey = dotMetricsEnabled
+		? 'k8s.container.cpu_limit'
+		: 'k8s_container_cpu_limit';
+
+	const k8sPodMemoryUsageKey = dotMetricsEnabled
+		? 'k8s.pod.memory.usage'
+		: 'k8s_pod_memory_usage';
+
+	const k8sContainerMemoryRequestKey = dotMetricsEnabled
+		? 'k8s.container.memory_request'
+		: 'k8s_container_memory_request';
+
+	const k8sContainerMemoryLimitKey = dotMetricsEnabled
+		? 'k8s.container.memory_limit'
+		: 'k8s_container_memory_limit';
+
+	const k8sPodNetworkIoKey = dotMetricsEnabled
+		? 'k8s.pod.network.io'
+		: 'k8s_pod_network_io';
+
+	const k8sPodNetworkErrorsKey = dotMetricsEnabled
+		? 'k8s.pod.network.errors'
+		: 'k8s_pod_network_errors';
+
+	const k8sDeploymentNameKey = dotMetricsEnabled
+		? 'k8s.deployment.name'
+		: 'k8s_deployment_name';
+
+	const k8sPodNameKey = dotMetricsEnabled ? 'k8s.pod.name' : 'k8s_pod_name';
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -43,7 +83,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -59,7 +99,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_deployment_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_deployment_name',
+											key: k8sDeploymentNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -86,7 +126,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_container_cpu_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -102,7 +142,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -129,7 +169,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_container_cpu_limit--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_limit',
+								key: k8sContainerCpuLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -145,7 +185,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -205,7 +245,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_pod_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -221,7 +261,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_deployment_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_deployment_name',
+											key: k8sDeploymentNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -248,7 +288,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_container_memory_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemoryRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -264,7 +304,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -291,7 +331,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_container_memory_limit--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_limit',
+								key: k8sContainerMemoryLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -307,7 +347,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_pod_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
@@ -367,7 +407,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_pod_network_io--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_io',
+								key: k8sPodNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -383,7 +423,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_deployment_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_deployment_name',
+											key: k8sDeploymentNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -460,7 +500,7 @@ export const getDeploymentMetricsQueryPayload = (
 								id: 'k8s_pod_network_errors--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_errors',
+								key: k8sPodNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -476,7 +516,7 @@ export const getDeploymentMetricsQueryPayload = (
 											id: 'k8s_deployment_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_deployment_name',
+											key: k8sDeploymentNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -542,3 +582,4 @@ export const getDeploymentMetricsQueryPayload = (
 			end,
 		},
 	];
+};

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:
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sEntityToAggregateAttributeMapping[K8sCategory.DEPLOYMENTS],
+				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(
+		const rawKey = group.key as string;
-			deployment.meta[group.key as keyof typeof deployment.meta],
+
-		);
+		// 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,
+	GetClustersQuickFiltersConfig,
-	DaemonSetsQuickFiltersConfig,
+	GetDaemonsetsQuickFiltersConfig,
-	DeploymentsQuickFiltersConfig,
+	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,7 +30,26 @@ export const getJobMetricsQueryPayload = (
 	job: K8sJobsData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	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,
@@ -43,7 +62,7 @@ export const getJobMetricsQueryPayload = (
 								id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -59,7 +78,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_job_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_job_name',
+											key: k8sJobNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -72,7 +91,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -132,7 +151,7 @@ export const getJobMetricsQueryPayload = (
 								id: 'k8s_pod_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -148,7 +167,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_job_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_job_name',
+											key: k8sJobNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -161,7 +180,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -221,7 +240,7 @@ export const getJobMetricsQueryPayload = (
 								id: 'k8s_pod_network_io--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_io',
+								key: k8sPodNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -237,7 +256,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_job_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_job_name',
+											key: k8sJobNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -250,7 +269,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -327,7 +346,7 @@ export const getJobMetricsQueryPayload = (
 								id: 'k8s_pod_network_errors--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_errors',
+								key: k8sPodNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -343,7 +362,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_job_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_job_name',
+											key: k8sJobNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -356,7 +375,7 @@ export const getJobMetricsQueryPayload = (
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -422,3 +441,4 @@ export const getJobMetricsQueryPayload = (
 			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, {
+	} = 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:
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sEntityToAggregateAttributeMapping[K8sCategory.NAMESPACES],
+				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/NamespaceDetails/constants.ts

@@ -54,7 +54,97 @@ export const getNamespaceMetricsQueryPayload = (
 	namespace: K8sNamespacesData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const getKey = (dotKey: string, underscoreKey: string): string =>
+		dotMetricsEnabled ? dotKey : underscoreKey;
+	const k8sPodCpuUtilizationKey = getKey(
+		'k8s.pod.cpu.utilization',
+		'k8s_pod_cpu_utilization',
+	);
+	const k8sContainerCpuRequestKey = getKey(
+		'k8s.container.cpu_request',
+		'k8s_container_cpu_request',
+	);
+	const k8sPodMemoryUsageKey = getKey(
+		'k8s.pod.memory.usage',
+		'k8s_pod_memory_usage',
+	);
+	const k8sContainerMemoryRequestKey = getKey(
+		'k8s.container.memory_request',
+		'k8s_container_memory_request',
+	);
+	const k8sPodMemoryWorkingSetKey = getKey(
+		'k8s.pod.memory.working_set',
+		'k8s_pod_memory_working_set',
+	);
+	const k8sPodMemoryRssKey = getKey('k8s.pod.memory.rss', 'k8s_pod_memory_rss');
+	const k8sPodNetworkIoKey = getKey('k8s.pod.network.io', 'k8s_pod_network_io');
+	const k8sPodNetworkErrorsKey = getKey(
+		'k8s.pod.network.errors',
+		'k8s_pod_network_errors',
+	);
+	const k8sStatefulsetCurrentPodsKey = getKey(
+		'k8s.statefulset.current_pods',
+		'k8s_statefulset_current_pods',
+	);
+	const k8sStatefulsetDesiredPodsKey = getKey(
+		'k8s.statefulset.desired_pods',
+		'k8s_statefulset_desired_pods',
+	);
+	const k8sStatefulsetUpdatedPodsKey = getKey(
+		'k8s.statefulset.updated_pods',
+		'k8s_statefulset_updated_pods',
+	);
+	const k8sReplicasetDesiredKey = getKey(
+		'k8s.replicaset.desired',
+		'k8s_replicaset_desired',
+	);
+	const k8sReplicasetAvailableKey = getKey(
+		'k8s.replicaset.available',
+		'k8s_replicaset_available',
+	);
+	const k8sDaemonsetDesiredScheduledNamespacesKey = getKey(
+		'k8s.daemonset.desired.scheduled.namespaces',
+		'k8s_daemonset_desired_scheduled_namespaces',
+	);
+	const k8sDaemonsetCurrentScheduledNamespacesKey = getKey(
+		'k8s.daemonset.current.scheduled.namespaces',
+		'k8s_daemonset_current_scheduled_namespaces',
+	);
+	const k8sDaemonsetReadyNamespacesKey = getKey(
+		'k8s.daemonset.ready.namespaces',
+		'k8s_daemonset_ready_namespaces',
+	);
+	const k8sDaemonsetMisscheduledNamespacesKey = getKey(
+		'k8s.daemonset.misscheduled.namespaces',
+		'k8s_daemonset_misscheduled_namespaces',
+	);
+	const k8sDeploymentDesiredKey = getKey(
+		'k8s.deployment.desired',
+		'k8s_deployment_desired',
+	);
+	const k8sDeploymentAvailableKey = getKey(
+		'k8s.deployment.available',
+		'k8s_deployment_available',
+	);
+	const k8sNamespaceNameKey = getKey('k8s.namespace.name', 'k8s_namespace_name');
+	const k8sPodNameKey = getKey('k8s.pod.name', 'k8s_pod_name');
+	const k8sStatefulsetNameKey = getKey(
+		'k8s.statefulset.name',
+		'k8s_statefulset_name',
+	);
+	const k8sReplicasetNameKey = getKey(
+		'k8s.replicaset.name',
+		'k8s_replicaset_name',
+	);
+	const k8sDaemonsetNameKey = getKey('k8s.daemonset.name', 'k8s_daemonset_name');
+	const k8sDeploymentNameKey = getKey(
+		'k8s.deployment.name',
+		'k8s_deployment_name',
+	);
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -64,10 +154,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								id: k8sPodCpuUtilizationKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -80,10 +170,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '47b3adae',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -107,10 +197,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_cpu_request--float64--Gauge--true',
+								id: k8sContainerCpuRequestKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -123,10 +213,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '93d2be5e',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -150,10 +240,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								id: k8sPodCpuUtilizationKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'min',
@@ -166,10 +256,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '795eb679',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -193,10 +283,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								id: k8sPodCpuUtilizationKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'max',
@@ -209,10 +299,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '6792adbe',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -269,10 +359,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								id: k8sPodMemoryUsageKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -285,10 +375,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '10011298',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -312,10 +402,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_memory_request--float64--Gauge--true',
+								id: k8sContainerMemoryRequestKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemoryRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -328,10 +418,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'ea53b656',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -355,10 +445,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_working_set--float64--Gauge--true',
+								id: k8sPodMemoryWorkingSetKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_working_set',
+								key: k8sPodMemoryWorkingSetKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -371,10 +461,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '674ace83',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -398,10 +488,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_rss--float64--Gauge--true',
+								id: k8sPodMemoryRssKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_rss',
+								key: k8sPodMemoryRssKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -414,10 +504,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '187dbdb3',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -441,10 +531,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								id: k8sPodMemoryUsageKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'min',
@@ -457,10 +547,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'a3dbf468',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -484,10 +574,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								id: k8sPodMemoryUsageKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'max',
@@ -500,10 +590,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '4b2406c2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -560,10 +650,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								id: k8sPodCpuUtilizationKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -576,10 +666,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'c3a73f0a',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -592,15 +682,15 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_pod_name--string--tag--false',
+									id: k8sPodNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_pod_name',
+									key: k8sPodNameKey,
 									type: 'tag',
 								},
 							],
 							having: [],
-						legend: '{{k8s_pod_name}}',
+							legend: `{{${k8sPodNameKey}}}`,
 							limit: 20,
 							orderBy: [],
 							queryName: 'A',
@@ -645,10 +735,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								id: k8sPodMemoryUsageKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -661,10 +751,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '5cad3379',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -677,15 +767,15 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_pod_name--string--tag--false',
+									id: k8sPodNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_pod_name',
+									key: k8sPodNameKey,
 									type: 'tag',
 								},
 							],
 							having: [],
-						legend: '{{k8s_pod_name}}',
+							legend: `{{${k8sPodNameKey}}}`,
 							limit: 10,
 							orderBy: [],
 							queryName: 'A',
@@ -730,10 +820,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_network_io--float64--Sum--true',
+								id: k8sPodNetworkIoKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_io',
+								key: k8sPodNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -746,10 +836,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '00f5c5e1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -762,7 +852,7 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
+									id: 'interface',
 									isColumn: false,
 									isJSON: false,
 									key: 'interface',
@@ -770,7 +860,7 @@ export const getNamespaceMetricsQueryPayload = (
 								},
 								{
 									dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
+									id: 'direction',
 									isColumn: false,
 									isJSON: false,
 									key: 'direction',
@@ -823,10 +913,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.String,
-							id: 'k8s_pod_network_errors--float64--Sum--true',
+								id: k8sPodNetworkErrorsKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_errors',
+								key: k8sPodNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -839,10 +929,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '3aa8e064',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -855,7 +945,7 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
+									id: 'interface',
 									isColumn: false,
 									isJSON: false,
 									key: 'interface',
@@ -863,7 +953,7 @@ export const getNamespaceMetricsQueryPayload = (
 								},
 								{
 									dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
+									id: 'direction',
 									isColumn: false,
 									isJSON: false,
 									key: 'direction',
@@ -916,10 +1006,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_statefulset_current_pods--float64--Gauge--true',
+								id: k8sStatefulsetCurrentPodsKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_statefulset_current_pods',
+								key: k8sStatefulsetCurrentPodsKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -932,10 +1022,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '5f2a55c5',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sStatefulsetNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sStatefulsetNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -948,10 +1038,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_statefulset_name--string--tag--false',
+									id: k8sStatefulsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_statefulset_name',
+									key: k8sStatefulsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -968,10 +1058,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_statefulset_desired_pods--float64--Gauge--true',
+								id: k8sStatefulsetDesiredPodsKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_statefulset_desired_pods',
+								key: k8sStatefulsetDesiredPodsKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -984,10 +1074,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '13bd7a1d',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1000,10 +1090,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_statefulset_name--string--tag--false',
+									id: k8sStatefulsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_statefulset_name',
+									key: k8sStatefulsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1020,10 +1110,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_statefulset_updated_pods--float64--Gauge--true',
+								id: k8sStatefulsetUpdatedPodsKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_statefulset_updated_pods',
+								key: k8sStatefulsetUpdatedPodsKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1036,10 +1126,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '9d287c73',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1052,10 +1142,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_statefulset_name--string--tag--false',
+									id: k8sStatefulsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_statefulset_name',
+									key: k8sStatefulsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1105,10 +1195,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_replicaset_desired--float64--Gauge--true',
+								id: k8sReplicasetDesiredKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_replicaset_desired',
+								key: k8sReplicasetDesiredKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1121,10 +1211,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '0c1e655c',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1137,16 +1227,16 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_replicaset_name--string--tag--false',
+									id: k8sReplicasetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_replicaset_name',
+									key: k8sReplicasetNameKey,
 									type: 'tag',
 								},
 							],
 							having: [
 								{
-								columnName: 'MAX(k8s_replicaset_desired)',
+									columnName: `MAX(${k8sReplicasetDesiredKey})`,
 									op: '>',
 									value: 0,
 								},
@@ -1163,10 +1253,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_replicaset_available--float64--Gauge--true',
+								id: k8sReplicasetAvailableKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_replicaset_available',
+								key: k8sReplicasetAvailableKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1179,10 +1269,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'b2296bdb',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1195,16 +1285,16 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_replicaset_name--string--tag--false',
+									id: k8sReplicasetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_replicaset_name',
+									key: k8sReplicasetNameKey,
 									type: 'tag',
 								},
 							],
 							having: [
 								{
-								columnName: 'MAX(k8s_replicaset_available)',
+									columnName: `MAX(${k8sReplicasetDesiredKey})`,
 									op: '>',
 									value: 0,
 								},
@@ -1254,10 +1344,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_daemonset_desired_scheduled_namespaces--float64--Gauge--true',
+								id: k8sDaemonsetDesiredScheduledNamespacesKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_daemonset_desired_scheduled_namespaces',
+								key: k8sDaemonsetDesiredScheduledNamespacesKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1270,10 +1360,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '2964eb92',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1286,10 +1376,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_daemonset_name--string--tag--false',
+									id: k8sDaemonsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_daemonset_name',
+									key: k8sDaemonsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1306,10 +1396,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_daemonset_current_scheduled_namespaces--float64--Gauge--true',
+								id: k8sDaemonsetCurrentScheduledNamespacesKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_daemonset_current_scheduled_namespaces',
+								key: k8sDaemonsetCurrentScheduledNamespacesKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1322,10 +1412,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'cd324eff',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1338,10 +1428,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_daemonset_name--string--tag--false',
+									id: k8sDaemonsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_daemonset_name',
+									key: k8sDaemonsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1358,10 +1448,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_daemonset_ready_namespaces--float64--Gauge--true',
+								id: k8sDaemonsetReadyNamespacesKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_daemonset_ready_namespaces',
+								key: k8sDaemonsetReadyNamespacesKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1374,10 +1464,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '0416fa6f',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1390,10 +1480,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_daemonset_name--string--tag--false',
+									id: k8sDaemonsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_daemonset_name',
+									key: k8sDaemonsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1410,10 +1500,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_daemonset_misscheduled_namespaces--float64--Gauge--true',
+								id: k8sDaemonsetMisscheduledNamespacesKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_daemonset_misscheduled_namespaces',
+								key: k8sDaemonsetMisscheduledNamespacesKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1426,10 +1516,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'c0a126d3',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1442,10 +1532,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_daemonset_name--string--tag--false',
+									id: k8sDaemonsetNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_daemonset_name',
+									key: k8sDaemonsetNameKey,
 									type: 'tag',
 								},
 							],
@@ -1495,10 +1585,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_deployment_desired--float64--Gauge--true',
+								id: k8sDeploymentDesiredKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_deployment_desired',
+								key: k8sDeploymentDesiredKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -1511,10 +1601,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: '9bc659c1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1527,10 +1617,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_deployment_name--string--tag--false',
+									id: k8sDeploymentNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_deployment_name',
+									key: k8sDeploymentNameKey,
 									type: 'tag',
 								},
 							],
@@ -1547,10 +1637,10 @@ export const getNamespaceMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_deployment_available--float64--Gauge--true',
+								id: k8sDeploymentAvailableKey,
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_deployment_available',
+								key: k8sDeploymentAvailableKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1563,10 +1653,10 @@ export const getNamespaceMetricsQueryPayload = (
 										id: 'e1696631',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: k8sNamespaceNameKey,
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1579,10 +1669,10 @@ export const getNamespaceMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'k8s_deployment_name--string--tag--false',
+									id: k8sDeploymentNameKey,
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_deployment_name',
+									key: k8sDeploymentNameKey,
 									type: 'tag',
 								},
 							],
@@ -1631,3 +1721,4 @@ export const getNamespaceMetricsQueryPayload = (
 			end,
 		},
 	];
+};

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, {
+	} = 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/NodeDetails/constants.ts

@@ -54,7 +54,90 @@ export const getNodeMetricsQueryPayload = (
 	node: K8sNodesData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const getKey = (dotKey: string, underscoreKey: string): string =>
+		dotMetricsEnabled ? dotKey : underscoreKey;
+	const k8sNodeCpuUtilizationKey = getKey(
+		'k8s.node.cpu.utilization',
+		'k8s_node_cpu_utilization',
+	);
+
+	const k8sNodeAllocatableCpuKey = getKey(
+		'k8s.node.allocatable_cpu',
+		'k8s_node_allocatable_cpu',
+	);
+
+	const k8sContainerCpuRequestKey = getKey(
+		'k8s.container.cpu_request',
+		'k8s_container_cpu_request',
+	);
+
+	const k8sNodeMemoryUsageKey = getKey(
+		'k8s.node.memory.usage',
+		'k8s_node_memory_usage',
+	);
+
+	const k8sNodeAllocatableMemoryKey = getKey(
+		'k8s.node.allocatable_memory',
+		'k8s_node_allocatable_memory',
+	);
+
+	const k8sContainerMemoryRequestKey = getKey(
+		'k8s.container.memory_request',
+		'k8s_container_memory_request',
+	);
+
+	const k8sNodeMemoryWorkingSetKey = getKey(
+		'k8s.node.memory.working_set',
+		'k8s_node_memory_working_set',
+	);
+
+	const k8sNodeMemoryRssKey = getKey(
+		'k8s.node.memory.rss',
+		'k8s_node_memory_rss',
+	);
+
+	const k8sPodCpuUtilizationKey = getKey(
+		'k8s.pod.cpu.utilization',
+		'k8s_pod_cpu_utilization',
+	);
+
+	const k8sPodMemoryUsageKey = getKey(
+		'k8s.pod.memory.usage',
+		'k8s_pod_memory_usage',
+	);
+
+	const k8sNodeNetworkErrorsKey = getKey(
+		'k8s.node.network.errors',
+		'k8s_node_network_errors',
+	);
+
+	const k8sNodeNetworkIoKey = getKey(
+		'k8s.node.network.io',
+		'k8s_node_network_io',
+	);
+
+	const k8sNodeFilesystemUsageKey = getKey(
+		'k8s.node.filesystem.usage',
+		'k8s_node_filesystem_usage',
+	);
+
+	const k8sNodeFilesystemCapacityKey = getKey(
+		'k8s.node.filesystem.capacity',
+		'k8s_node_filesystem_capacity',
+	);
+
+	const k8sNodeFilesystemAvailableKey = getKey(
+		'k8s.node.filesystem.available',
+		'k8s_node_filesystem_available',
+	);
+
+	const k8sNodeNameKey = getKey('k8s.node.name', 'k8s_node_name');
+
+	const k8sPodNameKey = getKey('k8s.pod.name', 'k8s_pod_name');
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -67,7 +150,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_cpu_utilization',
+								key: k8sNodeCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -83,7 +166,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -110,7 +193,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_allocatable_cpu--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_allocatable_cpu',
+								key: k8sNodeAllocatableCpuKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -126,7 +209,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -153,7 +236,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_container_cpu_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -169,7 +252,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -196,7 +279,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_cpu_utilization',
+								key: k8sNodeCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'max',
@@ -212,7 +295,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -239,7 +322,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_cpu_utilization',
+								key: k8sNodeCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'min',
@@ -255,7 +338,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -315,7 +398,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_usage',
+								key: k8sNodeMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -331,7 +414,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -358,7 +441,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_allocatable_memory--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_allocatable_memory',
+								key: k8sNodeAllocatableMemoryKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -374,7 +457,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -401,7 +484,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_container_memory_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemoryRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -417,7 +500,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -444,7 +527,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_usage',
+								key: k8sNodeMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'max',
@@ -460,7 +543,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -487,7 +570,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_usage',
+								key: k8sNodeMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'min',
@@ -503,7 +586,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -530,7 +613,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_working_set--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_working_set',
+								key: k8sNodeMemoryWorkingSetKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -546,7 +629,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -573,7 +656,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_rss--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_rss',
+								key: k8sNodeMemoryRssKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -589,7 +672,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -649,7 +732,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_cpu_utilization',
+								key: k8sNodeCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -665,7 +748,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -692,7 +775,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_allocatable_cpu--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_allocatable_cpu',
+								key: k8sNodeAllocatableCpuKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -708,7 +791,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -735,7 +818,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_container_cpu_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -751,7 +834,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -824,7 +907,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_memory_usage',
+								key: k8sNodeMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -840,7 +923,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -867,7 +950,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_allocatable_memory--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_allocatable_memory',
+								key: k8sNodeAllocatableMemoryKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -883,7 +966,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -910,7 +993,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_container_memory_request--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemoryRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -926,7 +1009,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -999,7 +1082,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilizationKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1015,7 +1098,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1031,12 +1114,12 @@ export const getNodeMetricsQueryPayload = (
 									id: 'k8s_pod_name--string--tag--false',
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_pod_name',
+									key: k8sPodNameKey,
 									type: 'tag',
 								},
 							],
 							having: [],
-						legend: '{{k8s_pod_name}}',
+							legend: `{{${k8sPodNameKey}}}`,
 							limit: 10,
 							orderBy: [],
 							queryName: 'A',
@@ -1084,7 +1167,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_pod_memory_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemoryUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1100,7 +1183,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1116,12 +1199,12 @@ export const getNodeMetricsQueryPayload = (
 									id: 'k8s_pod_name--string--tag--false',
 									isColumn: false,
 									isJSON: false,
-								key: 'k8s_pod_name',
+									key: k8sPodNameKey,
 									type: 'tag',
 								},
 							],
 							having: [],
-						legend: '{{k8s_pod_name}}',
+							legend: `{{${k8sPodNameKey}}}`,
 							limit: 10,
 							orderBy: [],
 							queryName: 'A',
@@ -1169,7 +1252,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_network_errors--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_network_errors',
+								key: k8sNodeNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -1185,7 +1268,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1262,7 +1345,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_network_io--float64--Sum--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_network_io',
+								key: k8sNodeNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -1278,7 +1361,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1355,7 +1438,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_filesystem_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_filesystem_usage',
+								key: k8sNodeFilesystemUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1371,7 +1454,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1398,7 +1481,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_filesystem_capacity--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_filesystem_capacity',
+								key: k8sNodeFilesystemCapacityKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1414,7 +1497,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1441,7 +1524,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_filesystem_available--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_filesystem_available',
+								key: k8sNodeFilesystemAvailableKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1457,7 +1540,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1517,7 +1600,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_filesystem_usage--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_filesystem_usage',
+								key: k8sNodeFilesystemUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1533,7 +1616,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1560,7 +1643,7 @@ export const getNodeMetricsQueryPayload = (
 								id: 'k8s_node_filesystem_capacity--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_node_filesystem_capacity',
+								key: k8sNodeFilesystemCapacityKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -1576,7 +1659,7 @@ export const getNodeMetricsQueryPayload = (
 											id: 'k8s_node_name--string--tag--false',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_node_name',
+											key: k8sNodeNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -1632,3 +1715,4 @@ export const getNodeMetricsQueryPayload = (
 			end,
 		},
 	];
+};

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, {
+	} = 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:
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sEntityToAggregateAttributeMapping[K8sCategory.STATEFULSETS],
+				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/StatefulSetDetails/constants.ts

@@ -38,7 +38,56 @@ export const getStatefulSetMetricsQueryPayload = (
 	statefulSet: K8sStatefulSetsData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const k8sStatefulSetNameKey = dotMetricsEnabled
+		? 'k8s.statefulset.name'
+		: 'k8s_statefulset_name';
+	const k8sNamespaceNameKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const k8sPodNameKey = dotMetricsEnabled ? 'k8s.pod.name' : 'k8s_pod_name';
+
+	const k8sPodCpuUtilKey = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+	const k8sContainerCpuRequestKey = dotMetricsEnabled
+		? 'k8s.container.cpu_request'
+		: 'k8s_container_cpu_request';
+	const k8sContainerCpuLimitKey = dotMetricsEnabled
+		? 'k8s.container.cpu_limit'
+		: 'k8s_container_cpu_limit';
+	const k8sPodCpuReqUtilKey = dotMetricsEnabled
+		? 'k8s.pod.cpu_request_utilization'
+		: 'k8s_pod_cpu_request_utilization';
+	const k8sPodCpuLimitUtilKey = dotMetricsEnabled
+		? 'k8s.pod.cpu_limit_utilization'
+		: 'k8s_pod_cpu_limit_utilization';
+
+	const k8sPodMemUsageKey = dotMetricsEnabled
+		? 'k8s.pod.memory.usage'
+		: 'k8s_pod_memory_usage';
+	const k8sContainerMemRequestKey = dotMetricsEnabled
+		? 'k8s.container.memory_request'
+		: 'k8s_container_memory_request';
+	const k8sContainerMemLimitKey = dotMetricsEnabled
+		? 'k8s.container.memory_limit'
+		: 'k8s_container_memory_limit';
+	const k8sPodMemReqUtilKey = dotMetricsEnabled
+		? 'k8s.pod.memory_request_utilization'
+		: 'k8s_pod_memory_request_utilization';
+	const k8sPodMemLimitUtilKey = dotMetricsEnabled
+		? 'k8s.pod.memory_limit_utilization'
+		: 'k8s_pod_memory_limit_utilization';
+
+	const k8sPodNetworkIoKey = dotMetricsEnabled
+		? 'k8s.pod.network.io'
+		: 'k8s_pod_network_io';
+	const k8sPodNetworkErrorsKey = dotMetricsEnabled
+		? 'k8s.pod.network.errors'
+		: 'k8s_pod_network_errors';
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -48,10 +97,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+								id: 'cpu_usage',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_utilization',
+								key: k8sPodCpuUtilKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -61,26 +110,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '8627bd22',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -104,10 +153,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_cpu_request--float64--Gauge--true',
+								id: 'cpu_request',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_request',
+								key: k8sContainerCpuRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -117,26 +166,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '82f07131',
+										id: 'f3',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_pod_name--string--tag--false',
+											id: 'pod_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -160,10 +209,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_cpu_limit--float64--Gauge--true',
+								id: 'cpu_limit',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_cpu_limit',
+								key: k8sContainerCpuLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -173,26 +222,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '9c669f4f',
+										id: 'f4',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_pod_name--string--tag--false',
+											id: 'pod_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -216,23 +265,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -249,10 +284,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_request_utilization--float64--Gauge--true',
+								id: 'cpu_req_util',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_request_utilization',
+								key: k8sPodCpuReqUtilKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -262,26 +297,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '3c835082',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -305,10 +340,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_cpu_limit_utilization--float64--Gauge--true',
+								id: 'cpu_limit_util',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_cpu_limit_utilization',
+								key: k8sPodCpuLimitUtilKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -318,26 +353,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: 'c0a5e5b1',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -361,23 +396,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -394,10 +415,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+								id: 'mem_usage',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_usage',
+								key: k8sPodMemUsageKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -407,26 +428,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: 'f8ae7d0f',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -450,10 +471,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_memory_request--float64--Gauge--true',
+								id: 'mem_request',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_request',
+								key: k8sContainerMemRequestKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -463,26 +484,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '66fbdd5e',
+										id: 'f3',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_pod_name--string--tag--false',
+											id: 'pod_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -506,10 +527,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_container_memory_limit--float64--Gauge--true',
+								id: 'mem_limit',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_container_memory_limit',
+								key: k8sContainerMemLimitKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'latest',
@@ -519,26 +540,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '1a408383',
+										id: 'f4',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_pod_name--string--tag--false',
+											id: 'pod_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_pod_name',
+											key: k8sPodNameKey,
 											type: 'tag',
 										},
 										op: 'contains',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -562,23 +583,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -595,10 +602,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_request_utilization--float64--Gauge--true',
+								id: 'mem_req_util',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_request_utilization',
+								key: k8sPodMemReqUtilKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -608,26 +615,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: 'acdccfa2',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -651,10 +658,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_memory_limit_utilization--float64--Gauge--true',
+								id: 'mem_limit_util',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_memory_limit_utilization',
+								key: k8sPodMemLimitUtilKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -664,26 +671,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: 'cc9a85d3',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -707,23 +714,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -740,10 +733,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_network_io--float64--Sum--true',
+								id: 'net_io',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_io',
+								key: k8sPodNetworkIoKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'rate',
@@ -753,26 +746,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '2ea33f83',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -785,7 +778,7 @@ export const getStatefulSetMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
+									id: 'direction',
 									isColumn: false,
 									isJSON: false,
 									key: 'direction',
@@ -793,7 +786,7 @@ export const getStatefulSetMetricsQueryPayload = (
 								},
 								{
 									dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
+									id: 'interface',
 									isColumn: false,
 									isJSON: false,
 									key: 'interface',
@@ -813,23 +806,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -846,10 +825,10 @@ export const getStatefulSetMetricsQueryPayload = (
 						{
 							aggregateAttribute: {
 								dataType: DataTypes.Float64,
-							id: 'k8s_pod_network_errors--float64--Sum--true',
+								id: 'net_err',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_pod_network_errors',
+								key: k8sPodNetworkErrorsKey,
 								type: 'Sum',
 							},
 							aggregateOperator: 'increase',
@@ -859,26 +838,26 @@ export const getStatefulSetMetricsQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '7e25d4fb',
+										id: 'f1',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_statefulset_name--string--tag--false',
+											id: 'ss_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_statefulset_name',
+											key: k8sStatefulSetNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: statefulSet.meta.k8s_statefulset_name,
 									},
 									{
-									id: '47b3adae',
+										id: 'f2',
 										key: {
 											dataType: DataTypes.String,
-										id: 'k8s_namespace_name--string--tag--false',
+											id: 'ns_name',
 											isColumn: false,
 											isJSON: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: '=',
@@ -891,7 +870,7 @@ export const getStatefulSetMetricsQueryPayload = (
 							groupBy: [
 								{
 									dataType: DataTypes.String,
-								id: 'direction--string--tag--false',
+									id: 'direction',
 									isColumn: false,
 									isJSON: false,
 									key: 'direction',
@@ -899,7 +878,7 @@ export const getStatefulSetMetricsQueryPayload = (
 								},
 								{
 									dataType: DataTypes.String,
-								id: 'interface--string--tag--false',
+									id: 'interface',
 									isColumn: false,
 									isJSON: false,
 									key: 'interface',
@@ -919,23 +898,9 @@ export const getStatefulSetMetricsQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -944,3 +909,4 @@ export const getStatefulSetMetricsQueryPayload = (
 			end,
 		},
 	];
+};

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(
+		const rawKey = group.key as string;
-			statefulSet.meta[group.key as keyof typeof statefulSet.meta],
+
-		);
+		// 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, {
+	} = 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/VolumeDetails/constants.ts

@@ -34,7 +34,40 @@ export const getVolumeQueryPayload = (
 	volume: K8sVolumesData,
 	start: number,
 	end: number,
-): GetQueryResultsProps[] => [
+	dotMetricsEnabled: boolean,
+): GetQueryResultsProps[] => {
+	const k8sClusterNameKey = dotMetricsEnabled
+		? 'k8s.cluster.name'
+		: 'k8s_cluster_name';
+	const k8sNamespaceNameKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const k8sVolumeAvailableKey = dotMetricsEnabled
+		? 'k8s.volume.available'
+		: 'k8s_volume_available';
+	const k8sVolumeCapacityKey = dotMetricsEnabled
+		? 'k8s.volume.capacity'
+		: 'k8s_volume_capacity';
+	const k8sVolumeInodesUsedKey = dotMetricsEnabled
+		? 'k8s.volume.inodes.used'
+		: 'k8s_volume_inodes_used';
+	const k8sVolumeInodesKey = dotMetricsEnabled
+		? 'k8s.volume.inodes'
+		: 'k8s_volume_inodes';
+	const k8sVolumeInodesFreeKey = dotMetricsEnabled
+		? 'k8s.volume.inodes.free'
+		: 'k8s_volume_inodes_free';
+	const k8sVolumeTypeKey = dotMetricsEnabled
+		? 'k8s.volume.type'
+		: 'k8s_volume_type';
+	const k8sPVCNameKey = dotMetricsEnabled
+		? 'k8s.persistentvolumeclaim.name'
+		: 'k8s_persistentvolumeclaim_name';
+	const legendTemplate = dotMetricsEnabled
+		? '{{k8s.namespace.name}}-{{k8s.pod.name}}'
+		: '{{k8s_namespace_name}}-{{k8s_pod_name}}';
+
+	return [
 		{
 			selectedTime: 'GLOBAL_TIME',
 			graphType: PANEL_TYPES.TIME_SERIES,
@@ -47,7 +80,7 @@ export const getVolumeQueryPayload = (
 								id: 'k8s_volume_available--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_volume_available',
+								key: k8sVolumeAvailableKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -57,50 +90,49 @@ export const getVolumeQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '6077fbc2',
+										id: 'c1',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_cluster_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_cluster_name',
+											key: k8sClusterNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: volume.meta.k8s_cluster_name,
 									},
 									{
-									id: '6077fbc2',
+										id: 'c2',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: [volume.meta.k8s_namespace_name],
 									},
 									{
-									id: '217757e9',
+										id: 'c3',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_volume_type--string--tag--false',
 											isColumn: false,
-										key: 'k8s_volume_type',
+											key: k8sVolumeTypeKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: ['persistentVolumeClaim'],
 									},
 									{
-									id: '34754bda',
+										id: 'c4',
 										key: {
-										key: 'k8s_persistentvolumeclaim_name',
 											dataType: DataTypes.String,
-										type: 'tag',
-										isColumn: false,
-										isJSON: false,
 											id: 'k8s_persistentvolumeclaim_name--string--tag--false',
+											isColumn: false,
+											key: k8sPVCNameKey,
+											type: 'tag',
 										},
 										op: '=',
 										value: volume.persistentVolumeClaimName,
@@ -111,7 +143,7 @@ export const getVolumeQueryPayload = (
 							functions: [],
 							groupBy: [],
 							having: [],
-						legend: '{{k8s_namespace_name}}-{{k8s_pod_name}}',
+							legend: legendTemplate,
 							limit: null,
 							orderBy: [],
 							queryName: 'A',
@@ -123,23 +155,9 @@ export const getVolumeQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -159,7 +177,7 @@ export const getVolumeQueryPayload = (
 								id: 'k8s_volume_capacity--float64--Gauge--true',
 								isColumn: true,
 								isJSON: false,
-							key: 'k8s_volume_capacity',
+								key: k8sVolumeCapacityKey,
 								type: 'Gauge',
 							},
 							aggregateOperator: 'avg',
@@ -169,50 +187,49 @@ export const getVolumeQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '6077fbc2',
+										id: 'c1',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_cluster_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_cluster_name',
+											key: k8sClusterNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: volume.meta.k8s_cluster_name,
 									},
 									{
-									id: '0cdebb88',
+										id: 'c2',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: [volume.meta.k8s_namespace_name],
 									},
 									{
-									id: 'e0e880ce',
+										id: 'c3',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_volume_type--string--tag--false',
 											isColumn: false,
-										key: 'k8s_volume_type',
+											key: k8sVolumeTypeKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: ['persistentVolumeClaim'],
 									},
 									{
-									id: '34754bda',
+										id: 'c4',
 										key: {
-										key: 'k8s_persistentvolumeclaim_name',
 											dataType: DataTypes.String,
-										type: 'tag',
-										isColumn: false,
-										isJSON: false,
 											id: 'k8s_persistentvolumeclaim_name--string--tag--false',
+											isColumn: false,
+											key: k8sPVCNameKey,
+											type: 'tag',
 										},
 										op: '=',
 										value: volume.persistentVolumeClaimName,
@@ -223,7 +240,7 @@ export const getVolumeQueryPayload = (
 							functions: [],
 							groupBy: [],
 							having: [],
-						legend: '{{k8s_namespace_name}}-{{k8s_pod_name}}',
+							legend: legendTemplate,
 							limit: null,
 							orderBy: [],
 							queryName: 'A',
@@ -235,23 +252,9 @@ export const getVolumeQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -270,7 +273,7 @@ export const getVolumeQueryPayload = (
 								dataType: DataTypes.Float64,
 								id: 'k8s_volume_inodes_used--float64----true',
 								isColumn: true,
-							key: 'k8s_volume_inodes_used',
+								key: k8sVolumeInodesUsedKey,
 								type: '',
 							},
 							aggregateOperator: 'avg',
@@ -280,50 +283,49 @@ export const getVolumeQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '6077fbc2',
+										id: 'c1',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_cluster_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_cluster_name',
+											key: k8sClusterNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: volume.meta.k8s_cluster_name,
 									},
 									{
-									id: '46393c61',
+										id: 'c2',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: [volume.meta.k8s_namespace_name],
 									},
 									{
-									id: '450ee3cb',
+										id: 'c3',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_volume_type--string--tag--false',
 											isColumn: false,
-										key: 'k8s_volume_type',
+											key: k8sVolumeTypeKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: ['persistentVolumeClaim'],
 									},
 									{
-									id: '34754bda',
+										id: 'c4',
 										key: {
-										key: 'k8s_persistentvolumeclaim_name',
 											dataType: DataTypes.String,
-										type: 'tag',
-										isColumn: false,
-										isJSON: false,
 											id: 'k8s_persistentvolumeclaim_name--string--tag--false',
+											isColumn: false,
+											key: k8sPVCNameKey,
+											type: 'tag',
 										},
 										op: '=',
 										value: volume.persistentVolumeClaimName,
@@ -333,7 +335,7 @@ export const getVolumeQueryPayload = (
 							},
 							groupBy: [],
 							having: [],
-						legend: '{{k8s_namespace_name}}-{{k8s_pod_name}}',
+							legend: legendTemplate,
 							limit: null,
 							orderBy: [],
 							queryName: 'A',
@@ -346,23 +348,9 @@ export const getVolumeQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -381,7 +369,7 @@ export const getVolumeQueryPayload = (
 								dataType: DataTypes.Float64,
 								id: 'k8s_volume_inodes--float64----true',
 								isColumn: true,
-							key: 'k8s_volume_inodes',
+								key: k8sVolumeInodesKey,
 								type: '',
 							},
 							aggregateOperator: 'avg',
@@ -391,50 +379,49 @@ export const getVolumeQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '6077fbc2',
+										id: 'c1',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_cluster_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_cluster_name',
+											key: k8sClusterNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: volume.meta.k8s_cluster_name,
 									},
 									{
-									id: '5a604bad',
+										id: 'c2',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: [volume.meta.k8s_namespace_name],
 									},
 									{
-									id: '24b074f3',
+										id: 'c3',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_volume_type--string--tag--false',
 											isColumn: false,
-										key: 'k8s_volume_type',
+											key: k8sVolumeTypeKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: ['persistentVolumeClaim'],
 									},
 									{
-									id: '34754bda',
+										id: 'c4',
 										key: {
-										key: 'k8s_persistentvolumeclaim_name',
 											dataType: DataTypes.String,
-										type: 'tag',
-										isColumn: false,
-										isJSON: false,
 											id: 'k8s_persistentvolumeclaim_name--string--tag--false',
+											isColumn: false,
+											key: k8sPVCNameKey,
+											type: 'tag',
 										},
 										op: '=',
 										value: volume.persistentVolumeClaimName,
@@ -444,7 +431,7 @@ export const getVolumeQueryPayload = (
 							},
 							groupBy: [],
 							having: [],
-						legend: '{{k8s_namespace_name}}-{{k8s_pod_name}}',
+							legend: legendTemplate,
 							limit: null,
 							orderBy: [],
 							queryName: 'A',
@@ -457,23 +444,9 @@ export const getVolumeQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -492,7 +465,7 @@ export const getVolumeQueryPayload = (
 								dataType: DataTypes.Float64,
 								id: 'k8s_volume_inodes_free--float64----true',
 								isColumn: true,
-							key: 'k8s_volume_inodes_free',
+								key: k8sVolumeInodesFreeKey,
 								type: '',
 							},
 							aggregateOperator: 'avg',
@@ -502,50 +475,49 @@ export const getVolumeQueryPayload = (
 							filters: {
 								items: [
 									{
-									id: '6077fbc2',
+										id: 'c1',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_cluster_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_cluster_name',
+											key: k8sClusterNameKey,
 											type: 'tag',
 										},
 										op: '=',
 										value: volume.meta.k8s_cluster_name,
 									},
 									{
-									id: '8f01b14d',
+										id: 'c2',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_namespace_name--string--tag--false',
 											isColumn: false,
-										key: 'k8s_namespace_name',
+											key: k8sNamespaceNameKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: [volume.meta.k8s_namespace_name],
 									},
 									{
-									id: 'a72c99da',
+										id: 'c3',
 										key: {
 											dataType: DataTypes.String,
 											id: 'k8s_volume_type--string--tag--false',
 											isColumn: false,
-										key: 'k8s_volume_type',
+											key: k8sVolumeTypeKey,
 											type: 'tag',
 										},
 										op: 'in',
 										value: ['persistentVolumeClaim'],
 									},
 									{
-									id: '34754bda',
+										id: 'c4',
 										key: {
-										key: 'k8s_persistentvolumeclaim_name',
 											dataType: DataTypes.String,
-										type: 'tag',
-										isColumn: false,
-										isJSON: false,
 											id: 'k8s_persistentvolumeclaim_name--string--tag--false',
+											isColumn: false,
+											key: k8sPVCNameKey,
+											type: 'tag',
 										},
 										op: '=',
 										value: volume.persistentVolumeClaimName,
@@ -555,7 +527,7 @@ export const getVolumeQueryPayload = (
 							},
 							groupBy: [],
 							having: [],
-						legend: '{{k8s_namespace_name}}-{{k8s_pod_name}}',
+							legend: legendTemplate,
 							limit: null,
 							orderBy: [],
 							queryName: 'A',
@@ -568,23 +540,9 @@ export const getVolumeQueryPayload = (
 					],
 					queryFormulas: [],
 				},
-			clickhouse_sql: [
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				id: v4(),
-			promql: [
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-				{
-					disabled: false,
-					legend: '',
-					name: 'A',
-					query: '',
-				},
-			],
 				queryType: EQueryType.QUERY_BUILDER,
 			},
 			variables: {},
@@ -593,3 +551,4 @@ export const getVolumeQueryPayload = (
 			end,
 		},
 	];
+};

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/constants.ts

@@ -36,7 +36,7 @@ export const K8sCategories = {
 	VOLUMES: 'volumes',
 };
 
-export const K8sEntityToAggregateAttributeMapping = {
+export const underscoreMap = {
 	[K8sCategory.HOSTS]: 'system_cpu_load_average_15m',
 	[K8sCategory.PODS]: 'k8s_pod_cpu_utilization',
 	[K8sCategory.NODES]: 'k8s_node_cpu_utilization',
@@ -50,20 +50,66 @@ export const K8sEntityToAggregateAttributeMapping = {
 	[K8sCategory.VOLUMES]: 'k8s_volume_capacity',
 };
 
-export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
+export const dotMap = {
+	[K8sCategory.HOSTS]: 'system.cpu.load_average.15m',
+	[K8sCategory.PODS]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.NODES]: 'k8s.node.cpu.utilization',
+	[K8sCategory.NAMESPACES]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.CLUSTERS]: 'k8s.node.cpu.utilization',
+	[K8sCategory.DEPLOYMENTS]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.STATEFULSETS]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.DAEMONSETS]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.CONTAINERS]: 'k8s.pod.cpu.utilization',
+	[K8sCategory.JOBS]: 'k8s.job.desired_successful_pods',
+	[K8sCategory.VOLUMES]: 'k8s.volume.capacity',
+};
+
+export function GetK8sEntityToAggregateAttribute(
+	category: K8sCategory,
+	dotMetricsEnabled: boolean,
+): string {
+	return dotMetricsEnabled ? dotMap[category] : underscoreMap[category];
+}
+
+export function GetPodsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const podKey = dotMetricsEnabled ? 'k8s.pod.name' : 'k8s_pod_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const nodeKey = dotMetricsEnabled ? 'k8s.node.name' : 'k8s_node_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const deploymentKey = dotMetricsEnabled
+		? 'k8s.deployment.name'
+		: 'k8s_deployment_name';
+	const statefulsetKey = dotMetricsEnabled
+		? 'k8s.statefulset.name'
+		: 'k8s_statefulset_name';
+	const daemonsetKey = dotMetricsEnabled
+		? 'k8s.daemonset.name'
+		: 'k8s_daemonset_name';
+	const jobKey = dotMetricsEnabled ? 'k8s.job.name' : 'k8s_job_name';
+
+	// Define aggregate attribute (metric) name
+	const cpuUtilizationMetric = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Pod',
 			attributeKey: {
-			key: 'k8s_pod_name',
+				key: podKey,
 				dataType: DataTypes.String,
 				type: 'tag',
 				isColumn: false,
 				isJSON: false,
-			id: 'k8s_pod_name--string--tag--true',
+				id: `${podKey}--string--tag--true`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -71,14 +117,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${namespaceKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -86,15 +133,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Node',
 			attributeKey: {
-			key: 'k8s_node_name',
+				key: nodeKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
-			id: 'k8s.node.name--string--resource--true',
+				id: `${nodeKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -102,14 +149,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -117,14 +165,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Deployment',
 			attributeKey: {
-			key: 'k8s_deployment_name',
+				key: deploymentKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${deploymentKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -132,14 +181,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Statefulset',
 			attributeKey: {
-			key: 'k8s_statefulset_name',
+				key: statefulsetKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${statefulsetKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -147,14 +197,15 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'DaemonSet',
 			attributeKey: {
-			key: 'k8s_daemonset_name',
+				key: daemonsetKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${daemonsetKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
@@ -162,32 +213,47 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Job',
 			attributeKey: {
-			key: 'k8s_job_name',
+				key: jobKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${jobKey}--string--resource--false`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilizationMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: false,
 		},
 	];
+}
 
-export const NodesQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetNodesQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	// Define attribute keys
+	const nodeKey = dotMetricsEnabled ? 'k8s.node.name' : 'k8s_node_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+
+	// Define aggregate metric name for node CPU utilization
+	const cpuUtilMetric = dotMetricsEnabled
+		? 'k8s.node.cpu.utilization'
+		: 'k8s_node_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Node Name',
 			attributeKey: {
-			key: 'k8s_node_name',
+				key: nodeKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${nodeKey}--string--resource--true`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -195,32 +261,46 @@ export const NodesQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource--true`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const NamespaceQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetNamespaceQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const cpuUtilMetric = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${namespaceKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -228,65 +308,101 @@ export const NamespaceQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const ClustersQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetClustersQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const cpuUtilMetric = dotMetricsEnabled
+		? 'k8s.node.cpu.utilization'
+		: 'k8s_node_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: cpuUtilMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const ContainersQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetContainersQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const containerKey = dotMetricsEnabled
+		? 'k8s.container.name'
+		: 'k8s_container_name';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Container',
 			attributeKey: {
-			key: 'k8s_container_name',
+				key: containerKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${containerKey}--string--resource`,
 			},
 			defaultOpen: true,
 		},
 	];
+}
 
-export const VolumesQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetVolumesQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const pvcKey = dotMetricsEnabled
+		? 'k8s.persistentvolumeclaim.name'
+		: 'k8s_persistentvolumeclaim_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const volumeMetric = dotMetricsEnabled
+		? 'k8s.volume.capacity'
+		: 'k8s_volume_capacity';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'PVC Volume Claim Name',
 			attributeKey: {
-			key: 'k8s_persistentvolumeclaim_name',
+				key: pvcKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${pvcKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_volume_capacity',
+			aggregateAttribute: volumeMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -294,14 +410,15 @@ export const VolumesQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${namespaceKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_volume_capacity',
+			aggregateAttribute: volumeMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -309,32 +426,49 @@ export const VolumesQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_volume_capacity',
+			aggregateAttribute: volumeMetric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const DeploymentsQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetDeploymentsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const deployKey = dotMetricsEnabled
+		? 'k8s.deployment.name'
+		: 'k8s_deployment_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const metric = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Deployment Name',
 			attributeKey: {
-			key: 'k8s_deployment_name',
+				key: deployKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${deployKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -342,14 +476,15 @@ export const DeploymentsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${namespaceKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -357,32 +492,49 @@ export const DeploymentsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const StatefulsetsQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetStatefulsetsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const ssKey = dotMetricsEnabled
+		? 'k8s.statefulset.name'
+		: 'k8s_statefulset_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const metric = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Statefulset Name',
 			attributeKey: {
-			key: 'k8s_statefulset_name',
+				key: ssKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${ssKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -390,14 +542,15 @@ export const StatefulsetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${namespaceKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -405,32 +558,49 @@ export const StatefulsetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${clusterKey}--string--resource`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metric,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const DaemonSetsQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetDaemonsetsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const nameKey = dotMetricsEnabled
+		? 'k8s.daemonset.name'
+		: 'k8s_daemonset_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const metricName = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'DaemonSet Name',
 			attributeKey: {
-			key: 'k8s_daemonset_name',
+				key: nameKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${nameKey}--string--resource--true`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -438,14 +608,14 @@ export const DaemonSetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -453,32 +623,46 @@ export const DaemonSetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
-export const JobsQuickFiltersConfig: IQuickFiltersConfig[] = [
+export function GetJobsQuickFiltersConfig(
+	dotMetricsEnabled: boolean,
+): IQuickFiltersConfig[] {
+	const nameKey = dotMetricsEnabled ? 'k8s.job.name' : 'k8s_job_name';
+	const namespaceKey = dotMetricsEnabled
+		? 'k8s.namespace.name'
+		: 'k8s_namespace_name';
+	const clusterKey = dotMetricsEnabled ? 'k8s.cluster.name' : 'k8s_cluster_name';
+	const metricName = dotMetricsEnabled
+		? 'k8s.pod.cpu.utilization'
+		: 'k8s_pod_cpu_utilization';
+
+	return [
 		{
 			type: FiltersType.CHECKBOX,
 			title: 'Job Name',
 			attributeKey: {
-			key: 'k8s_job_name',
+				key: nameKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
+				id: `${nameKey}--string--resource--true`,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -486,14 +670,14 @@ export const JobsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Namespace Name',
 			attributeKey: {
-			key: 'k8s_namespace_name',
+				key: namespaceKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
@@ -501,18 +685,19 @@ export const JobsQuickFiltersConfig: IQuickFiltersConfig[] = [
 			type: FiltersType.CHECKBOX,
 			title: 'Cluster Name',
 			attributeKey: {
-			key: 'k8s_cluster_name',
+				key: clusterKey,
 				dataType: DataTypes.String,
 				type: 'resource',
 				isColumn: false,
 				isJSON: false,
 			},
 			aggregateOperator: 'noop',
-		aggregateAttribute: 'k8s_pod_cpu_utilization',
+			aggregateAttribute: metricName,
 			dataSource: DataSource.METRICS,
 			defaultOpen: true,
 		},
 	];
+}
 
 export const getInvalidValueTooltipText = (
 	entity: K8sCategory,

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/ListOfDashboard/DashboardsList.tsx

@@ -22,7 +22,7 @@ import {
 } from 'antd';
 import { TableProps } from 'antd/lib';
 import logEvent from 'api/common/logEvent';
-import createDashboard from 'api/dashboard/create';
+import createDashboard from 'api/v1/dashboards/create';
 import { AxiosError } from 'axios';
 import cx from 'classnames';
 import { ENTITY_VERSION_V4 } from 'constants/app';
@@ -63,6 +63,7 @@ import {
 import { handleContactSupport } from 'pages/Integrations/utils';
 import { useAppContext } from 'providers/App/App';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { useTimezone } from 'providers/Timezone';
 import {
 	ChangeEvent,
@@ -83,6 +84,7 @@ import {
 	WidgetRow,
 	Widgets,
 } from 'types/api/dashboard/getAll';
+import APIError from 'types/api/error';
 
 import DashboardTemplatesModal from './DashboardTemplates/DashboardTemplatesModal';
 import ImportJSON from './ImportJSON';
@@ -226,7 +228,7 @@ function DashboardsList(): JSX.Element {
 	useEffect(() => {
 		const filteredDashboards = filterDashboard(
 			searchString,
-			dashboardListResponse || [],
+			dashboardListResponse?.data || [],
 		);
 		if (sortOrder.columnKey === 'updatedAt') {
 			sortDashboardsByUpdatedAt(filteredDashboards || []);
@@ -256,17 +258,19 @@ function DashboardsList(): JSX.Element {
 		errorMessage: '',
 	});
 
+	const { showErrorModal } = useErrorModal();
+
 	const data: Data[] =
 		dashboards?.map((e) => ({
 			createdAt: e.createdAt,
 			description: e.data.description || '',
-			id: e.uuid,
+			id: e.id,
 			lastUpdatedTime: e.updatedAt,
 			name: e.data.title,
 			tags: e.data.tags || [],
-			key: e.uuid,
+			key: e.id,
 			createdBy: e.createdBy,
-			isLocked: !!e.isLocked || false,
+			isLocked: !!e.locked || false,
 			lastUpdatedBy: e.updatedBy,
 			image: e.data.image || Base64Icons[0],
 			variables: e.data.variables,
@@ -292,28 +296,20 @@ function DashboardsList(): JSX.Element {
 				version: ENTITY_VERSION_V4,
 			});
 
-			if (response.statusCode === 200) {
 			safeNavigate(
 				generatePath(ROUTES.DASHBOARD, {
-						dashboardId: response.payload.uuid,
+					dashboardId: response.data.id,
 				}),
 			);
-			} else {
-				setNewDashboardState({
-					...newDashboardState,
-					loading: false,
-					error: true,
-					errorMessage: response.error || 'Something went wrong',
-				});
-			}
 		} catch (error) {
+			showErrorModal(error as APIError);
 			setNewDashboardState({
 				...newDashboardState,
 				error: true,
 				errorMessage: (error as AxiosError).toString() || 'Something went Wrong',
 			});
 		}
-	}, [newDashboardState, safeNavigate, t]);
+	}, [newDashboardState, safeNavigate, showErrorModal, t]);
 
 	const onModalHandler = (uploadedGrafana: boolean): void => {
 		logEvent('Dashboard List: Import JSON clicked', {});
@@ -327,7 +323,7 @@ function DashboardsList(): JSX.Element {
 		const searchText = (event as React.BaseSyntheticEvent)?.target?.value || '';
 		const filteredDashboards = filterDashboard(
 			searchText,
-			dashboardListResponse || [],
+			dashboardListResponse?.data || [],
 		);
 		setDashboards(filteredDashboards);
 		setIsFilteringDashboards(false);
@@ -677,7 +673,7 @@ function DashboardsList(): JSX.Element {
 			!isUndefined(dashboardListResponse)
 		) {
 			logEvent('Dashboard List: Page visited', {
-				number: dashboardListResponse?.length,
+				number: dashboardListResponse?.data?.length,
 			});
 			logEventCalledRef.current = true;
 		}

frontend/src/container/ListOfDashboard/ImportJSON/index.tsx

@@ -14,19 +14,21 @@ import {
 	UploadProps,
 } from 'antd';
 import logEvent from 'api/common/logEvent';
-import createDashboard from 'api/dashboard/create';
+import createDashboard from 'api/v1/dashboards/create';
 import ROUTES from 'constants/routes';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { getUpdatedLayout } from 'lib/dashboard/getUpdatedLayout';
 import { ExternalLink, Github, MonitorDot, MoveRight, X } from 'lucide-react';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 // #TODO: Lucide will be removing brand icons like GitHub in the future. In that case, we can use Simple Icons. https://simpleicons.org/
 // See more: https://github.com/lucide-icons/lucide/issues/94
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { generatePath } from 'react-router-dom';
 import { DashboardData } from 'types/api/dashboard/getAll';
+import APIError from 'types/api/error';
 
 function ImportJSON({
 	isImportJSONModalVisible,
@@ -74,6 +76,8 @@ function ImportJSON({
 		}
 	};
 
+	const { showErrorModal } = useErrorModal();
+
 	const onClickLoadJsonHandler = async (): Promise<void> => {
 		try {
 			setDashboardCreating(true);
@@ -81,11 +85,6 @@ function ImportJSON({
 
 			const dashboardData = JSON.parse(editorValue) as DashboardData;
 
-			// Remove uuid from the dashboard data, in all cases - empty, duplicate or any valid not duplicate uuid
-			if (dashboardData.uuid !== undefined) {
-				delete dashboardData.uuid;
-			}
-
 			if (dashboardData?.layout) {
 				dashboardData.layout = getUpdatedLayout(dashboardData.layout);
 			} else {
@@ -97,28 +96,19 @@ function ImportJSON({
 				uploadedGrafana,
 			});
 
-			if (response.statusCode === 200) {
 			safeNavigate(
 				generatePath(ROUTES.DASHBOARD, {
-						dashboardId: response.payload.uuid,
+					dashboardId: response.data.id,
 				}),
 			);
 			logEvent('Dashboard List: New dashboard imported successfully', {
-					dashboardId: response.payload?.uuid,
+				dashboardId: response.data?.id,
-					dashboardName: response.payload?.data?.title,
+				dashboardName: response.data?.data?.title,
 			});
-			} else {
+
-				setIsCreateDashboardError(true);
-				notifications.error({
-					message:
-						response.error ||
-						t('something_went_wrong', {
-							ns: 'common',
-						}),
-				});
-			}
 			setDashboardCreating(false);
 		} catch (error) {
+			showErrorModal(error as APIError);
 			setDashboardCreating(false);
 			setIsCreateDashboardError(true);
 			notifications.error({

frontend/src/container/ListOfDashboard/SearchFilter/__tests__/utils.test.ts

@@ -6,8 +6,7 @@ import { executeSearchQueries } from '../utils';
 
 describe('executeSearchQueries', () => {
 	const firstDashboard: Dashboard = {
-		id: 11111,
+		id: uuid(),
-		uuid: uuid(),
 		createdAt: '',
 		updatedAt: '',
 		createdBy: '',
@@ -18,8 +17,7 @@ describe('executeSearchQueries', () => {
 		},
 	};
 	const secondDashboard: Dashboard = {
-		id: 22222,
+		id: uuid(),
-		uuid: uuid(),
 		createdAt: '',
 		updatedAt: '',
 		createdBy: '',
@@ -30,8 +28,7 @@ describe('executeSearchQueries', () => {
 		},
 	};
 	const thirdDashboard: Dashboard = {
-		id: 333333,
+		id: uuid(),
-		uuid: uuid(),
 		createdAt: '',
 		updatedAt: '',
 		createdBy: '',

frontend/src/container/ListOfDashboard/TableComponents/DeleteButton.tsx

@@ -59,7 +59,7 @@ export function DeleteButton({
 				onClick: (e) => {
 					e.preventDefault();
 					e.stopPropagation();
-					deleteDashboardMutation.mutateAsync(undefined, {
+					deleteDashboardMutation.mutate(undefined, {
 						onSuccess: () => {
 							notifications.success({
 								message: t('dashboard:delete_dashboard_success', {

frontend/src/container/ListOfDashboard/dashboardSearchAndFilter.ts

@@ -14,7 +14,7 @@ export const generateSearchData = (
 
 	dashboards.forEach((dashboard) => {
 		dashboardSearchData.push({
-			id: dashboard.uuid,
+			id: dashboard.id,
 			title: dashboard.data.title,
 			description: dashboard.data.description,
 			tags: dashboard.data.tags || [],

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);
+		return getHostQueryPayload(hostName, start, end, dotMetricsEnabled);
-	}, [nodeName, hostName, clusterName, start, end]);
+	}, [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),
+		() => getPodQueryPayload(clusterName, podName, start, end, dotMetricsEnabled),
-		[clusterName, end, podName, start],
+		[clusterName, end, podName, start, dotMetricsEnabled],
 	);
 	const queries = useQueries(
 		queryPayloads.map((payload) => ({

frontend/src/container/LogDetailedView/TableView/TableViewActions.tsx

@@ -21,8 +21,10 @@ import { FORBID_DOM_PURIFY_TAGS } from 'utils/app';
 
 import { DataType } from '../TableView';
 import {
+	escapeHtml,
 	filterKeyForField,
 	jsonToDataNodes,
+	parseFieldValue,
 	recursiveParseJSON,
 	removeEscapeCharacters,
 	unescapeString,
@@ -85,7 +87,7 @@ export function TableViewActions(
 		record.field === 'body'
 			? {
 					__html: convert.toHtml(
-						dompurify.sanitize(unescapeString(record.value), {
+						dompurify.sanitize(unescapeString(escapeHtml(record.value)), {
 							FORBID_TAGS: [...FORBID_DOM_PURIFY_TAGS],
 						}),
 					),
@@ -155,7 +157,11 @@ export function TableViewActions(
 									<ArrowDownToDot size={14} style={{ transform: 'rotate(90deg)' }} />
 								)
 							}
-							onClick={onClickHandler(OPERATORS['='], fieldFilterKey, fieldData.value)}
+							onClick={onClickHandler(
+								OPERATORS['='],
+								fieldFilterKey,
+								parseFieldValue(fieldData.value),
+							)}
 						/>
 					</Tooltip>
 					<Tooltip title="Filter out value">
@@ -171,7 +177,7 @@ export function TableViewActions(
 							onClick={onClickHandler(
 								OPERATORS['!='],
 								fieldFilterKey,
-								fieldData.value,
+								parseFieldValue(fieldData.value),
 							)}
 						/>
 					</Tooltip>

frontend/src/container/LogDetailedView/utils.tsx

@@ -259,6 +259,24 @@ export const getDataTypes = (value: unknown): DataTypes => {
 	return determineType(value);
 };
 
+// prevent html rendering in the value
+export const escapeHtml = (unsafe: string): string =>
+	unsafe
+		.replace(/&/g, '&')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&#039;');
+
+// parse field value to remove escaping characters
+export const parseFieldValue = (value: string): string => {
+	try {
+		return JSON.parse(value);
+	} catch (error) {
+		return value;
+	}
+};
+
 // now we do not want to render colors everywhere like in tooltip and monaco editor hence we remove such codes to make
 // the log line readable
 export const removeEscapeCharacters = (str: string): string =>

frontend/src/container/LogsExplorerViews/index.tsx

@@ -28,16 +28,12 @@ import LogsExplorerTable from 'container/LogsExplorerTable';
 import { useOptionsMenu } from 'container/OptionsMenu';
 import TimeSeriesView from 'container/TimeSeriesView/TimeSeriesView';
 import dayjs from 'dayjs';
-import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
-import { addEmptyWidgetInDashboardJSONWithQuery } from 'hooks/dashboard/utils';
 import { useCopyLogLink } from 'hooks/logs/useCopyLogLink';
 import { useGetExplorerQueryRange } from 'hooks/queryBuilder/useGetExplorerQueryRange';
 import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import useAxiosError from 'hooks/useAxiosError';
 import useClickOutside from 'hooks/useClickOutside';
 import { useHandleExplorerTabChange } from 'hooks/useHandleExplorerTabChange';
-import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQueryData from 'hooks/useUrlQueryData';
 import { FlatLogData } from 'lib/logs/flatLogData';
@@ -98,7 +94,6 @@ function LogsExplorerViews({
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	chartQueryKeyRef: MutableRefObject<any>;
 }): JSX.Element {
-	const { notifications } = useNotifications();
 	const { safeNavigate } = useSafeNavigate();
 
 	// this is to respect the panel type present in the URL rather than defaulting it to list always.
@@ -141,8 +136,6 @@ function LogsExplorerViews({
 	const [queryId, setQueryId] = useState<string>(v4());
 	const [queryStats, setQueryStats] = useState<WsDataEvent>();
 
-	const handleAxisError = useAxiosError();
-
 	const listQuery = useMemo(() => {
 		if (!stagedQuery || stagedQuery.builder.queryData.length < 1) return null;
 
@@ -396,11 +389,6 @@ function LogsExplorerViews({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [data?.payload]);
 
-	const {
-		mutate: updateDashboard,
-		isLoading: isUpdateDashboardLoading,
-	} = useUpdateDashboard();
-
 	const getUpdatedQueryForExport = useCallback((): Query => {
 		const updatedQuery = cloneDeep(currentQuery);
 
@@ -424,68 +412,22 @@ function LogsExplorerViews({
 					? getUpdatedQueryForExport()
 					: exportDefaultQuery;
 
-			const updatedDashboard = addEmptyWidgetInDashboardJSONWithQuery(
-				dashboard,
-				query,
-				widgetId,
-				panelTypeParam,
-				options.selectColumns,
-			);
-
 			logEvent('Logs Explorer: Add to dashboard successful', {
 				panelType,
 				isNewDashboard,
 				dashboardName: dashboard?.data?.title,
 			});
 
-			updateDashboard(updatedDashboard, {
-				onSuccess: (data) => {
-					if (data.error) {
-						const message =
-							data.error === 'feature usage exceeded' ? (
-								<span>
-									Panel limit exceeded for {DataSource.LOGS} in community edition. Please
-									checkout our paid plans{' '}
-									<a
-										href="https://signoz.io/pricing/?utm_source=product&utm_medium=dashboard-limit"
-										rel="noreferrer noopener"
-										target="_blank"
-									>
-										here
-									</a>
-								</span>
-							) : (
-								data.error
-							);
-						notifications.error({
-							message,
-						});
-
-						return;
-					}
-
 			const dashboardEditView = generateExportToDashboardLink({
 				query,
 				panelType: panelTypeParam,
-						dashboardId: data.payload?.uuid || '',
+				dashboardId: dashboard.id,
 				widgetId,
 			});
 
 			safeNavigate(dashboardEditView);
 		},
-				onError: handleAxisError,
+		[getUpdatedQueryForExport, exportDefaultQuery, safeNavigate, panelType],
-			});
-		},
-		[
-			getUpdatedQueryForExport,
-			exportDefaultQuery,
-			options.selectColumns,
-			safeNavigate,
-			notifications,
-			panelType,
-			updateDashboard,
-			handleAxisError,
-		],
 	);
 
 	useEffect(() => {
@@ -811,7 +753,6 @@ function LogsExplorerViews({
 			<ExplorerOptionWrapper
 				disabled={!stagedQuery}
 				query={exportDefaultQuery}
-				isLoading={isUpdateDashboardLoading}
 				onExport={handleExport}
 				sourcepage={DataSource.LOGS}
 			/>

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,