refactor(infra-monitoring): remove dead-code

frontend/package.json

@@ -54,7 +54,7 @@
     "@signozhq/checkbox": "0.0.2",
     "@signozhq/combobox": "0.0.2",
     "@signozhq/command": "0.0.0",
-    "@signozhq/design-tokens": "2.1.1",
+    "@signozhq/design-tokens": "2.1.4",
     "@signozhq/dialog": "^0.0.2",
     "@signozhq/drawer": "0.0.4",
     "@signozhq/icons": "0.1.0",

frontend/src/api/infraMonitoring/getK8sNodesList.ts

@@ -1,127 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-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[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
-
-export interface K8sNodesData {
-	nodeUID: string;
-	nodeCPUUsage: number;
-	nodeCPUAllocatable: number;
-	nodeMemoryUsage: number;
-	nodeMemoryAllocatable: number;
-	meta: {
-		k8s_node_name: string;
-		k8s_node_uid: string;
-		k8s_cluster_name: string;
-	};
-}
-
-export interface K8sNodesListResponse {
-	status: string;
-	data: {
-		type: string;
-		records: K8sNodesData[];
-		groups: null;
-		total: number;
-		sentAnyHostMetricsData: boolean;
-		isSendingK8SAgentMetrics: boolean;
-	};
-}
-
-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 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,
-			params: requestProps,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};

frontend/src/container/InfraMonitoringK8s/Base/K8sBaseDetails.tsx

@@ -1,12 +1,10 @@
-/* eslint-disable sonarjs/no-identical-functions */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useQuery } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
 import logEvent from 'api/common/logEvent';
-import { K8sPodsData } from 'api/infraMonitoring/getK8sPodsList';
 import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
 import { InfraMonitoringEvents } from 'constants/events';
 import { QueryParams } from 'constants/query';
@@ -15,21 +13,13 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
 import {
 	CustomTimeType,
 	Time,
 } from 'container/TopNav/DateTimeSelectionV2/types';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import useUrlQuery from 'hooks/useUrlQuery';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import GetMinMax from 'lib/getMinMax';
 import {
 	BarChart2,
@@ -39,48 +29,133 @@ import {
 	ScrollText,
 	X,
 } from 'lucide-react';
-import { AppState } from 'store/reducers';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import {
 	IBuilderQuery,
+	TagFilter,
 	TagFilterItem,
 } from 'types/api/queryBuilder/queryBuilderData';
 import {
 	LogsAggregatorOperator,
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
 import { v4 as uuidv4 } from 'uuid';
 
-import PodEvents from '../../EntityDetailsUtils/EntityEvents';
-import PodLogs from '../../EntityDetailsUtils/EntityLogs';
-import PodMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import PodTraces from '../../EntityDetailsUtils/EntityTraces';
-import { getPodMetricsQueryPayload, podWidgetInfo } from './constants';
-import { PodDetailProps } from './PodDetail.interfaces';
+import {
+	isCustomTimeRange,
+	useGlobalTimeStore,
+} from '../../../store/globalTime';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from '../../../store/globalTime/utils';
+import { DEFAULT_TIME_RANGE } from '../../TopNav/DateTimeSelectionV2/constants';
+import { filterDuplicateFilters } from '../commonUtils';
+import { K8sCategory } from '../constants';
+import EntityEvents from '../EntityDetailsUtils/EntityEvents';
+import EntityLogs from '../EntityDetailsUtils/EntityLogs';
+import EntityMetrics from '../EntityDetailsUtils/EntityMetrics';
+import EntityTraces from '../EntityDetailsUtils/EntityTraces';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import {
+	useInfraMonitoringEventsFilters,
+	useInfraMonitoringLogFilters,
+	useInfraMonitoringSelectedItem,
+	useInfraMonitoringTracesFilters,
+	useInfraMonitoringView,
+} from '../hooks';
+import LoadingContainer from '../LoadingContainer';
 
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
+import '../EntityDetailsUtils/entityDetails.styles.scss';
 
 const TimeRangeOffset = 1000000000;
 
-function PodDetails({
-	pod,
-	onClose,
-	isModalTimeSelection,
-}: PodDetailProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
+export interface K8sDetailsMetadataConfig<T> {
+	label: string;
+	getValue: (entity: T) => string;
+}
 
-	const startMs = useMemo(() => Math.floor(Number(minTime) / TimeRangeOffset), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / TimeRangeOffset), [
-		maxTime,
-	]);
+export interface K8sDetailsFilters {
+	filters: TagFilter;
+	start: number;
+	end: number;
+}
 
-	const urlQuery = useUrlQuery();
+export interface K8sBaseDetailsProps<T> {
+	category: K8sCategory;
+	eventCategory: string;
+	// Data fetching configuration
+	getSelectedItemFilters: (selectedItem: string) => TagFilter;
+	fetchEntityData: (
+		filters: K8sDetailsFilters,
+		signal?: AbortSignal,
+	) => Promise<{ data: T | null; error?: string | null }>;
+	// Entity configuration
+	getEntityName: (entity: T) => string;
+	getInitialLogTracesFilters: (entity: T) => TagFilterItem[];
+	getInitialEventsFilters: (entity: T) => TagFilterItem[];
+	primaryFilterKeys: string[];
+	metadataConfig: K8sDetailsMetadataConfig<T>[];
+	entityWidgetInfo: {
+		title: string;
+		yAxisUnit: string;
+	}[];
+	getEntityQueryPayload: (
+		entity: T,
+		start: number,
+		end: number,
+		dotMetricsEnabled: boolean,
+	) => GetQueryResultsProps[];
+	queryKeyPrefix: string;
+	/** When true, only metrics are shown and the Metrics/Logs/Traces/Events tab bar is hidden. */
+	hideDetailViewTabs?: boolean;
+}
+
+export function createFilterItem(
+	key: string,
+	value: string,
+	dataType: DataTypes = DataTypes.String,
+): TagFilterItem {
+	return {
+		id: uuidv4(),
+		key: {
+			key,
+			dataType,
+			type: 'resource',
+			id: `${key}--string--resource--false`,
+		},
+		op: '=',
+		value,
+	};
+}
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function K8sBaseDetails<T>({
+	category,
+	eventCategory,
+	getSelectedItemFilters,
+	fetchEntityData,
+	getEntityName,
+	getInitialLogTracesFilters,
+	getInitialEventsFilters,
+	primaryFilterKeys,
+	metadataConfig,
+	entityWidgetInfo,
+	getEntityQueryPayload,
+	queryKeyPrefix,
+	hideDetailViewTabs = false,
+}: K8sBaseDetailsProps<T>): JSX.Element {
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const { startMs, endMs } = useMemo(() => {
+		const { minTime: startNs, maxTime: endNs } = getMinMaxTime(selectedTime);
+
+		return {
+			startMs: Math.floor(startNs / NANO_SECOND_MULTIPLIER),
+			endMs: Math.floor(endNs / NANO_SECOND_MULTIPLIER),
+		};
+	}, [getMinMaxTime, selectedTime]);
 
 	const [modalTimeRange, setModalTimeRange] = useState(() => ({
 		startTime: startMs,
@@ -88,14 +163,17 @@ function PodDetails({
 	}));
 
 	const lastSelectedInterval = useRef<Time | null>(null);
-
 	const [selectedInterval, setSelectedInterval] = useState<Time>(
 		lastSelectedInterval.current
 			? lastSelectedInterval.current
-			: (selectedTime as Time),
+			: isCustomTimeRange(selectedTime)
+			? DEFAULT_TIME_RANGE
+			: selectedTime,
 	);
 
 	const [selectedView, setSelectedView] = useInfraMonitoringView();
+	const effectiveView = hideDetailViewTabs ? VIEW_TYPES.METRICS : selectedView;
+
 	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
 	const [
 		tracesFiltersParam,
@@ -107,79 +185,89 @@ function PodDetails({
 	] = useInfraMonitoringEventsFilters();
 	const isDarkMode = useIsDarkMode();
 
+	const [selectedItem, setSelectedItem] = useInfraMonitoringSelectedItem();
+	const urlQuery = useUrlQuery();
+
+	useEffect(() => {
+		if (
+			hideDetailViewTabs &&
+			selectedItem &&
+			selectedView !== VIEW_TYPES.METRICS
+		) {
+			setSelectedView(VIEW_TYPES.METRICS);
+		}
+	}, [hideDetailViewTabs, selectedItem, selectedView, setSelectedView]);
+
+	const entityQueryKey = useMemo(
+		() =>
+			getAutoRefreshQueryKey(
+				selectedTime,
+				`${queryKeyPrefix}EntityDetails`,
+				selectedItem,
+			),
+		[queryKeyPrefix, selectedItem, selectedTime],
+	);
+
+	const {
+		data: entityResponse,
+		isLoading: isEntityLoading,
+		isError: isEntityError,
+	} = useQuery({
+		queryKey: entityQueryKey,
+		queryFn: ({ signal }) => {
+			if (!selectedItem) {
+				return { data: null };
+			}
+			const filters = getSelectedItemFilters(selectedItem);
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchEntityData(
+				{
+					filters,
+					start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
+					end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
+				},
+				signal,
+			);
+		},
+		enabled: !!selectedItem,
+	});
+
+	const entity = entityResponse?.data ?? null;
+
 	const initialFilters = useMemo(() => {
 		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+			effectiveView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
 		if (filters) {
 			return filters;
 		}
+		if (!entity) {
+			return { op: 'AND', items: [] };
+		}
 		return {
 			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_POD_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_pod_name--string--resource--false',
-					},
-					op: '=',
-					value: pod?.meta.k8s_pod_name || '',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_pod_name--string--resource--false',
-					},
-					op: '=',
-					value: pod?.meta.k8s_namespace_name || '',
-				},
-			],
+			items: getInitialLogTracesFilters(entity),
 		};
 	}, [
-		pod?.meta.k8s_namespace_name,
-		pod?.meta.k8s_pod_name,
-		selectedView,
+		entity,
+		effectiveView,
 		logFiltersParam,
 		tracesFiltersParam,
+		getInitialLogTracesFilters,
 	]);
 
 	const initialEventsFilters = useMemo(() => {
 		if (eventsFiltersParam) {
 			return eventsFiltersParam;
 		}
+		if (!entity) {
+			return { op: 'AND', items: [] };
+		}
 		return {
 			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Pod',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: pod?.meta.k8s_pod_name || '',
-				},
-			],
+			items: getInitialEventsFilters(entity),
 		};
-	}, [pod?.meta.k8s_pod_name, eventsFiltersParam]);
+	}, [entity, eventsFiltersParam, getInitialEventsFilters]);
 
 	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -190,14 +278,14 @@ function PodDetails({
 	);
 
 	useEffect(() => {
-		if (pod) {
+		if (entity) {
 			logEvent(InfraMonitoringEvents.PageVisited, {
 				entity: InfraMonitoringEvents.K8sEntity,
 				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Pod,
+				category: eventCategory,
 			});
 		}
-	}, [pod]);
+	}, [entity, eventCategory]);
 
 	useEffect(() => {
 		setLogsAndTracesFilters(initialFilters);
@@ -206,17 +294,16 @@ function PodDetails({
 
 	useEffect(() => {
 		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
+		if (!isCustomTimeRange(currentSelectedInterval)) {
+			setSelectedInterval(currentSelectedInterval);
+			const { minTime, maxTime } = getMinMaxTime();
 
 			setModalTimeRange({
-				startTime: Math.floor(minTime / TimeRangeOffset),
-				endTime: Math.floor(maxTime / TimeRangeOffset),
+				startTime: minTime / TimeRangeOffset,
+				endTime: maxTime / TimeRangeOffset,
 			});
 		}
-	}, [selectedTime, minTime, maxTime]);
+	}, [getMinMaxTime, selectedTime]);
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
@@ -226,7 +313,7 @@ function PodDetails({
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Pod,
+			category: eventCategory,
 			view: e.target.value,
 		});
 	};
@@ -253,38 +340,34 @@ function PodDetails({
 			logEvent(InfraMonitoringEvents.TimeUpdated, {
 				entity: InfraMonitoringEvents.K8sEntity,
 				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Pod,
+				category: eventCategory,
 				interval,
-				view: selectedView,
+				view: effectiveView,
 			});
 		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
+		[eventCategory, effectiveView],
 	);
 
 	const handleChangeLogFilters = useCallback(
 		(value: IBuilderQuery['filters'], view: VIEWS) => {
 			setLogsAndTracesFilters((prevFilters) => {
 				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[
-						QUERY_KEYS.K8S_POD_NAME,
-						QUERY_KEYS.K8S_CLUSTER_NAME,
-						QUERY_KEYS.K8S_NAMESPACE_NAME,
-					].includes(item.key?.key ?? ''),
+					primaryFilterKeys.includes(item.key?.key ?? ''),
 				);
 				const paginationFilter = value?.items?.find(
 					(item) => item.key?.key === 'id',
 				);
 				const newFilters = value?.items?.filter(
 					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
+						item.key?.key !== 'id' &&
+						!primaryFilterKeys.includes(item.key?.key ?? ''),
 				);
 
 				if (newFilters && newFilters?.length > 0) {
 					logEvent(InfraMonitoringEvents.FilterApplied, {
 						entity: InfraMonitoringEvents.K8sEntity,
 						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Pod,
+						category: eventCategory,
 						view: selectedView,
 					});
 				}
@@ -306,26 +389,27 @@ function PodDetails({
 				return updatedFilters;
 			});
 		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
+		[
+			setLogFiltersParam,
+			setSelectedView,
+			primaryFilterKeys,
+			eventCategory,
+			selectedView,
+		],
 	);
 
 	const handleChangeTracesFilters = useCallback(
 		(value: IBuilderQuery['filters'], view: VIEWS) => {
 			setLogsAndTracesFilters((prevFilters) => {
 				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[
-						QUERY_KEYS.K8S_POD_NAME,
-						QUERY_KEYS.K8S_CLUSTER_NAME,
-						QUERY_KEYS.K8S_NAMESPACE_NAME,
-					].includes(item.key?.key ?? ''),
+					primaryFilterKeys.includes(item.key?.key ?? ''),
 				);
 
 				if (value?.items && value?.items?.length > 0) {
 					logEvent(InfraMonitoringEvents.FilterApplied, {
 						entity: InfraMonitoringEvents.K8sEntity,
 						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Pod,
+						category: eventCategory,
 						view: selectedView,
 					});
 				}
@@ -336,7 +420,7 @@ function PodDetails({
 						[
 							...(primaryFilters || []),
 							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_POD_NAME,
+								(item) => !primaryFilterKeys.includes(item.key?.key ?? ''),
 							) || []),
 						].filter((item): item is TagFilterItem => item !== undefined),
 					),
@@ -348,17 +432,22 @@ function PodDetails({
 				return updatedFilters;
 			});
 		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
+		[
+			setTracesFiltersParam,
+			setSelectedView,
+			primaryFilterKeys,
+			eventCategory,
+			selectedView,
+		],
 	);
 
 	const handleChangeEventsFilters = useCallback(
 		(value: IBuilderQuery['filters'], view: VIEWS) => {
 			setEventsFilters((prevFilters) => {
-				const podKindFilter = prevFilters?.items?.find(
+				const kindFilter = prevFilters?.items?.find(
 					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
 				);
-				const podNameFilter = prevFilters?.items?.find(
+				const nameFilter = prevFilters?.items?.find(
 					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
 				);
 
@@ -366,22 +455,24 @@ function PodDetails({
 					logEvent(InfraMonitoringEvents.FilterApplied, {
 						entity: InfraMonitoringEvents.K8sEntity,
 						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Pod,
+						category: eventCategory,
 						view: selectedView,
 					});
 				}
 
 				const updatedFilters = {
 					op: 'AND',
-					items: [
-						podKindFilter,
-						podNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
+					items: filterDuplicateFilters(
+						[
+							kindFilter,
+							nameFilter,
+							...(value?.items?.filter(
+								(item) =>
+									item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
+									item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
+							) || []),
+						].filter((item): item is TagFilterItem => item !== undefined),
+					),
 				};
 
 				setEventsFiltersParam(updatedFilters);
@@ -390,8 +481,7 @@ function PodDetails({
 				return updatedFilters;
 			});
 		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
+		[eventCategory, selectedView, setEventsFiltersParam, setSelectedView],
 	);
 
 	const handleExplorePagesRedirect = (): void => {
@@ -406,7 +496,7 @@ function PodDetails({
 		logEvent(InfraMonitoringEvents.ExploreClicked, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Pod,
+			category: eventCategory,
 			view: selectedView,
 		});
 
@@ -476,24 +566,28 @@ function PodDetails({
 				endTime: Math.floor(maxTime / TimeRangeOffset),
 			});
 		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
+
+		setSelectedItem(null);
+		setSelectedView(null);
+		setTracesFiltersParam(null);
+		setEventsFiltersParam(null);
+		setLogFiltersParam(null);
 	};
 
+	const entityName = entity ? getEntityName(entity) : '';
+
 	return (
 		<Drawer
 			width="70%"
 			title={
 				<>
 					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{pod?.meta.k8s_pod_name}
-					</Typography.Text>
+					<Typography.Text className="title">{entityName}</Typography.Text>
 				</>
 			}
 			placement="right"
 			onClose={handleClose}
-			open={!!pod}
+			open={!!selectedItem}
 			style={{
 				overscrollBehavior: 'contain',
 				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
@@ -502,173 +596,157 @@ function PodDetails({
 			destroyOnClose
 			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
 		>
-			{pod && (
+			{isEntityLoading && <LoadingContainer />}
+			{isEntityError && (
+				<Typography.Text type="danger">
+					{entityResponse?.error || 'Failed to load entity details'}
+				</Typography.Text>
+			)}
+			{entity && !isEntityLoading && (
 				<>
 					<div className="entity-detail-drawer__entity">
 						<div className="entity-details-grid">
 							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									NAMESPACE
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Node
-								</Typography.Text>
+								{metadataConfig.map((config) => (
+									<Typography.Text
+										key={config.label}
+										type="secondary"
+										className="entity-details-metadata-label"
+									>
+										{config.label}
+									</Typography.Text>
+								))}
 							</div>
 
 							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={pod.meta.k8s_namespace_name}>
-										{pod.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={pod.meta.k8s_cluster_name}>
-										{pod.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={pod.meta.k8s_node_name}>
-										{pod.meta.k8s_node_name}
-									</Tooltip>
-								</Typography.Text>
+								{metadataConfig.map((config) => {
+									const value = config.getValue(entity);
+									return (
+										<Typography.Text
+											key={config.label}
+											className="entity-details-metadata-value"
+										>
+											<Tooltip title={value}>{value}</Tooltip>
+										</Typography.Text>
+									);
+								})}
 							</div>
 						</div>
 					</div>
 
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
+					{!hideDetailViewTabs && (
+						<div className="views-tabs-container">
+							<Radio.Group
+								className="views-tabs"
+								onChange={handleTabChange}
+								value={selectedView}
 							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
+								<Radio.Button
+									className={
+										selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
+									}
+									value={VIEW_TYPES.METRICS}
+								>
+									<div className="view-title">
+										<BarChart2 size={14} />
+										Metrics
+									</div>
+								</Radio.Button>
+								<Radio.Button
+									className={
+										selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
+									}
+									value={VIEW_TYPES.LOGS}
+								>
+									<div className="view-title">
+										<ScrollText size={14} />
+										Logs
+									</div>
+								</Radio.Button>
+								<Radio.Button
+									className={
+										selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
+									}
+									value={VIEW_TYPES.TRACES}
+								>
+									<div className="view-title">
+										<DraftingCompass size={14} />
+										Traces
+									</div>
+								</Radio.Button>
+								<Radio.Button
+									className={
+										selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
+									}
+									value={VIEW_TYPES.EVENTS}
+								>
+									<div className="view-title">
+										<ChevronsLeftRight size={14} />
+										Events
+									</div>
+								</Radio.Button>
+							</Radio.Group>
 
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
+							{(selectedView === VIEW_TYPES.LOGS ||
+								selectedView === VIEW_TYPES.TRACES) && (
+								<Button
+									icon={<Compass size={18} />}
+									className="compass-button"
+									onClick={handleExplorePagesRedirect}
+								/>
+							)}
+						</div>
+					)}
 
-					{selectedView === VIEW_TYPES.METRICS && (
-						<PodMetrics<K8sPodsData>
-							entity={pod}
+					{effectiveView === VIEW_TYPES.METRICS && (
+						<EntityMetrics<T>
+							entity={entity}
 							selectedInterval={selectedInterval}
 							timeRange={modalTimeRange}
 							handleTimeChange={handleTimeChange}
-							isModalTimeSelection={isModalTimeSelection}
-							entityWidgetInfo={podWidgetInfo}
-							getEntityQueryPayload={getPodMetricsQueryPayload}
-							category={K8sCategory.PODS}
-							queryKey="podMetrics"
+							isModalTimeSelection
+							entityWidgetInfo={entityWidgetInfo}
+							getEntityQueryPayload={getEntityQueryPayload}
+							category={category}
+							queryKey={`${queryKeyPrefix}Metrics`}
 						/>
 					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<PodLogs
+					{effectiveView === VIEW_TYPES.LOGS && (
+						<EntityLogs
 							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
+							isModalTimeSelection
 							handleTimeChange={handleTimeChange}
 							handleChangeLogFilters={handleChangeLogFilters}
 							logFilters={logsAndTracesFilters}
 							selectedInterval={selectedInterval}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_POD_NAME,
-								QUERY_KEYS.K8S_CLUSTER_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-							queryKey="podLogs"
-							category={K8sCategory.PODS}
+							queryKeyFilters={primaryFilterKeys}
+							queryKey={`${queryKeyPrefix}Logs`}
+							category={category}
 						/>
 					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<PodTraces
+					{effectiveView === VIEW_TYPES.TRACES && (
+						<EntityTraces
 							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
+							isModalTimeSelection
 							handleTimeChange={handleTimeChange}
 							handleChangeTracesFilters={handleChangeTracesFilters}
 							tracesFilters={logsAndTracesFilters}
 							selectedInterval={selectedInterval}
-							queryKey="podTraces"
-							category={InfraMonitoringEvents.Pod}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_POD_NAME,
-								QUERY_KEYS.K8S_CLUSTER_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
+							queryKey={`${queryKeyPrefix}Traces`}
+							category={eventCategory}
+							queryKeyFilters={primaryFilterKeys}
 						/>
 					)}
-
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<PodEvents
+					{effectiveView === VIEW_TYPES.EVENTS && (
+						<EntityEvents
 							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
+							isModalTimeSelection
 							handleTimeChange={handleTimeChange}
 							handleChangeEventFilters={handleChangeEventsFilters}
 							filters={eventsFilters}
 							selectedInterval={selectedInterval}
-							category={K8sCategory.PODS}
-							queryKey="podEvents"
+							category={category}
+							queryKey={`${queryKeyPrefix}Events`}
 						/>
 					)}
 				</>
@@ -677,4 +755,4 @@ function PodDetails({
 	);
 }
 
-export default PodDetails;
+export default K8sBaseDetails;

frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.module.scss

@@ -0,0 +1,156 @@
+.clickableRow {
+	cursor: pointer;
+}
+
+.expandedClickableRow {
+	cursor: pointer;
+}
+
+.expandedTableContainer {
+	border: 1px solid var(--l1-border);
+	overflow-x: auto;
+	padding-left: 48px;
+
+	:global(.ant-table-tbody > tr:hover > td) {
+		background: none !important;
+	}
+}
+
+.expandedTableFooter {
+	display: flex;
+	justify-content: flex-start;
+	gap: 8px;
+	padding: 8px;
+	padding-left: 42px;
+	margin-top: 8px;
+}
+
+.viewAllButton {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+}
+
+.k8sListTable {
+	:global(.ant-table) {
+		:global(.ant-table-thead > tr > th) {
+			padding: 12px;
+			font-weight: 500;
+			font-size: 12px;
+			line-height: 18px;
+
+			border-bottom: none;
+
+			color: var(--l2-foreground);
+			font-family: Inter;
+			font-size: 11px;
+			font-style: normal;
+			font-weight: 600;
+			line-height: 18px;
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+			background: var(--bg-ink-500) !important;
+
+			&::before {
+				background: transparent !important;
+			}
+		}
+
+		:global(.ant-table-cell) {
+			padding: 12px;
+			font-size: 13px;
+			line-height: 20px;
+			color: var(--l1-foreground);
+			background: var(--bg-ink-500);
+			border-bottom: none;
+
+			&:before,
+			&:after {
+				display: none;
+			}
+		}
+
+		:global(.hostname-column-value) {
+			color: var(--l1-foreground);
+			font-family: 'Geist Mono';
+			font-style: normal;
+			font-weight: 600;
+			line-height: 20px;
+			letter-spacing: -0.07px;
+		}
+
+		:global(.progress-container) {
+			:global(.ant-progress-bg) {
+				height: 8px !important;
+				border-radius: 4px;
+			}
+		}
+
+		:global(.ant-table-tbody > tr:hover > td) {
+			background: var(--bg-ink-500);
+		}
+
+		:global(.ant-table-tbody > tr:not(.ant-table-expanded-row):hover > td) {
+			background: var(--l2-background);
+		}
+
+		:global(.ant-table-tbody > tr > td) {
+			border-bottom: none;
+		}
+
+		:global(.ant-empty-normal) {
+			visibility: hidden;
+		}
+	}
+
+	:global(.ant-pagination) {
+		width: 100%;
+		position: fixed;
+		bottom: 0;
+		right: 0;
+		padding: 16px;
+		background-color: var(--bg-ink-500);
+		margin: 0 !important;
+		padding-right: 72px;
+
+		:global(.ant-pagination-item) {
+			border-radius: 4px;
+		}
+
+		:global(.ant-pagination-item-active) {
+			background: var(--l2-background);
+			border-color: var(--l2-border);
+
+			a {
+				color: var(--l1-foreground) !important;
+			}
+		}
+	}
+}
+
+.noFilteredHostsMessageContainer {
+	height: 30vh;
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+}
+
+.noFilteredHostsMessageContent {
+	display: flex;
+	flex-direction: column;
+	align-items: flex-start;
+	justify-content: center;
+
+	width: fit-content;
+	padding: 24px;
+}
+
+.noFilteredHostsMessage {
+	margin-top: var(--spacing-4);
+}
+
+.emptyStateSvg {
+	width: 32px;
+	max-width: 100%;
+}

frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.tsx

@@ -0,0 +1,615 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+// eslint-disable-next-line no-restricted-imports
+import { LoadingOutlined } from '@ant-design/icons';
+import {
+	Button,
+	Spin,
+	Table,
+	TableColumnType as ColumnType,
+	TablePaginationConfig,
+	TableProps,
+	Typography,
+} from 'antd';
+import type { SorterResult } from 'antd/es/table/interface';
+import logEvent from 'api/common/logEvent';
+import { InfraMonitoringEvents } from 'constants/events';
+import { ChevronDown, ChevronRight, CornerDownRight } from 'lucide-react';
+import { parseAsString, useQueryState } from 'nuqs';
+import { useGlobalTimeStore } from 'store/globalTime';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import {
+	IBuilderQuery,
+	TagFilter,
+} from 'types/api/queryBuilder/queryBuilderData';
+import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
+import { openInNewTab } from 'utils/navigation';
+
+import { K8sCategory } from '../constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFilters,
+	useInfraMonitoringGroupBy,
+	useInfraMonitoringOrderBy,
+	useInfraMonitoringQueryFilters,
+	useInfraMonitoringSelectedItem,
+} from '../hooks';
+import LoadingContainer from '../LoadingContainer';
+import { OrderBySchemaType } from '../schemas';
+import { usePageSize } from '../utils';
+import K8sHeader from './K8sHeader';
+import {
+	IEntityColumn,
+	useInfraMonitoringTableColumnsForPage,
+	useInfraMonitoringTableColumnsStore,
+} from './useInfraMonitoringTableColumnsStore';
+
+import styles from './K8sBaseList.module.scss';
+
+export type K8sBaseFilters = {
+	filters?: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	start: number;
+	end: number;
+	orderBy?: OrderBySchemaType;
+};
+
+export type K8sRenderedRowData = {
+	/**
+	 * The unique ID for the row
+	 */
+	key: string;
+	/**
+	 * The ID to the selectedItem
+	 */
+	itemKey: string;
+	groupedByMeta: Record<string, string>;
+	[key: string]: unknown;
+};
+
+export type K8sBaseListProps<T = unknown> = {
+	controlListPrefix?: React.ReactNode;
+	entity: K8sCategory;
+	tableColumnsDefinitions: IEntityColumn[];
+	tableColumns: ColumnType<K8sRenderedRowData>[];
+	fetchListData: (
+		filters: K8sBaseFilters,
+		signal?: AbortSignal,
+	) => Promise<{
+		data: T[];
+		total: number;
+		error?: string | null;
+	}>;
+	renderRowData: (
+		record: T,
+		groupBy: BaseAutocompleteData[],
+	) => K8sRenderedRowData;
+	eventCategory: InfraMonitoringEvents;
+};
+
+export type K8sExpandedRowProps<T> = {
+	record: K8sRenderedRowData;
+	entity: K8sCategory;
+	tableColumns: ColumnType<K8sRenderedRowData>[];
+	fetchListData: K8sBaseListProps<T>['fetchListData'];
+	renderRowData: K8sBaseListProps<T>['renderRowData'];
+};
+
+function K8sExpandedRow<T>({
+	record,
+	entity,
+	tableColumns,
+	fetchListData,
+	renderRowData,
+}: K8sExpandedRowProps<T>): JSX.Element {
+	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
+	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [, setFilters] = useInfraMonitoringFilters();
+	const [, setSelectedItem] = useInfraMonitoringSelectedItem();
+
+	const queryFilters = useInfraMonitoringQueryFilters();
+
+	const [
+		columnsDefinitions,
+		columnsHidden,
+	] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const hiddenColumnIdsForNested = useMemo(
+		() =>
+			columnsDefinitions
+				.filter((col) => col.behavior === 'hidden-on-collapse')
+				.map((col) => col.id),
+		[columnsDefinitions],
+	);
+
+	const nestedColumns = useMemo(
+		() =>
+			tableColumns.filter(
+				(c) =>
+					!columnsHidden.includes(c.key?.toString() || '') &&
+					!hiddenColumnIdsForNested.includes(c.key?.toString() || ''),
+			),
+		[tableColumns, columnsHidden, hiddenColumnIdsForNested],
+	);
+
+	const createFiltersForRecord = useCallback((): IBuilderQuery['filters'] => {
+		const baseFilters: IBuilderQuery['filters'] = {
+			items: [...queryFilters.items],
+			op: 'and',
+		};
+
+		const { groupedByMeta } = record;
+
+		for (const key of Object.keys(groupedByMeta)) {
+			baseFilters.items.push({
+				key: {
+					key,
+					type: null,
+				},
+				op: '=',
+				value: groupedByMeta[key],
+				id: key,
+			});
+		}
+
+		return baseFilters;
+	}, [queryFilters.items, record]);
+
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
+	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const queryKey = useMemo(() => {
+		return getAutoRefreshQueryKey(selectedTime, [
+			'k8sExpandedRow',
+			record.key,
+			JSON.stringify(queryFilters),
+			JSON.stringify(orderBy),
+		]);
+	}, [selectedTime, record.key, queryFilters, orderBy]);
+
+	const { data, isFetching, isLoading, isError } = useQuery({
+		queryKey,
+		queryFn: ({ signal }) => {
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchListData(
+				{
+					limit: 10,
+					offset: 0,
+					filters: createFiltersForRecord(),
+					start: Math.floor(minTime / 1000000),
+					end: Math.floor(maxTime / 1000000),
+					orderBy: orderBy || undefined,
+					groupBy: undefined,
+				},
+				signal,
+			);
+		},
+		refetchInterval: isRefreshEnabled ? refreshInterval : false,
+	});
+
+	const formattedData = useMemo(
+		() => data?.data?.map((item) => renderRowData(item, groupBy)),
+		[data?.data, renderRowData, groupBy],
+	);
+
+	const openRecordInNewTab = (rowRecord: K8sRenderedRowData): void => {
+		const newParams = new URLSearchParams(document.location.search);
+		newParams.set('selectedItem', rowRecord.itemKey);
+		openInNewTab(
+			buildAbsolutePath({
+				relativePath: '',
+				urlQueryString: newParams.toString(),
+			}),
+		);
+	};
+
+	const handleViewAllClick = (): void => {
+		const filters = createFiltersForRecord();
+		setFilters(JSON.stringify(filters));
+		setCurrentPage(1);
+		setGroupBy([]);
+		setOrderBy(null);
+	};
+
+	return (
+		<div
+			className={styles.expandedTableContainer}
+			data-testid="expanded-table-container"
+		>
+			{isError && (
+				<Typography>{data?.error?.toString() || 'Something went wrong'}</Typography>
+			)}
+
+			{isFetching || isLoading ? (
+				<LoadingContainer />
+			) : (
+				<div data-testid="expanded-table">
+					<Table
+						columns={nestedColumns}
+						dataSource={formattedData}
+						pagination={false}
+						scroll={{ x: true }}
+						tableLayout="fixed"
+						showHeader={false}
+						loading={{
+							spinning: isFetching || isLoading,
+							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+						}}
+						onRow={(
+							rowRecord: K8sRenderedRowData,
+						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
+							onClick: (event: React.MouseEvent): void => {
+								if (isModifierKeyPressed(event)) {
+									openRecordInNewTab(rowRecord);
+									return;
+								}
+								setSelectedItem(rowRecord.itemKey);
+							},
+							className: styles.expandedClickableRow,
+						})}
+					/>
+
+					{data?.total && data?.total > 10 && (
+						<div className={styles.expandedTableFooter}>
+							<Button
+								type="default"
+								size="small"
+								className={styles.viewAllButton}
+								onClick={handleViewAllClick}
+							>
+								<CornerDownRight size={14} />
+								View All
+							</Button>
+						</div>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
+
+export function K8sBaseList<T>({
+	controlListPrefix,
+	entity,
+	tableColumnsDefinitions,
+	tableColumns,
+	fetchListData,
+	renderRowData,
+	eventCategory,
+}: K8sBaseListProps<T>): JSX.Element {
+	const queryFilters = useInfraMonitoringQueryFilters();
+	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [groupBy] = useInfraMonitoringGroupBy();
+	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [initialOrderBy] = useState(orderBy);
+	const [selectedItem, setSelectedItem] = useQueryState(
+		'selectedItem',
+		parseAsString,
+	);
+
+	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
+	useEffect(() => {
+		setExpandedRowKeys([]);
+	}, [groupBy, currentPage]);
+	const { pageSize, setPageSize } = usePageSize(entity);
+
+	const initializeTableColumns = useInfraMonitoringTableColumnsStore(
+		(state) => state.initializePageColumns,
+	);
+	useEffect(() => {
+		initializeTableColumns(entity, tableColumnsDefinitions);
+	}, [initializeTableColumns, entity, tableColumnsDefinitions]);
+
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
+	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const queryKey = useMemo(() => {
+		return getAutoRefreshQueryKey(
+			selectedTime,
+			'k8sBaseList',
+			entity,
+			String(pageSize),
+			String(currentPage),
+			JSON.stringify(queryFilters),
+			JSON.stringify(orderBy),
+			JSON.stringify(groupBy),
+		);
+	}, [
+		selectedTime,
+		entity,
+		pageSize,
+		currentPage,
+		queryFilters,
+		orderBy,
+		groupBy,
+	]);
+
+	const { data, isLoading, isError } = useQuery({
+		queryKey,
+		queryFn: ({ signal }) => {
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchListData(
+				{
+					limit: pageSize,
+					offset: (currentPage - 1) * pageSize,
+					filters: queryFilters,
+					start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
+					end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
+					orderBy: orderBy || undefined,
+					groupBy: groupBy?.length > 0 ? groupBy : undefined,
+				},
+				signal,
+			);
+		},
+		refetchInterval: isRefreshEnabled ? refreshInterval : false,
+	});
+
+	const pageData = data?.data;
+	const totalCount = data?.total || 0;
+
+	const formattedItemsData = useMemo(
+		() => pageData?.map((item) => renderRowData(item, groupBy)),
+		[pageData, renderRowData, groupBy],
+	);
+
+	const handleTableChange: TableProps<K8sRenderedRowData>['onChange'] = useCallback(
+		(
+			pagination: TablePaginationConfig,
+			_filters: Record<string, (string | number | boolean)[] | null>,
+			sorter:
+				| SorterResult<K8sRenderedRowData>
+				| SorterResult<K8sRenderedRowData>[],
+		): void => {
+			if (pagination.current) {
+				setCurrentPage(pagination.current);
+				logEvent(InfraMonitoringEvents.PageNumberChanged, {
+					entity: InfraMonitoringEvents.K8sEntity,
+					page: InfraMonitoringEvents.ListPage,
+					category: eventCategory,
+				});
+			}
+
+			if ('field' in sorter && sorter.order) {
+				setOrderBy({
+					columnName: sorter.field as string,
+					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				});
+			} else {
+				setOrderBy(null);
+			}
+		},
+		[eventCategory, setCurrentPage, setOrderBy],
+	);
+
+	useEffect(() => {
+		logEvent(InfraMonitoringEvents.PageVisited, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+			total: totalCount,
+		});
+	}, [eventCategory, totalCount]);
+
+	const handleGroupByRowClick = (record: K8sRenderedRowData): void => {
+		if (expandedRowKeys.includes(record.key)) {
+			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
+		} else {
+			setExpandedRowKeys([record.key]);
+		}
+	};
+
+	const openItemInNewTab = (record: K8sRenderedRowData): void => {
+		const newParams = new URLSearchParams(document.location.search);
+		newParams.set('selectedItem', record.itemKey);
+		openInNewTab(
+			buildAbsolutePath({
+				relativePath: '',
+				urlQueryString: newParams.toString(),
+			}),
+		);
+	};
+
+	const handleRowClick = (
+		record: K8sRenderedRowData,
+		event: React.MouseEvent,
+	): void => {
+		if (event && isModifierKeyPressed(event)) {
+			openItemInNewTab(record);
+			return;
+		}
+		if (groupBy.length === 0) {
+			setSelectedItem(record.itemKey);
+		} else {
+			handleGroupByRowClick(record);
+		}
+
+		logEvent(InfraMonitoringEvents.ItemClicked, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+		});
+	};
+
+	const [
+		columnsDefinitions,
+		columnsHidden,
+	] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const hiddenColumnIdsOnList = useMemo(
+		() =>
+			columnsDefinitions
+				.filter(
+					(col) =>
+						(groupBy?.length > 0 && col.behavior === 'hidden-on-expand') ||
+						(!groupBy?.length && col.behavior === 'hidden-on-collapse'),
+				)
+				.map((col) => col.id),
+		[columnsDefinitions, groupBy?.length],
+	);
+
+	const mapDefaultSort = useCallback(
+		(
+			tableColumn: ColumnType<K8sRenderedRowData>,
+		): ColumnType<K8sRenderedRowData> => {
+			if (tableColumn.key === initialOrderBy?.columnName) {
+				return {
+					...tableColumn,
+					defaultSortOrder: initialOrderBy?.order === 'asc' ? 'ascend' : 'descend',
+				};
+			}
+
+			return tableColumn;
+		},
+		[initialOrderBy?.columnName, initialOrderBy?.order],
+	);
+
+	const columns = useMemo(
+		() =>
+			tableColumns
+				.filter(
+					(c) =>
+						!hiddenColumnIdsOnList.includes(c.key?.toString() || '') &&
+						!columnsHidden.includes(c.key?.toString() || ''),
+				)
+				.map(mapDefaultSort),
+		[columnsHidden, hiddenColumnIdsOnList, mapDefaultSort, tableColumns],
+	);
+
+	const isGroupedByAttribute = groupBy.length > 0;
+
+	const expandedRowRender = (record: K8sRenderedRowData): JSX.Element => (
+		<K8sExpandedRow<T>
+			record={record}
+			entity={entity}
+			tableColumns={tableColumns}
+			fetchListData={fetchListData}
+			renderRowData={renderRowData}
+		/>
+	);
+
+	const expandRowIconRenderer = ({
+		expanded,
+		onExpand,
+		record,
+	}: {
+		expanded: boolean;
+		onExpand: (
+			record: K8sRenderedRowData,
+			e: React.MouseEvent<HTMLButtonElement>,
+		) => void;
+		record: K8sRenderedRowData;
+	}): JSX.Element | null => {
+		if (!isGroupedByAttribute) {
+			return null;
+		}
+
+		return expanded ? (
+			<Button
+				className="periscope-btn ghost"
+				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
+					onExpand(record, e)
+				}
+				role="button"
+			>
+				<ChevronDown size={14} />
+			</Button>
+		) : (
+			<Button
+				className="periscope-btn ghost"
+				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
+					onExpand(record, e)
+				}
+				role="button"
+			>
+				<ChevronRight size={14} />
+			</Button>
+		);
+	};
+
+	const onPaginationChange = (page: number, pageSize: number): void => {
+		setCurrentPage(page);
+		setPageSize(pageSize);
+		logEvent(InfraMonitoringEvents.PageNumberChanged, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+		});
+	};
+
+	const showTableLoadingState = isLoading;
+
+	return (
+		<>
+			<K8sHeader
+				controlListPrefix={controlListPrefix}
+				entity={entity}
+				showAutoRefresh={!selectedItem}
+			/>
+			{isError && (
+				<Typography>{data?.error?.toString() || 'Something went wrong'}</Typography>
+			)}
+
+			<Table
+				className={styles.k8sListTable}
+				dataSource={showTableLoadingState ? [] : formattedItemsData}
+				columns={columns}
+				pagination={{
+					current: currentPage,
+					pageSize,
+					total: totalCount,
+					showSizeChanger: true,
+					hideOnSinglePage: false,
+					onChange: onPaginationChange,
+				}}
+				loading={{
+					spinning: showTableLoadingState,
+					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+				}}
+				locale={{
+					emptyText: showTableLoadingState ? null : (
+						<div className={styles.noFilteredHostsMessageContainer}>
+							<div className={styles.noFilteredHostsMessageContent}>
+								<img
+									src="/Icons/emptyState.svg"
+									alt="thinking-emoji"
+									className={styles.emptyStateSvg}
+								/>
+
+								<Typography.Text className={styles.noFilteredHostsMessage}>
+									This query had no results. Edit your query and try again!
+								</Typography.Text>
+							</div>
+						</div>
+					),
+				}}
+				scroll={{ x: true }}
+				tableLayout="fixed"
+				onChange={handleTableChange}
+				onRow={(
+					record,
+				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
+					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+					className: styles.clickableRow,
+				})}
+				expandable={{
+					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
+					expandIcon: expandRowIconRenderer,
+					expandedRowKeys,
+				}}
+			/>
+		</>
+	);
+}

frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.module.scss

@@ -0,0 +1,36 @@
+.drawer {
+	--dialog-description-padding: 0px 0px var(--spacing-8) 0px;
+}
+
+.columnItem {
+	display: flex;
+	align-items: center;
+}
+
+.columnsTitle {
+	color: var(--l2-foreground);
+	font-size: var(--periscope-font-size-small, 11px);
+	font-weight: var(--periscope-font-weight-medium, 500);
+	text-transform: uppercase;
+
+	padding: var(--spacing-4) var(--spacing-8);
+	border-bottom: 1px solid var(--l2-border);
+
+	&:not(:first-of-type) {
+		border-top: 1px solid var(--l2-border);
+	}
+}
+
+.columnsList {
+	display: flex;
+	flex-direction: column;
+}
+
+.columnItem {
+	justify-content: flex-start !important;
+	width: 100%;
+}
+
+.horizontalDivider {
+	border-top: 1px solid var(--l1-border);
+}

frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.tsx

@@ -0,0 +1,102 @@
+import { Button, DrawerWrapper } from '@signozhq/ui';
+
+import { K8sCategory } from '../constants';
+import {
+	useInfraMonitoringTableColumnsForPage,
+	useInfraMonitoringTableColumnsStore,
+} from './useInfraMonitoringTableColumnsStore';
+
+import styles from './K8sFiltersSidePanel.module.scss';
+
+function K8sFiltersSidePanel({
+	open,
+	onClose,
+	entity,
+}: {
+	open: boolean;
+	onClose: () => void;
+	entity: K8sCategory;
+}): JSX.Element {
+	const addColumn = useInfraMonitoringTableColumnsStore(
+		(state) => state.addColumn,
+	);
+	const removeColumn = useInfraMonitoringTableColumnsStore(
+		(state) => state.removeColumn,
+	);
+
+	const [columns, columnsHidden] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const drawerContent = (
+		<>
+			<div className={styles.columnsTitle}>Added Columns (Click to remove)</div>
+
+			<div className={styles.columnsList}>
+				{columns
+					.filter(
+						(column) =>
+							!columnsHidden.includes(column.id) &&
+							column.behavior !== 'hidden-on-collapse',
+					)
+					.map((column) => (
+						<div className={styles.columnItem} key={column.value}>
+							{/*<GripVertical size={16} /> TODO: Add support back when update the table component */}
+							<Button
+								variant="ghost"
+								color="none"
+								className={styles.columnItem}
+								disabled={!column.canBeHidden}
+								data-testid={`remove-column-${column.id}`}
+								onClick={(): void => removeColumn(entity, column.id)}
+							>
+								{column.label}
+							</Button>
+						</div>
+					))}
+			</div>
+
+			<div className={styles.horizontalDivider} />
+
+			<div className={styles.columnsTitle}>Other Columns (Click to add)</div>
+
+			<div className={styles.columnsList}>
+				{columns
+					.filter((column) => columnsHidden.includes(column.id))
+					.map((column) => (
+						<div className={styles.columnItem} key={column.value}>
+							<Button
+								variant="ghost"
+								color="none"
+								className={styles.columnItem}
+								data-can-be-added="true"
+								data-testid={`add-column-${column.id}`}
+								onClick={(): void => addColumn(entity, column.id)}
+								tabIndex={0}
+							>
+								{column.label}
+							</Button>
+						</div>
+					))}
+			</div>
+		</>
+	);
+
+	return (
+		<DrawerWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					onClose();
+				}
+			}}
+			title="Columns"
+			direction="right"
+			showCloseButton
+			showOverlay={false}
+			className={styles.drawer}
+		>
+			{drawerContent}
+		</DrawerWrapper>
+	);
+}
+
+export default K8sFiltersSidePanel;

frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.module.scss

@@ -0,0 +1,80 @@
+.k8sListControls {
+	padding: var(--spacing-4);
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	gap: var(--spacing-4);
+
+	:global(.ant-select-selector) {
+		border-radius: 2px;
+		border: 1px solid var(--l1-border) !important;
+		background-color: var(--l2-background) !important;
+
+		input {
+			font-size: 12px;
+		}
+
+		:global(.ant-tag .ant-typography) {
+			font-size: 12px;
+		}
+	}
+}
+
+.k8sListControlsLeft {
+	flex: 1;
+	display: flex;
+	align-items: center;
+	flex-wrap: wrap;
+	gap: var(--spacing-4);
+
+	.k8sQbSearchContainer {
+		flex: 1;
+		min-width: 240px;
+		max-width: 60%;
+	}
+}
+
+.k8sAttributeSearchContainer {
+	flex: 1;
+	min-width: 240px;
+	max-width: 40%;
+	display: flex;
+	align-items: center;
+}
+
+.groupByLabel {
+	min-width: max-content;
+	font-size: var(--periscope-font-size-base, 13px);
+	font-weight: var(--periscope-font-weight-regular, 400);
+	line-height: 18px;
+	letter-spacing: -0.07px;
+
+	border-radius: 2px 0px 0px 2px;
+	border: 1px solid var(--l1-border);
+	border-right: none;
+	border-top-right-radius: 0px;
+	border-bottom-right-radius: 0px;
+
+	display: flex;
+	height: 32px;
+	padding: var(--spacing-3) var(--spacing-3) var(--spacing-3) var(--spacing-4);
+	justify-content: center;
+	align-items: center;
+	gap: var(--spacing-2);
+}
+
+.groupBySelect {
+	:global(.ant-select-selector) {
+		border-left: none;
+		border-top-left-radius: 0px;
+		border-bottom-left-radius: 0px;
+	}
+}
+
+.k8sListControlsRight {
+	min-width: 240px;
+
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+}

frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.tsx

@@ -0,0 +1,226 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { Button } from '@signozhq/button';
+import { Select } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { InfraMonitoringEvents } from 'constants/events';
+import { FeatureKeys } from 'constants/features';
+import { initialQueriesMap } from 'constants/queryBuilder';
+import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
+import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
+import { SlidersHorizontal } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { GetK8sEntityToAggregateAttribute, K8sCategory } from '../constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFiltersK8s,
+	useInfraMonitoringGroupBy,
+} from '../hooks';
+import K8sFiltersSidePanel from './K8sFiltersSidePanel';
+
+import styles from './K8sHeader.module.scss';
+
+interface K8sHeaderProps {
+	controlListPrefix?: React.ReactNode;
+	entity: K8sCategory;
+	showAutoRefresh: boolean;
+}
+
+function K8sHeader({
+	controlListPrefix,
+	entity,
+	showAutoRefresh,
+}: K8sHeaderProps): JSX.Element {
+	const [isFiltersSidePanelOpen, setIsFiltersSidePanelOpen] = useState(false);
+	const [urlFilters, setUrlFilters] = useInfraMonitoringFiltersK8s();
+
+	const currentQuery = initialQueriesMap[DataSource.METRICS];
+
+	const updatedCurrentQuery = useMemo(() => {
+		let { filters } = currentQuery.builder.queryData[0];
+		if (urlFilters) {
+			filters = urlFilters;
+		}
+		return {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: [
+					{
+						...currentQuery.builder.queryData[0],
+						aggregateOperator: 'noop',
+						aggregateAttribute: {
+							...currentQuery.builder.queryData[0].aggregateAttribute,
+						},
+						filters,
+					},
+				],
+			},
+		};
+	}, [currentQuery, urlFilters]);
+
+	const query = useMemo(
+		() => updatedCurrentQuery?.builder?.queryData[0] || null,
+		[updatedCurrentQuery],
+	);
+
+	const { handleChangeQueryData } = useQueryOperations({
+		index: 0,
+		query: currentQuery.builder.queryData[0],
+		entityVersion: '',
+	});
+
+	const [, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const handleChangeTagFilters = useCallback(
+		(value: IBuilderQuery['filters']) => {
+			setUrlFilters(value || null);
+			handleChangeQueryData('filters', value);
+			setCurrentPage(1);
+
+			if (value?.items && value?.items?.length > 0) {
+				logEvent(InfraMonitoringEvents.FilterApplied, {
+					entity: InfraMonitoringEvents.K8sEntity,
+					page: InfraMonitoringEvents.ListPage,
+					category: InfraMonitoringEvents.Pod,
+				});
+			}
+		},
+		[handleChangeQueryData, setCurrentPage, setUrlFilters],
+	);
+
+	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: GetK8sEntityToAggregateAttribute(
+				entity,
+				dotMetricsEnabled,
+			),
+			aggregateOperator: 'noop',
+			searchText: '',
+			tagType: '',
+		},
+		{
+			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
+		},
+		true,
+		entity,
+	);
+
+	const groupByOptions = useMemo(
+		() =>
+			groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
+				value: filter.key,
+				label: filter.key,
+			})) || [],
+		[groupByFiltersData],
+	);
+
+	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
+
+	const handleGroupByChange = useCallback(
+		(value: IBuilderQuery['groupBy']) => {
+			const newGroupBy = [];
+
+			for (let index = 0; index < value.length; index++) {
+				const element = (value[index] as unknown) as string;
+
+				const key = groupByFiltersData?.payload?.attributeKeys?.find(
+					(k) => k.key === element,
+				);
+
+				if (key) {
+					newGroupBy.push(key);
+				}
+			}
+
+			// Reset pagination on switching to groupBy
+			setCurrentPage(1);
+			setGroupBy(newGroupBy);
+
+			logEvent(InfraMonitoringEvents.GroupByChanged, {
+				entity: InfraMonitoringEvents.K8sEntity,
+				page: InfraMonitoringEvents.ListPage,
+				category: InfraMonitoringEvents.Pod,
+			});
+		},
+		[groupByFiltersData, setCurrentPage, setGroupBy],
+	);
+
+	const onClickOutside = useCallback(() => {
+		setIsFiltersSidePanelOpen(false);
+	}, []);
+
+	return (
+		<div className={styles.k8sListControls}>
+			<div className={styles.k8sListControlsLeft}>
+				{controlListPrefix}
+
+				<div className={styles.k8sQbSearchContainer}>
+					<QueryBuilderSearch
+						query={query as IBuilderQuery}
+						onChange={handleChangeTagFilters}
+						isInfraMonitoring
+						disableNavigationShortcuts
+						entity={entity}
+					/>
+				</div>
+
+				<div className={styles.k8sAttributeSearchContainer}>
+					<div className={styles.groupByLabel}> Group by </div>
+					<Select
+						className={styles.groupBySelect}
+						loading={isLoadingGroupByFilters}
+						mode="multiple"
+						value={groupBy}
+						allowClear
+						maxTagCount="responsive"
+						placeholder="Search for attribute"
+						style={{ width: '100%' }}
+						options={groupByOptions}
+						onChange={handleGroupByChange}
+					/>
+				</div>
+			</div>
+
+			<div className={styles.k8sListControlsRight}>
+				<DateTimeSelectionV2
+					showAutoRefresh={showAutoRefresh}
+					showRefreshText={false}
+					hideShareModal
+				/>
+
+				<Button
+					type="button"
+					variant="ghost"
+					size="icon"
+					color="none"
+					disabled={groupBy?.length > 0}
+					data-testid="k8s-list-filters-button"
+					onClick={(): void => setIsFiltersSidePanelOpen(true)}
+				>
+					<SlidersHorizontal size={14} />
+				</Button>
+			</div>
+
+			<K8sFiltersSidePanel
+				open={isFiltersSidePanelOpen}
+				entity={entity}
+				onClose={onClickOutside}
+			/>
+		</div>
+	);
+}
+
+export default K8sHeader;

frontend/src/container/InfraMonitoringK8s/Base/useInfraMonitoringTableColumnsStore.ts

@@ -0,0 +1,113 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+export interface IEntityColumn {
+	label: string;
+	value: string;
+	id: string;
+	defaultVisibility: boolean;
+	canBeHidden: boolean;
+	behavior: 'hidden-on-expand' | 'hidden-on-collapse' | 'always-visible';
+}
+
+export interface IInfraMonitoringTableColumnsStore {
+	columns: Record<string, IEntityColumn[]>;
+	columnsHidden: Record<string, string[]>;
+	addColumn: (page: string, columnId: string) => void;
+	removeColumn: (page: string, columnId: string) => void;
+	initializePageColumns: (page: string, columns: IEntityColumn[]) => void;
+}
+
+export const useInfraMonitoringTableColumnsStore = create<IInfraMonitoringTableColumnsStore>()(
+	persist(
+		(set, get) => ({
+			columns: {},
+			columnsHidden: {},
+			addColumn: (page, columnId): void => {
+				const state = get();
+				const columnDefinition = state.columns[page]?.find(
+					(c) => c.id === columnId,
+				);
+
+				if (!columnDefinition) {
+					return;
+				}
+
+				if (!columnDefinition.canBeHidden) {
+					return;
+				}
+
+				const columnsHidden = state.columnsHidden[page];
+
+				if (columnsHidden.includes(columnId)) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: columnsHidden.filter((id) => id !== columnId),
+						},
+					});
+				}
+			},
+			removeColumn: (page, columnId): void => {
+				const state = get();
+				const columnDefinition = state.columns[page]?.find(
+					(c) => c.id === columnId,
+				);
+
+				if (!columnDefinition) {
+					return;
+				}
+
+				if (!columnDefinition.canBeHidden) {
+					return;
+				}
+
+				const columnsHidden = state.columnsHidden[page];
+
+				if (!columnsHidden.includes(columnId)) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: [...columnsHidden, columnId],
+						},
+					});
+				}
+			},
+			initializePageColumns: (page, columns): void => {
+				const state = get();
+
+				set({
+					columns: {
+						...state.columns,
+						[page]: columns,
+					},
+				});
+
+				if (state.columnsHidden[page] === undefined) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: columns
+								.filter((c) => c.defaultVisibility === false)
+								.map((c) => c.id),
+						},
+					});
+				}
+			},
+		}),
+		{
+			name: '@signoz/infra-monitoring-columns',
+		},
+	),
+);
+
+export const useInfraMonitoringTableColumnsForPage = (
+	page: string,
+): [columns: IEntityColumn[], columnsHidden: string[]] => {
+	const state = useInfraMonitoringTableColumnsStore((s) => s.columns);
+	const columnsHidden = useInfraMonitoringTableColumnsStore(
+		(s) => s.columnsHidden,
+	);
+
+	return [state[page] ?? [], columnsHidden[page] ?? []];
+};

frontend/src/container/InfraMonitoringK8s/Base/utils.module.scss

@@ -0,0 +1,18 @@
+.itemDataGroup {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	flex-wrap: wrap;
+
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.itemDataGroupTagItem {
+	display: block !important;
+	max-width: 100%;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}

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

@@ -0,0 +1,93 @@
+import { Badge } from '@signozhq/ui';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+import styles from './utils.module.scss';
+
+const dotToUnder: Record<string, string> = {
+	'k8s.node.name': 'k8s_node_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+	'k8s.node.uid': 'k8s_node_uid',
+	'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.pod.name': 'k8s_pod_name',
+	'k8s.pod.uid': 'k8s_pod_uid',
+	'k8s.statefulset.name': 'k8s_statefulset_name',
+	'k8s.persistentvolumeclaim.name': 'k8s_persistentvolumeclaim_name',
+};
+
+export function getGroupedByMeta<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	groupBy: BaseAutocompleteData[],
+): Record<string, string> {
+	const result: Record<string, string> = {};
+
+	groupBy.forEach((group) => {
+		const rawKey = group.key as string;
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof itemData.meta;
+		result[rawKey] = itemData.meta[metaKey] ?? '';
+	});
+
+	return result;
+}
+
+export function getRowKey<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	getItemIdentifier: () => string,
+	groupBy: BaseAutocompleteData[],
+): string {
+	const nodeIdentifier = getItemIdentifier();
+
+	if (groupBy.length === 0) {
+		return nodeIdentifier || JSON.stringify(itemData.meta);
+	}
+
+	const groupedMeta = getGroupedByMeta(itemData, groupBy);
+	const groupKey = Object.values(groupedMeta).join('-');
+
+	if (groupKey && nodeIdentifier) {
+		return `${groupKey}-${nodeIdentifier}`;
+	}
+	if (groupKey) {
+		return groupKey;
+	}
+	if (nodeIdentifier) {
+		return nodeIdentifier;
+	}
+
+	return JSON.stringify(itemData.meta);
+}
+
+export function getGroupByEl<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	groupBy: IBuilderQuery['groupBy'],
+): React.ReactNode {
+	const groupByValues: string[] = [];
+
+	groupBy.forEach((group) => {
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof itemData.meta;
+		const value = itemData.meta[metaKey] || '-';
+
+		groupByValues.push(value);
+	});
+
+	return (
+		<div className={styles.itemDataGroup}>
+			{groupByValues.map((value) => (
+				<Badge
+					key={value}
+					color="secondary"
+					className={styles.itemDataGroupTagItem}
+				>
+					{value === '' ? '<no-value>' : value}
+				</Badge>
+			))}
+		</div>
+	);
+}

frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
-
-export type ClusterDetailsProps = {
-	cluster: K8sClustersData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,624 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import ClusterEvents from '../../EntityDetailsUtils/EntityEvents';
-import ClusterLogs from '../../EntityDetailsUtils/EntityLogs';
-import ClusterMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import ClusterTraces from '../../EntityDetailsUtils/EntityTraces';
-import { ClusterDetailsProps } from './ClusterDetails.interfaces';
-import { clusterWidgetInfo, getClusterMetricsQueryPayload } from './constants';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function ClusterDetails({
-	cluster,
-	onClose,
-	isModalTimeSelection,
-}: ClusterDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_CLUSTER_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_cluster_name--string--resource--false',
-					},
-					op: '=',
-					value: cluster?.meta.k8s_cluster_name || '',
-				},
-			],
-		};
-	}, [
-		cluster?.meta.k8s_cluster_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Cluster',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: cluster?.meta.k8s_cluster_name || '',
-				},
-			],
-		};
-	}, [cluster?.meta.k8s_cluster_name, eventsFiltersParam]);
-
-	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (cluster) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Cluster,
-			});
-		}
-	}, [cluster]);
-
-	useEffect(() => {
-		setLogsAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Cluster,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Cluster,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogsAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_CLUSTER_NAME].includes(item.key?.key ?? ''),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.LogsView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogsAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_CLUSTER_NAME].includes(item.key?.key ?? ''),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.TracesView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const clusterKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const clusterNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.EventsView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							clusterKindFilter,
-							clusterNameFilter,
-							...(value?.items?.filter(
-								(item) =>
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Cluster,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logsAndTracesFilters,
-				items:
-					logsAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') ||
-					[],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logsAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{cluster?.meta.k8s_cluster_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!cluster}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{cluster && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={cluster.meta.k8s_cluster_name}>
-										{cluster.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<ClusterMetrics<K8sClustersData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={cluster}
-							entityWidgetInfo={clusterWidgetInfo}
-							getEntityQueryPayload={getClusterMetricsQueryPayload}
-							category={K8sCategory.CLUSTERS}
-							queryKey="clusterMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<ClusterLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logsAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="clusterLogs"
-							category={K8sCategory.CLUSTERS}
-							queryKeyFilters={[QUERY_KEYS.K8S_CLUSTER_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<ClusterTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logsAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="clusterTraces"
-							category={InfraMonitoringEvents.Cluster}
-							queryKeyFilters={[QUERY_KEYS.K8S_CLUSTER_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<ClusterEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.CLUSTERS}
-							queryKey="clusterEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default ClusterDetails;

frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.styles.scss

@@ -1,17 +0,0 @@
-.infra-monitoring-container {
-	.clusters-list-table {
-		.expanded-table-container {
-			padding-left: 40px;
-		}
-
-		.ant-table-cell {
-			min-width: 223px !important;
-			max-width: 223px !important;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}

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

@@ -1,693 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sClustersListPayload } from 'api/infraMonitoring/getK8sClustersList';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
-import { useGetK8sClustersList } from 'hooks/infraMonitoring/useGetK8sClustersList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
+import { FeatureKeys } from 'constants/features';
+import { useAppContext } from 'providers/App/App';
 
-import { FeatureKeys } from '../../../constants/features';
-import { useAppContext } from '../../../providers/App/App';
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sClustersList, K8sClusterData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	clusterWidgetInfo,
+	getClusterMetricsQueryPayload,
+	k8sClusterDetailsMetadataConfig,
+	k8sClusterGetEntityName,
+	k8sClusterGetSelectedItemFilters,
+	k8sClusterInitialEventsFilter,
+	k8sClusterInitialFilters,
+	k8sClusterInitialLogTracesFilter,
+} from './constants';
 import {
-	useInfraMonitoringClusterName,
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import ClusterDetails from './ClusterDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sClustersListColumns,
-	getK8sClustersListQuery,
-	K8sClustersRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sClustersList.styles.scss';
+	k8sClustersColumns,
+	k8sClustersColumnsConfig,
+	k8sClustersRenderRowData,
+} from './table';
 
 function K8sClustersList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-	const [
-		selectedClusterName,
-		setselectedClusterName,
-	] = useInfraMonitoringClusterName();
-
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.CLUSTERS);
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sClustersRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sClustersRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sClustersListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedClusterName) {
-			return [
-				'clusterList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'clusterList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedClusterName,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sClustersList(
-		fetchGroupedByRowDataQuery as K8sClustersListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.CLUSTERS,
+			const response = await getK8sClustersList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sClustersListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByClustersData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const nestedClustersData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const queryKey = useMemo(() => {
-		if (selectedClusterName) {
-			return [
-				'clusterList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'clusterList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedClusterName,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sClustersList(
-		query as K8sClustersListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const clustersData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedClustersData = useMemo(
-		() => formatDataForTable(clustersData, groupBy),
-		[clustersData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sClustersListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sClustersRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sClustersRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sClustersRowData>
-				| SorterResult<K8sClustersRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Cluster,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					category: InfraMonitoringEvents.Cluster,
-					page: InfraMonitoringEvents.ListPage,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			category: InfraMonitoringEvents.Cluster,
-			page: InfraMonitoringEvents.ListPage,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedClusterData = useMemo(() => {
-		if (!selectedClusterName) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the cluster from the formatted grouped by clusters data
-			return (
-				nestedClustersData.find(
-					(cluster) => cluster.meta.k8s_cluster_name === selectedClusterName,
-				) || null
 			);
-		}
-		// If not grouped by, return the cluster from the clusters data
-		return (
-			clustersData.find(
-				(cluster) => cluster.meta.k8s_cluster_name === selectedClusterName,
-			) || null
-		);
-	}, [selectedClusterName, groupBy.length, clustersData, nestedClustersData]);
 
-	const openClusterInNewTab = (record: K8sClustersRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
-			record.clusterUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sClustersRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openClusterInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedClusterName(record.clusterUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Cluster,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sClustersListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sClustersRowData>[]}
-						dataSource={formattedGroupedByClustersData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openClusterInNewTab(record);
-									return;
-								}
-								setselectedClusterName(record.clusterUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sClustersRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sClustersRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseClusterDetail = (): void => {
-		setselectedClusterName(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					newGroupBy.push(key);
-				}
-			}
-
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(newGroupBy);
-			setExpandedRowKeys([]);
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Cluster,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sClusterData | null; error?: string | null }> => {
+			const response = await getK8sClustersList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Cluster,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedClustersData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
-				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedClusterData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className="k8s-list-table clusters-list-table"
-				dataSource={showTableLoadingState ? [] : formattedClustersData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+		<>
+			<K8sBaseList<K8sClusterData>
+				controlListPrefix={controlListPrefix}
+				entity={K8sCategory.CLUSTERS}
+				tableColumnsDefinitions={k8sClustersColumns}
+				tableColumns={k8sClustersColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sClustersRenderRowData}
+				eventCategory={InfraMonitoringEvents.Cluster}
 			/>
 
-			<ClusterDetails
-				cluster={selectedClusterData}
-				isModalTimeSelection
-				onClose={handleCloseClusterDetail}
+			<K8sBaseDetails<K8sClusterData>
+				category={K8sCategory.CLUSTERS}
+				eventCategory={InfraMonitoringEvents.Cluster}
+				getSelectedItemFilters={k8sClusterGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sClusterGetEntityName}
+				getInitialLogTracesFilters={k8sClusterInitialLogTracesFilter}
+				getInitialEventsFilters={k8sClusterInitialEventsFilter}
+				primaryFilterKeys={k8sClusterInitialFilters}
+				metadataConfig={k8sClusterDetailsMetadataConfig}
+				entityWidgetInfo={clusterWidgetInfo}
+				getEntityQueryPayload={getClusterMetricsQueryPayload}
+				queryKeyPrefix="cluster"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Clusters/api.ts

@@ -1,11 +1,12 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
-import { UnderscoreToDotMap } from '../utils';
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sClustersListPayload {
 	filters: TagFilter;
@@ -18,7 +19,7 @@ export interface K8sClustersListPayload {
 	};
 }
 
-export interface K8sClustersData {
+export interface K8sClusterData {
 	clusterUID: string;
 	cpuUsage: number;
 	cpuAllocatable: number;
@@ -34,7 +35,7 @@ export interface K8sClustersListResponse {
 	status: string;
 	data: {
 		type: string;
-		records: K8sClustersData[];
+		records: K8sClusterData[];
 		groups: null;
 		total: number;
 		sentAnyHostMetricsData: boolean;
@@ -49,7 +50,7 @@ export const clustersMetaMap = [
 
 export function mapClustersMeta(
 	raw: Record<string, unknown>,
-): K8sClustersData['meta'] {
+): K8sClusterData['meta'] {
 	const out: Record<string, unknown> = { ...raw };
 	clustersMetaMap.forEach(({ dot, under }) => {
 		if (dot in raw) {
@@ -57,11 +58,11 @@ export function mapClustersMeta(
 			out[under] = typeof v === 'string' ? v : raw[under];
 		}
 	});
-	return out as K8sClustersData['meta'];
+	return out as K8sClusterData['meta'];
 }
 
 export const getK8sClustersList = async (
-	props: K8sClustersListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
@@ -73,7 +74,7 @@ export const getK8sClustersList = async (
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;
@@ -106,7 +107,6 @@ export const getK8sClustersList = async (
 		});
 		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>),

frontend/src/container/InfraMonitoringK8s/Clusters/constants.ts

@@ -1,11 +1,57 @@
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sClusterData } from './api';
+
+export const k8sClusterGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_cluster_name',
+			key: {
+				key: 'k8s_cluster_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sClusterDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sClusterData>[] = [
+	{ label: 'Cluster Name', getValue: (p): string => p.meta.k8s_cluster_name },
+];
+
+export const k8sClusterInitialFilters = [QUERY_KEYS.K8S_CLUSTER_NAME];
+
+export const k8sClusterInitialEventsFilter = (
+	item: K8sClusterData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Cluster'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sClusterInitialLogTracesFilter = (
+	item: K8sClusterData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_CLUSTER_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sClusterGetEntityName = (item: K8sClusterData): string =>
+	item.meta.k8s_cluster_name;
+
 export const clusterWidgetInfo = [
 	{
 		title: 'CPU Usage, allocatable',
@@ -42,7 +88,7 @@ export const clusterWidgetInfo = [
 ];
 
 export const getClusterMetricsQueryPayload = (
-	cluster: K8sClustersData,
+	cluster: K8sClusterData,
 	start: number,
 	end: number,
 	dotMetricsEnabled: boolean,

frontend/src/container/InfraMonitoringK8s/Clusters/table.module.scss

@@ -0,0 +1,6 @@
+.entityGroupHeader {
+	display: flex;
+	align-items: center;
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+}

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

@@ -0,0 +1,183 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { K8sClusterData, K8sClustersListPayload } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sClustersRowData {
+	key: string;
+	itemKey: string;
+	clusterUID: string;
+	clusterName: React.ReactNode;
+	cpu: React.ReactNode;
+	cpu_allocatable: React.ReactNode;
+	memory: React.ReactNode;
+	memory_allocatable: React.ReactNode;
+	groupedByMeta?: Record<string, string>;
+}
+
+export const k8sClustersColumns: IEntityColumn[] = [
+	{
+		label: 'Cluster Group',
+		value: 'clusterGroup',
+		id: 'clusterGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterName',
+		id: 'clusterName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Alloc (cores)',
+		value: 'cpu_allocatable',
+		id: 'cpu_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Alloc (bytes)',
+		value: 'memory_allocatable',
+		id: 'memory_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const getK8sClustersListQuery = (): K8sClustersListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+export const k8sClustersColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> CLUSTER GROUP
+			</div>
+		),
+		dataIndex: 'clusterGroup',
+		key: 'clusterGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 150,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Alloc (cores)</div>,
+		dataIndex: 'cpu_allocatable',
+		key: 'cpu_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Allocatable</div>,
+		dataIndex: 'memory_allocatable',
+		key: 'memory_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sClustersRenderRowData = (
+	cluster: K8sClusterData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		cluster,
+		() =>
+			cluster.clusterUID ||
+			cluster.meta.k8s_cluster_uid ||
+			cluster.meta.k8s_cluster_name,
+		groupBy,
+	),
+	itemKey: cluster.meta.k8s_cluster_name,
+	clusterUID: cluster.clusterUID || cluster.meta.k8s_cluster_uid,
+	clusterName: (
+		<Tooltip title={cluster.meta.k8s_cluster_name}>
+			{cluster.meta.k8s_cluster_name || ''}
+		</Tooltip>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={cluster.cpuUsage}>
+			{cluster.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={cluster.memoryUsage}>
+			{formatBytes(cluster.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	cpu_allocatable: (
+		<ValidateColumnValueWrapper value={cluster.cpuAllocatable}>
+			{cluster.cpuAllocatable}
+		</ValidateColumnValueWrapper>
+	),
+	memory_allocatable: (
+		<ValidateColumnValueWrapper value={cluster.memoryAllocatable}>
+			{formatBytes(cluster.memoryAllocatable)}
+		</ValidateColumnValueWrapper>
+	),
+	clusterGroup: getGroupByEl(cluster, groupBy),
+	...cluster.meta,
+	groupedByMeta: getGroupedByMeta(cluster, groupBy),
+});

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

@@ -1,206 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sClustersData,
-	K8sClustersListPayload,
-} from 'api/infraMonitoring/getK8sClustersList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Cluster Name',
-		value: 'clusterName',
-		id: 'cluster',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Allocatable (cores)',
-		value: 'cpu_allocatable',
-		id: 'cpu_allocatable',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Allocatable',
-		value: 'memory_allocatable',
-		id: 'memory_allocatable',
-		canRemove: false,
-	},
-];
-
-export interface K8sClustersRowData {
-	key: string;
-	clusterUID: string;
-	clusterName: React.ReactNode;
-	cpu: React.ReactNode;
-	memory: React.ReactNode;
-	cpu_allocatable: React.ReactNode;
-	memory_allocatable: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const clusterGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> CLUSTER GROUP
-		</div>
-	),
-	dataIndex: 'clusterGroup',
-	key: 'clusterGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sClustersListQuery = (): K8sClustersListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnsConfig = [
-	{
-		title: <div className="column-header-left">Cluster Name</div>,
-		dataIndex: 'clusterName',
-		key: 'clusterName',
-		ellipsis: true,
-		width: 150,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Utilization (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Allocatable (cores)</div>,
-		dataIndex: 'cpu_allocatable',
-		key: 'cpu_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Utilization (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Allocatable</div>,
-		dataIndex: 'memory_allocatable',
-		key: 'memory_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-];
-
-export const getK8sClustersListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sClustersRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'clusterName',
-		);
-		filteredColumns.unshift(clusterGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sClustersRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		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 (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sClustersData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sClustersRowData[] =>
-	data.map((cluster, index) => ({
-		key: index.toString(),
-		clusterUID: cluster.meta.k8s_cluster_name,
-		clusterName: (
-			<Tooltip title={cluster.meta.k8s_cluster_name}>
-				{cluster.meta.k8s_cluster_name}
-			</Tooltip>
-		),
-		cpu: (
-			<ValidateColumnValueWrapper value={cluster.cpuUsage}>
-				{cluster.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={cluster.memoryUsage}>
-				{formatBytes(cluster.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		cpu_allocatable: (
-			<ValidateColumnValueWrapper value={cluster.cpuAllocatable}>
-				{cluster.cpuAllocatable}
-			</ValidateColumnValueWrapper>
-		),
-		memory_allocatable: (
-			<ValidateColumnValueWrapper value={cluster.memoryAllocatable}>
-				{formatBytes(cluster.memoryAllocatable)}
-			</ValidateColumnValueWrapper>
-		),
-		clusterGroup: getGroupByEle(cluster, groupBy),
-		meta: cluster.meta,
-		...cluster.meta,
-		groupedByMeta: cluster.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/DaemonSetDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sDaemonSetsData } from 'api/infraMonitoring/getK8sDaemonSetsList';
-
-export type DaemonSetDetailsProps = {
-	daemonSet: K8sDaemonSetsData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,667 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import DaemonSetEvents from '../../EntityDetailsUtils/EntityEvents';
-import DaemonSetLogs from '../../EntityDetailsUtils/EntityLogs';
-import DaemonSetMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import DaemonSetTraces from '../../EntityDetailsUtils/EntityTraces';
-import { QUERY_KEYS } from '../../EntityDetailsUtils/utils';
-import {
-	daemonSetWidgetInfo,
-	getDaemonSetMetricsQueryPayload,
-} from './constants';
-import { DaemonSetDetailsProps } from './DaemonSetDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function DaemonSetDetails({
-	daemonSet,
-	onClose,
-	isModalTimeSelection,
-}: DaemonSetDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_DAEMON_SET_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_daemonSet_name--string--resource--false',
-					},
-					op: '=',
-					value: daemonSet?.meta.k8s_daemonset_name || '',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_daemonSet_name--string--resource--false',
-					},
-					op: '=',
-					value: daemonSet?.meta.k8s_namespace_name || '',
-				},
-			],
-		};
-	}, [
-		daemonSet?.meta.k8s_daemonset_name,
-		daemonSet?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'DaemonSet',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: daemonSet?.meta.k8s_daemonset_name || '',
-				},
-			],
-		};
-	}, [daemonSet?.meta.k8s_daemonset_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (daemonSet) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.DaemonSet,
-			});
-		}
-	}, [daemonSet]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.DaemonSet,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.DaemonSet,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_DAEMON_SET_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' &&
-						item.key?.key !== QUERY_KEYS.K8S_DAEMON_SET_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.DaemonSet,
-						view: InfraMonitoringEvents.LogsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_DAEMON_SET_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.DaemonSet,
-						view: InfraMonitoringEvents.TracesView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_DAEMON_SET_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const daemonSetKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const daemonSetNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.DaemonSet,
-						view: InfraMonitoringEvents.EventsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						daemonSetKindFilter,
-						daemonSetNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.DaemonSet,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items: logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id'),
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{daemonSet?.meta.k8s_daemonset_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!daemonSet}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{daemonSet && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Daemonset Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={daemonSet.meta.k8s_daemonset_name}>
-										{daemonSet.meta.k8s_daemonset_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={daemonSet.meta.k8s_cluster_name}>
-										{daemonSet.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={daemonSet.meta.k8s_namespace_name}>
-										{daemonSet.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<DaemonSetMetrics
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={daemonSet}
-							entityWidgetInfo={daemonSetWidgetInfo}
-							getEntityQueryPayload={getDaemonSetMetricsQueryPayload}
-							category={K8sCategory.DAEMONSETS}
-							queryKey="daemonsetMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<DaemonSetLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.DAEMONSETS}
-							queryKey="daemonsetLogs"
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_DAEMON_SET_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<DaemonSetTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="daemonsetTraces"
-							category={InfraMonitoringEvents.DaemonSet}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_DAEMON_SET_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<DaemonSetEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							queryKey="daemonsetEvents"
-							category={K8sCategory.DAEMONSETS}
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default DaemonSetDetails;

frontend/src/container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/DaemonSets/K8sDaemonSetsList.styles.scss

@@ -1,62 +0,0 @@
-.infra-monitoring-container {
-	.daemonSets-list-table {
-		.expanded-table-container {
-			padding-left: 20px;
-		}
-
-		.ant-table-cell.column-progress-bar {
-			min-width: 180px;
-			max-width: 180px;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-
-		.progress-container {
-			display: flex;
-			justify-content: start;
-		}
-	}
-}
-
-.ant-table-cell {
-	&:has(.daemonset-name-header) {
-		min-width: 250px !important;
-		max-width: 250px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.namespace-name-header) {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.med-col) {
-		min-width: 200px !important;
-		max-width: 200px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.small-col) {
-		min-width: 120px !important;
-		max-width: 120px !important;
-	}
-}
-
-.expanded-daemonsets-list-table {
-	.ant-table-cell {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-
-	.ant-table-row-expand-icon-cell {
-		min-width: 30px !important;
-		max-width: 30px !important;
-	}
-}

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

@@ -1,715 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sDaemonSetsListPayload } from 'api/infraMonitoring/getK8sDaemonSetsList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
-import { useGetK8sDaemonSetsList } from 'hooks/infraMonitoring/useGetK8sDaemonSetsList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
+import { FeatureKeys } from 'constants/features';
+import { useAppContext } from 'providers/App/App';
 
-import { FeatureKeys } from '../../../constants/features';
-import { useAppContext } from '../../../providers/App/App';
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sDaemonSetsList, K8sDaemonSetsData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	daemonSetWidgetInfo,
+	getDaemonSetMetricsQueryPayload,
+	k8sDaemonSetDetailsMetadataConfig,
+	k8sDaemonSetGetEntityName,
+	k8sDaemonSetGetSelectedItemFilters,
+	k8sDaemonSetInitialEventsFilter,
+	k8sDaemonSetInitialFilters,
+	k8sDaemonSetInitialLogTracesFilter,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringDaemonSetUID,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import DaemonSetDetails from './DaemonSetDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sDaemonSetsListColumns,
-	getK8sDaemonSetsListQuery,
-	K8sDaemonSetsRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sDaemonSetsList.styles.scss';
+	k8sDaemonSetsColumns,
+	k8sDaemonSetsColumnsConfig,
+	k8sDaemonSetsRenderRowData,
+} from './table';
 
 function K8sDaemonSetsList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [
-		selectedDaemonSetUID,
-		setSelectedDaemonSetUID,
-	] = useInfraMonitoringDaemonSetUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.DAEMONSETS);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sDaemonSetsRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sDaemonSetsRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sDaemonSetsListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedDaemonSetUID) {
-			return [
-				'daemonSetList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'daemonSetList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedDaemonSetUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sDaemonSetsList(
-		fetchGroupedByRowDataQuery as K8sDaemonSetsListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.DAEMONSETS,
+			const response = await getK8sDaemonSetsList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.DAEMONSETS,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sDaemonSetsListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByDaemonSetsData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const queryKey = useMemo(() => {
-		if (selectedDaemonSetUID) {
-			return [
-				'daemonSetList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'daemonSetList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedDaemonSetUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sDaemonSetsList(
-		query as K8sDaemonSetsListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const daemonSetsData = useMemo(() => data?.payload?.data?.records || [], [
-		data,
-	]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedDaemonSetsData = useMemo(
-		() => formatDataForTable(daemonSetsData, groupBy),
-		[daemonSetsData, groupBy],
-	);
-
-	const nestedDaemonSetsData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const columns = useMemo(() => getK8sDaemonSetsListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sDaemonSetsRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sDaemonSetsRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sDaemonSetsRowData>
-				| SorterResult<K8sDaemonSetsRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.DaemonSet,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.DaemonSet,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.DaemonSet,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedDaemonSetData = useMemo(() => {
-		if (groupBy.length > 0) {
-			// If grouped by, return the daemonset from the formatted grouped by data
-			return (
-				nestedDaemonSetsData.find(
-					(daemonSet) => daemonSet.daemonSetName === selectedDaemonSetUID,
-				) || null
 			);
-		}
-		// If not grouped by, return the daemonset from the daemonsets data
-		return (
-			daemonSetsData.find(
-				(daemonSet) => daemonSet.daemonSetName === selectedDaemonSetUID,
-			) || null
-		);
-	}, [
-		selectedDaemonSetUID,
-		groupBy.length,
-		daemonSetsData,
-		nestedDaemonSetsData,
-	]);
 
-	const openDaemonSetInNewTab = (record: K8sDaemonSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
-			record.daemonsetUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sDaemonSetsRowData,
-		event?: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openDaemonSetInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setSelectedDaemonSetUID(record.daemonsetUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.DaemonSet,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sDaemonSetsListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sDaemonSetsRowData>[]}
-						dataSource={formattedGroupedByDaemonSetsData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openDaemonSetInNewTab(record);
-									return;
-								}
-								setSelectedDaemonSetUID(record.daemonsetUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sDaemonSetsRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sDaemonSetsRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseDaemonSetDetail = (): void => {
-		setSelectedDaemonSetUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.DaemonSet,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sDaemonSetsData | null; error?: string | null }> => {
+			const response = await getK8sDaemonSetsList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.DaemonSet,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedDaemonSetsData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sDaemonSetsData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.DAEMONSETS}
-				showAutoRefresh={!selectedDaemonSetData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', 'daemonSets-list-table', {
-					'expanded-daemonsets-list-table': isGroupedByAttribute,
-				})}
-				dataSource={showTableLoadingState ? [] : formattedDaemonSetsData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sDaemonSetsColumns}
+				tableColumns={k8sDaemonSetsColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sDaemonSetsRenderRowData}
+				eventCategory={InfraMonitoringEvents.DaemonSet}
 			/>
 
-			<DaemonSetDetails
-				daemonSet={selectedDaemonSetData}
-				isModalTimeSelection
-				onClose={handleCloseDaemonSetDetail}
+			<K8sBaseDetails<K8sDaemonSetsData>
+				category={K8sCategory.DAEMONSETS}
+				eventCategory={InfraMonitoringEvents.DaemonSet}
+				getSelectedItemFilters={k8sDaemonSetGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sDaemonSetGetEntityName}
+				getInitialLogTracesFilters={k8sDaemonSetInitialLogTracesFilter}
+				getInitialEventsFilters={k8sDaemonSetInitialEventsFilter}
+				primaryFilterKeys={k8sDaemonSetInitialFilters}
+				metadataConfig={k8sDaemonSetDetailsMetadataConfig}
+				entityWidgetInfo={daemonSetWidgetInfo}
+				getEntityQueryPayload={getDaemonSetMetricsQueryPayload}
+				queryKeyPrefix="daemonset"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/DaemonSets/api.ts

@@ -1,22 +1,10 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 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[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sDaemonSetsData {
 	daemonSetName: string;
@@ -68,20 +56,19 @@ export function mapDaemonSetsMeta(
 }
 
 export const getK8sDaemonSetsList = async (
-	props: K8sDaemonSetsListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sDaemonSetsListResponse> | ErrorResponse> => {
 	try {
-		// filter prep (unchanged)…
 		const requestProps =
 			dotMetricsEnabled && Array.isArray(props.filters?.items)
 				? {
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;
@@ -114,7 +101,6 @@ export const getK8sDaemonSetsList = async (
 		});
 		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>),

frontend/src/container/InfraMonitoringK8s/DaemonSets/constants.ts

@@ -1,11 +1,72 @@
-import { K8sDaemonSetsData } from 'api/infraMonitoring/getK8sDaemonSetsList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sDaemonSetsData } from './api';
+
+export const k8sDaemonSetGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_daemonset_name',
+			key: {
+				key: 'k8s_daemonset_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sDaemonSetDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sDaemonSetsData>[] = [
+	{
+		label: 'Daemonset Name',
+		getValue: (p): string => p.meta.k8s_daemonset_name,
+	},
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+	{
+		label: 'Namespace Name',
+		getValue: (p): string => p.meta.k8s_namespace_name,
+	},
+];
+
+export const k8sDaemonSetInitialFilters = [
+	QUERY_KEYS.K8S_DAEMON_SET_NAME,
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+];
+
+export const k8sDaemonSetInitialEventsFilter = (
+	item: K8sDaemonSetsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'DaemonSet'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_daemonset_name),
+];
+
+export const k8sDaemonSetInitialLogTracesFilter = (
+	item: K8sDaemonSetsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_DAEMON_SET_NAME, item.meta.k8s_daemonset_name),
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, item.meta.k8s_namespace_name),
+];
+
+export const k8sDaemonSetGetEntityName = (item: K8sDaemonSetsData): string =>
+	item.meta.k8s_daemonset_name;
+
 export const daemonSetWidgetInfo = [
 	{
 		title: 'CPU usage, request, limits',

frontend/src/container/InfraMonitoringK8s/DaemonSets/table.module.scss

@@ -0,0 +1,11 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}
+
+.progressBar {
+	display: flex;
+	justify-content: start;
+}

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

@@ -0,0 +1,297 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import {
+	EntityProgressBar,
+	formatBytes,
+	ValidateColumnValueWrapper,
+} from '../commonUtils';
+import { K8sCategory } from '../constants';
+import { K8sDaemonSetsData } from './api';
+
+import styles from './table.module.scss';
+
+export const k8sDaemonSetsColumns: IEntityColumn[] = [
+	{
+		label: 'DaemonSet Group',
+		value: 'daemonSetGroup',
+		id: 'daemonSetGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'DaemonSet Name',
+		value: 'daemonsetName',
+		id: 'daemonsetName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Namespace Name',
+		value: 'namespaceName',
+		id: 'namespaceName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Available',
+		value: 'available_nodes',
+		id: 'available_nodes',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Desired',
+		value: 'desired_nodes',
+		id: 'desired_nodes',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Req Usage (%)',
+		value: 'cpu_request',
+		id: 'cpu_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Limit Usage (%)',
+		value: 'cpu_limit',
+		id: 'cpu_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Req Usage (%)',
+		value: 'memory_request',
+		id: 'memory_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Limit Usage (%)',
+		value: 'memory_limit',
+		id: 'memory_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const k8sDaemonSetsColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> DAEMONSET GROUP
+			</div>
+		),
+		dataIndex: 'daemonSetGroup',
+		key: 'daemonSetGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>DaemonSet Name</div>,
+		dataIndex: 'daemonsetName',
+		key: 'daemonsetName',
+		ellipsis: true,
+		width: 150,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Namespace Name</div>,
+		dataIndex: 'namespaceName',
+		key: 'namespaceName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Available</div>,
+		dataIndex: 'available_nodes',
+		key: 'available_nodes',
+		width: 50,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Desired</div>,
+		dataIndex: 'desired_nodes',
+		key: 'desired_nodes',
+		width: 50,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Req Usage (%)</div>,
+		dataIndex: 'cpu_request',
+		key: 'cpu_request',
+		width: 180,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Limit Usage (%)</div>,
+		dataIndex: 'cpu_limit',
+		key: 'cpu_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Req Usage (%)</div>,
+		dataIndex: 'memory_request',
+		key: 'memory_request',
+		width: 170,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Limit Usage (%)</div>,
+		dataIndex: 'memory_limit',
+		key: 'memory_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 120,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sDaemonSetsRenderRowData = (
+	entity: K8sDaemonSetsData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		entity,
+		() => entity.daemonSetName || entity.meta.k8s_daemonset_name || '',
+		groupBy,
+	),
+	itemKey: entity.meta.k8s_daemonset_name,
+	daemonsetName: (
+		<Tooltip title={entity.meta.k8s_daemonset_name}>
+			{entity.meta.k8s_daemonset_name || ''}
+		</Tooltip>
+	),
+	namespaceName: (
+		<Tooltip title={entity.meta.k8s_namespace_name}>
+			{entity.meta.k8s_namespace_name || ''}
+		</Tooltip>
+	),
+	cpu_request: (
+		<ValidateColumnValueWrapper
+			value={entity.cpuRequest}
+			entity={K8sCategory.DAEMONSETS}
+			attribute="CPU Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={entity.cpuRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu_limit: (
+		<ValidateColumnValueWrapper
+			value={entity.cpuLimit}
+			entity={K8sCategory.DAEMONSETS}
+			attribute="CPU Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={entity.cpuLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={entity.cpuUsage}>
+			{entity.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory_request: (
+		<ValidateColumnValueWrapper
+			value={entity.memoryRequest}
+			entity={K8sCategory.DAEMONSETS}
+			attribute="Memory Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={entity.memoryRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory_limit: (
+		<ValidateColumnValueWrapper
+			value={entity.memoryLimit}
+			entity={K8sCategory.DAEMONSETS}
+			attribute="Memory Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={entity.memoryLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={entity.memoryUsage}>
+			{formatBytes(entity.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	available_nodes: (
+		<ValidateColumnValueWrapper value={entity.availableNodes}>
+			{entity.availableNodes}
+		</ValidateColumnValueWrapper>
+	),
+	desired_nodes: (
+		<ValidateColumnValueWrapper value={entity.desiredNodes}>
+			{entity.desiredNodes}
+		</ValidateColumnValueWrapper>
+	),
+	daemonSetGroup: getGroupByEl(entity, groupBy),
+	...entity.meta,
+	groupedByMeta: getGroupedByMeta(entity, groupBy),
+});

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

@@ -1,356 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sDaemonSetsData,
-	K8sDaemonSetsListPayload,
-} from 'api/infraMonitoring/getK8sDaemonSetsList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	EntityProgressBar,
-	formatBytes,
-	ValidateColumnValueWrapper,
-} from '../commonUtils';
-import { K8sCategory } from '../constants';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'DaemonSet Name',
-		value: 'daemonsetName',
-		id: 'daemonsetName',
-		canRemove: false,
-	},
-	{
-		label: 'Namespace Name',
-		value: 'namespaceName',
-		id: 'namespaceName',
-		canRemove: false,
-	},
-	{
-		label: 'Available',
-		value: 'available_nodes',
-		id: 'available_nodes',
-		canRemove: false,
-	},
-	{
-		label: 'Desired',
-		value: 'desired_nodes',
-		id: 'desired_nodes',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Req Usage (%)',
-		value: 'cpu_request',
-		id: 'cpu_request',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Limit Usage (%)',
-		value: 'cpu_limit',
-		id: 'cpu_limit',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Req Usage (%)',
-		value: 'memory_request',
-		id: 'memory_request',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Limit Usage (%)',
-		value: 'memory_limit',
-		id: 'memory_limit',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-];
-
-export interface K8sDaemonSetsRowData {
-	key: string;
-	daemonsetUID: string;
-	daemonsetName: React.ReactNode;
-	cpu_request: React.ReactNode;
-	cpu_limit: React.ReactNode;
-	cpu: React.ReactNode;
-	memory_request: React.ReactNode;
-	memory_limit: React.ReactNode;
-	memory: React.ReactNode;
-	desired_nodes: React.ReactNode;
-	available_nodes: React.ReactNode;
-	namespaceName: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const daemonSetGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> DAEMONSET GROUP
-		</div>
-	),
-	dataIndex: 'daemonSetGroup',
-	key: 'daemonSetGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sDaemonSetsListQuery = (): K8sDaemonSetsListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnProgressBarClassName = 'column-progress-bar';
-
-const columnsConfig = [
-	{
-		title: (
-			<div className="column-header-left daemonset-name-header">
-				DaemonSet Name
-			</div>
-		),
-		dataIndex: 'daemonsetName',
-		key: 'daemonsetName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: (
-			<div className="column-header-left namespace-name-header">
-				Namespace Name
-			</div>
-		),
-		dataIndex: 'namespaceName',
-		key: 'namespaceName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header small-col">Available</div>,
-		dataIndex: 'available_nodes',
-		key: 'available_nodes',
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">Desired</div>,
-		dataIndex: 'desired_nodes',
-		key: 'desired_nodes',
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Req Usage (%)</div>,
-		dataIndex: 'cpu_request',
-		key: 'cpu_request',
-		width: 180,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Limit Usage (%)</div>,
-		dataIndex: 'cpu_limit',
-		key: 'cpu_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Req Usage (%)</div>,
-		dataIndex: 'memory_request',
-		key: 'memory_request',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Limit Usage (%)</div>,
-		dataIndex: 'memory_limit',
-		key: 'memory_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 120,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-];
-
-export const getK8sDaemonSetsListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sDaemonSetsRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'daemonsetName',
-		);
-		filteredColumns.unshift(daemonSetGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sDaemonSetsRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		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 (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sDaemonSetsData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sDaemonSetsRowData[] =>
-	data.map((daemonSet, index) => ({
-		key: index.toString(),
-		daemonsetUID: daemonSet.daemonSetName,
-		daemonsetName: (
-			<Tooltip title={daemonSet.meta.k8s_daemonset_name}>
-				{daemonSet.meta.k8s_daemonset_name || ''}
-			</Tooltip>
-		),
-		namespaceName: (
-			<Tooltip title={daemonSet.meta.k8s_namespace_name}>
-				{daemonSet.meta.k8s_namespace_name || ''}
-			</Tooltip>
-		),
-		cpu_request: (
-			<ValidateColumnValueWrapper
-				value={daemonSet.cpuRequest}
-				entity={K8sCategory.DAEMONSETS}
-				attribute="CPU Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={daemonSet.cpuRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu_limit: (
-			<ValidateColumnValueWrapper
-				value={daemonSet.cpuLimit}
-				entity={K8sCategory.DAEMONSETS}
-				attribute="CPU Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={daemonSet.cpuLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu: (
-			<ValidateColumnValueWrapper value={daemonSet.cpuUsage}>
-				{daemonSet.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory_request: (
-			<ValidateColumnValueWrapper
-				value={daemonSet.memoryRequest}
-				entity={K8sCategory.DAEMONSETS}
-				attribute="Memory Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={daemonSet.memoryRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory_limit: (
-			<ValidateColumnValueWrapper
-				value={daemonSet.memoryLimit}
-				entity={K8sCategory.DAEMONSETS}
-				attribute="Memory Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={daemonSet.memoryLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={daemonSet.memoryUsage}>
-				{formatBytes(daemonSet.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		available_nodes: (
-			<ValidateColumnValueWrapper value={daemonSet.availableNodes}>
-				{daemonSet.availableNodes}
-			</ValidateColumnValueWrapper>
-		),
-		desired_nodes: (
-			<ValidateColumnValueWrapper value={daemonSet.desiredNodes}>
-				{daemonSet.desiredNodes}
-			</ValidateColumnValueWrapper>
-		),
-		daemonSetGroup: getGroupByEle(daemonSet, groupBy),
-		meta: daemonSet.meta,
-		...daemonSet.meta,
-		groupedByMeta: daemonSet.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/Deployments/DeploymentDetails/DeploymentDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sDeploymentsData } from 'api/infraMonitoring/getK8sDeploymentsList';
-
-export type DeploymentDetailsProps = {
-	deployment: K8sDeploymentsData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,671 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sDeploymentsData } from 'api/infraMonitoring/getK8sDeploymentsList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import DeploymentEvents from '../../EntityDetailsUtils/EntityEvents';
-import DeploymentLogs from '../../EntityDetailsUtils/EntityLogs';
-import DeploymentMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import DeploymentTraces from '../../EntityDetailsUtils/EntityTraces';
-import {
-	deploymentWidgetInfo,
-	getDeploymentMetricsQueryPayload,
-} from './constants';
-import { DeploymentDetailsProps } from './DeploymentDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function DeploymentDetails({
-	deployment,
-	onClose,
-	isModalTimeSelection,
-}: DeploymentDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_DEPLOYMENT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_deployment_name--string--resource--false',
-					},
-					op: '=',
-					value: deployment?.meta.k8s_deployment_name || '',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_deployment_name--string--resource--false',
-					},
-					op: '=',
-					value: deployment?.meta.k8s_namespace_name || '',
-				},
-			],
-		};
-	}, [
-		deployment?.meta.k8s_deployment_name,
-		deployment?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Deployment',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: deployment?.meta.k8s_deployment_name || '',
-				},
-			],
-		};
-	}, [deployment?.meta.k8s_deployment_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (deployment) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Deployment,
-			});
-		}
-	}, [deployment]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Deployment,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Deployment,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_DEPLOYMENT_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' &&
-						item.key?.key !== QUERY_KEYS.K8S_DEPLOYMENT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Deployment,
-						view: InfraMonitoringEvents.LogsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_DEPLOYMENT_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Deployment,
-						view: InfraMonitoringEvents.TracesView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_DEPLOYMENT_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const deploymentKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const deploymentNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Deployment,
-						view: InfraMonitoringEvents.EventsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							deploymentKindFilter,
-							deploymentNameFilter,
-							...(value?.items?.filter(
-								(item) =>
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Deployment,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items: logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id'),
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{deployment?.meta.k8s_deployment_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!deployment}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{deployment && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Deployment Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={deployment.meta.k8s_deployment_name}>
-										{deployment.meta.k8s_deployment_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={deployment.meta.k8s_cluster_name}>
-										{deployment.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={deployment.meta.k8s_namespace_name}>
-										{deployment.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<DeploymentMetrics<K8sDeploymentsData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={deployment}
-							entityWidgetInfo={deploymentWidgetInfo}
-							getEntityQueryPayload={getDeploymentMetricsQueryPayload}
-							category={K8sCategory.DEPLOYMENTS}
-							queryKey="deploymentMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<DeploymentLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_DEPLOYMENT_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-							queryKey="deploymentLogs"
-							category={K8sCategory.DEPLOYMENTS}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<DeploymentTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="deploymentTraces"
-							category={InfraMonitoringEvents.Deployment}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_DEPLOYMENT_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<DeploymentEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.DEPLOYMENTS}
-							queryKey="deploymentEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default DeploymentDetails;

frontend/src/container/InfraMonitoringK8s/Deployments/DeploymentDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/Deployments/K8sDeploymentsList.styles.scss

@@ -1,57 +0,0 @@
-.infra-monitoring-container {
-	.deployments-list-table {
-		.expanded-table-container {
-			padding-left: 20px;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}
-
-.ant-table-cell {
-	&:has(.deployment-name-header) {
-		min-width: 250px !important;
-		max-width: 250px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.namespace-name-header) {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.med-col) {
-		min-width: 200px !important;
-		max-width: 200px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.small-col) {
-		min-width: 120px !important;
-		max-width: 120px !important;
-	}
-}
-
-.progress-container {
-	display: flex !important;
-	justify-content: start !important;
-}
-
-.expanded-deployments-list-table {
-	.ant-table-cell {
-		min-width: 180px !important;
-		max-width: 180px !important;
-	}
-
-	.ant-table-row-expand-icon-cell {
-		min-width: 30px !important;
-		max-width: 30px !important;
-	}
-}

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

@@ -1,722 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sDeploymentsListPayload } from 'api/infraMonitoring/getK8sDeploymentsList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sDeploymentsList } from 'hooks/infraMonitoring/useGetK8sDeploymentsList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sDeploymentsList, K8sDeploymentsData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	deploymentWidgetInfo,
+	getDeploymentMetricsQueryPayload,
+	k8sDeploymentDetailsMetadataConfig,
+	k8sDeploymentGetEntityName,
+	k8sDeploymentGetSelectedItemFilters,
+	k8sDeploymentInitialEventsFilter,
+	k8sDeploymentInitialFilters,
+	k8sDeploymentInitialLogTracesFilter,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringDeploymentUID,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import DeploymentDetails from './DeploymentDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sDeploymentsListColumns,
-	getK8sDeploymentsListQuery,
-	K8sDeploymentsRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sDeploymentsList.styles.scss';
+	k8sDeploymentsColumns,
+	k8sDeploymentsColumnsConfig,
+	k8sDeploymentsRenderRowData,
+} from './table';
 
 function K8sDeploymentsList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [
-		selectedDeploymentUID,
-		setselectedDeploymentUID,
-	] = useInfraMonitoringDeploymentUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.DEPLOYMENTS);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sDeploymentsRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sDeploymentsRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sDeploymentsListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedDeploymentUID) {
-			return [
-				'deploymentList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'deploymentList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedDeploymentUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sDeploymentsList(
-		fetchGroupedByRowDataQuery as K8sDeploymentsListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.DEPLOYMENTS,
+			const response = await getK8sDeploymentsList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sDeploymentsListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByDeploymentsData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const queryKey = useMemo(() => {
-		if (selectedDeploymentUID) {
-			return [
-				'deploymentList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'deploymentList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedDeploymentUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sDeploymentsList(
-		query as K8sDeploymentsListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const deploymentsData = useMemo(() => data?.payload?.data?.records || [], [
-		data,
-	]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedDeploymentsData = useMemo(
-		() => formatDataForTable(deploymentsData, groupBy),
-		[deploymentsData, groupBy],
-	);
-
-	const nestedDeploymentsData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const columns = useMemo(() => getK8sDeploymentsListColumns(groupBy), [
-		groupBy,
-	]);
-
-	const handleGroupByRowClick = (record: K8sDeploymentsRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sDeploymentsRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sDeploymentsRowData>
-				| SorterResult<K8sDeploymentsRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Deployment,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Deployment,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Deployment,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedDeploymentData = useMemo(() => {
-		if (!selectedDeploymentUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the deployment from the formatted grouped by deployments data
-			return (
-				nestedDeploymentsData.find(
-					(deployment) => deployment.deploymentName === selectedDeploymentUID,
-				) || null
 			);
-		}
-		// If not grouped by, return the deployment from the deployments data
-		return (
-			deploymentsData.find(
-				(deployment) => deployment.deploymentName === selectedDeploymentUID,
-			) || null
-		);
-	}, [
-		selectedDeploymentUID,
-		groupBy.length,
-		deploymentsData,
-		nestedDeploymentsData,
-	]);
 
-	const openDeploymentInNewTab = (record: K8sDeploymentsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
-			record.deploymentUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sDeploymentsRowData,
-		event?: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openDeploymentInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedDeploymentUID(record.deploymentUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Deployment,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sDeploymentsListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sDeploymentsRowData>[]}
-						dataSource={formattedGroupedByDeploymentsData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openDeploymentInNewTab(record);
-									return;
-								}
-								setselectedDeploymentUID(record.deploymentUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sDeploymentsRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sDeploymentsRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseDeploymentDetail = (): void => {
-		setselectedDeploymentUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Deployment,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sDeploymentsData | null; error?: string | null }> => {
+			const response = await getK8sDeploymentsList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Deployment,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedDeploymentsData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
-				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedDeploymentData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', 'deployments-list-table', {
-					'expanded-deployments-list-table': isGroupedByAttribute,
-				})}
-				dataSource={showTableLoadingState ? [] : formattedDeploymentsData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+		<>
+			<K8sBaseList<K8sDeploymentsData>
+				controlListPrefix={controlListPrefix}
+				entity={K8sCategory.DEPLOYMENTS}
+				tableColumnsDefinitions={k8sDeploymentsColumns}
+				tableColumns={k8sDeploymentsColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sDeploymentsRenderRowData}
+				eventCategory={InfraMonitoringEvents.Deployment}
 			/>
 
-			<DeploymentDetails
-				deployment={selectedDeploymentData}
-				isModalTimeSelection
-				onClose={handleCloseDeploymentDetail}
+			<K8sBaseDetails<K8sDeploymentsData>
+				category={K8sCategory.DEPLOYMENTS}
+				eventCategory={InfraMonitoringEvents.Deployment}
+				getSelectedItemFilters={k8sDeploymentGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sDeploymentGetEntityName}
+				getInitialLogTracesFilters={k8sDeploymentInitialLogTracesFilter}
+				getInitialEventsFilters={k8sDeploymentInitialEventsFilter}
+				primaryFilterKeys={k8sDeploymentInitialFilters}
+				metadataConfig={k8sDeploymentDetailsMetadataConfig}
+				entityWidgetInfo={deploymentWidgetInfo}
+				getEntityQueryPayload={getDeploymentMetricsQueryPayload}
+				queryKeyPrefix="deployment"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Deployments/api.ts

@@ -1,11 +1,12 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
-import { UnderscoreToDotMap } from '../utils';
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sDeploymentsListPayload {
 	filters: TagFilter;
@@ -68,7 +69,7 @@ export function mapDeploymentsMeta(
 }
 
 export const getK8sDeploymentsList = async (
-	props: K8sDeploymentsListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
@@ -80,7 +81,7 @@ export const getK8sDeploymentsList = async (
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;
@@ -113,7 +114,6 @@ export const getK8sDeploymentsList = async (
 		});
 		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>),

frontend/src/container/InfraMonitoringK8s/Deployments/constants.ts

@@ -1,11 +1,75 @@
-import { K8sDeploymentsData } from 'api/infraMonitoring/getK8sDeploymentsList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sDeploymentsData } from './api';
+
+export const k8sDeploymentGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_deployment_name',
+			key: {
+				key: 'k8s_deployment_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sDeploymentDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sDeploymentsData>[] = [
+	{
+		label: 'Deployment Name',
+		getValue: (p): string => p.meta.k8s_deployment_name,
+	},
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+	{
+		label: 'Namespace Name',
+		getValue: (p): string => p.meta.k8s_namespace_name,
+	},
+];
+
+export const k8sDeploymentInitialFilters = [
+	QUERY_KEYS.K8S_DEPLOYMENT_NAME,
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+];
+
+export const k8sDeploymentInitialEventsFilter = (
+	item: K8sDeploymentsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Deployment'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_deployment_name),
+];
+
+export const k8sDeploymentInitialLogTracesFilter = (
+	item: K8sDeploymentsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(
+		QUERY_KEYS.K8S_DEPLOYMENT_NAME,
+		item.meta.k8s_deployment_name,
+	),
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, item.meta.k8s_namespace_name),
+];
+
+export const k8sDeploymentGetEntityName = (item: K8sDeploymentsData): string =>
+	item.meta.k8s_deployment_name;
+
 export const deploymentWidgetInfo = [
 	{
 		title: 'CPU usage, request, limits',

frontend/src/container/InfraMonitoringK8s/Deployments/table.module.scss

@@ -0,0 +1,11 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}
+
+.progressBar {
+	display: flex;
+	justify-content: start;
+}

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

@@ -0,0 +1,269 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import {
+	EntityProgressBar,
+	formatBytes,
+	ValidateColumnValueWrapper,
+} from '../commonUtils';
+import { K8sDeploymentsData } from './api';
+
+import styles from './table.module.scss';
+
+export const k8sDeploymentsColumns: IEntityColumn[] = [
+	{
+		label: 'Deployment Group',
+		value: 'deploymentGroup',
+		id: 'deploymentGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Deployment Name',
+		value: 'deploymentName',
+		id: 'deploymentName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Namespace Name',
+		value: 'namespaceName',
+		id: 'namespaceName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Available',
+		value: 'available_pods',
+		id: 'available_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Desired',
+		value: 'desired_pods',
+		id: 'desired_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Req Usage (%)',
+		value: 'cpu_request',
+		id: 'cpu_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Limit Usage (%)',
+		value: 'cpu_limit',
+		id: 'cpu_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Req Usage (%)',
+		value: 'memory_request',
+		id: 'memory_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Limit Usage (%)',
+		value: 'memory_limit',
+		id: 'memory_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const k8sDeploymentsColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> DEPLOYMENT GROUP
+			</div>
+		),
+		dataIndex: 'deploymentGroup',
+		key: 'deploymentGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Deployment Name</div>,
+		dataIndex: 'deploymentName',
+		key: 'deploymentName',
+		ellipsis: true,
+		width: 150,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Namespace Name</div>,
+		dataIndex: 'namespaceName',
+		key: 'namespaceName',
+		ellipsis: true,
+		width: 150,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Available</div>,
+		dataIndex: 'available_pods',
+		key: 'available_pods',
+		width: 100,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Desired</div>,
+		dataIndex: 'desired_pods',
+		key: 'desired_pods',
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Req Usage (%)</div>,
+		dataIndex: 'cpu_request',
+		key: 'cpu_request',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Limit Usage (%)</div>,
+		dataIndex: 'cpu_limit',
+		key: 'cpu_limit',
+		width: 50,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Req Usage (%)</div>,
+		dataIndex: 'memory_request',
+		key: 'memory_request',
+		width: 50,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Limit Usage (%)</div>,
+		dataIndex: 'memory_limit',
+		key: 'memory_limit',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sDeploymentsRenderRowData = (
+	deployment: K8sDeploymentsData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(deployment, () => deployment.meta.k8s_deployment_name, groupBy),
+	itemKey: deployment.meta.k8s_deployment_name,
+	deploymentName: (
+		<Tooltip title={deployment.meta.k8s_deployment_name}>
+			{deployment.meta.k8s_deployment_name || ''}
+		</Tooltip>
+	),
+	namespaceName: deployment.meta.k8s_namespace_name,
+	available_pods: (
+		<ValidateColumnValueWrapper value={deployment.availablePods}>
+			{deployment.availablePods}
+		</ValidateColumnValueWrapper>
+	),
+	desired_pods: (
+		<ValidateColumnValueWrapper value={deployment.desiredPods}>
+			{deployment.desiredPods}
+		</ValidateColumnValueWrapper>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={deployment.cpuUsage}>
+			{deployment.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	cpu_request: (
+		<ValidateColumnValueWrapper value={deployment.cpuRequest}>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={deployment.cpuRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu_limit: (
+		<ValidateColumnValueWrapper value={deployment.cpuLimit}>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={deployment.cpuLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={deployment.memoryUsage}>
+			{formatBytes(deployment.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	memory_request: (
+		<ValidateColumnValueWrapper value={deployment.memoryRequest}>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={deployment.memoryRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory_limit: (
+		<ValidateColumnValueWrapper value={deployment.memoryLimit}>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={deployment.memoryLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	deploymentGroup: getGroupByEl(deployment, groupBy),
+	...deployment.meta,
+	groupedByMeta: getGroupedByMeta(deployment, groupBy),
+});

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

@@ -1,333 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sDeploymentsData,
-	K8sDeploymentsListPayload,
-} from 'api/infraMonitoring/getK8sDeploymentsList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	EntityProgressBar,
-	formatBytes,
-	ValidateColumnValueWrapper,
-} from '../commonUtils';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Deployment Name',
-		value: 'deploymentName',
-		id: 'deploymentName',
-		canRemove: false,
-	},
-	{
-		label: 'Namespace Name',
-		value: 'namespaceName',
-		id: 'namespaceName',
-		canRemove: false,
-	},
-	{
-		label: 'Available',
-		value: 'available_pods',
-		id: 'available_pods',
-		canRemove: false,
-	},
-	{
-		label: 'Desired',
-		value: 'desired_pods',
-		id: 'desired_pods',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Request Utilization (% of limit)',
-		value: 'cpu_request',
-		id: 'cpu_request',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Limit Utilization (% of request)',
-		value: 'cpu_limit',
-		id: 'cpu_limit',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Utilization (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Request Utilization (% of limit)',
-		value: 'memory_request',
-		id: 'memory_request',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Limit Utilization (% of request)',
-		value: 'memory_limit',
-		id: 'memory_limit',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Utilization (bytes)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-];
-
-export interface K8sDeploymentsRowData {
-	key: string;
-	deploymentUID: string;
-	deploymentName: React.ReactNode;
-	available_pods: React.ReactNode;
-	desired_pods: React.ReactNode;
-	cpu_request: React.ReactNode;
-	cpu_limit: React.ReactNode;
-	cpu: React.ReactNode;
-	memory_request: React.ReactNode;
-	memory_limit: React.ReactNode;
-	memory: React.ReactNode;
-	restarts: React.ReactNode;
-	clusterName: string;
-	namespaceName: string;
-	groupedByMeta?: any;
-}
-
-const deploymentGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> DEPLOYMENT GROUP
-		</div>
-	),
-	dataIndex: 'deploymentGroup',
-	key: 'deploymentGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sDeploymentsListQuery = (): K8sDeploymentsListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnsConfig = [
-	{
-		title: (
-			<div className="column-header-left deployment-name-header">
-				Deployment Name
-			</div>
-		),
-		dataIndex: 'deploymentName',
-		key: 'deploymentName',
-		ellipsis: true,
-		width: 150,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: (
-			<div className="column-header-left namespace-name-header">
-				Namespace Name
-			</div>
-		),
-		dataIndex: 'namespaceName',
-		key: 'namespaceName',
-		ellipsis: true,
-		width: 150,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left small-col">Available</div>,
-		dataIndex: 'available_pods',
-		key: 'available_pods',
-		width: 100,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left small-col">Desired</div>,
-		dataIndex: 'desired_pods',
-		key: 'desired_pods',
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left med-col">CPU Req Usage (%)</div>,
-		dataIndex: 'cpu_request',
-		key: 'cpu_request',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left med-col">CPU Limit Usage (%)</div>,
-		dataIndex: 'cpu_limit',
-		key: 'cpu_limit',
-		width: 50,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header- small-col">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left med-col">Mem Req Usage (%)</div>,
-		dataIndex: 'memory_request',
-		key: 'memory_request',
-		width: 50,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left med-col">Mem Limit Usage (%)</div>,
-		dataIndex: 'memory_limit',
-		key: 'memory_limit',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left small-col">Mem Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 120,
-		sorter: true,
-		align: 'left',
-	},
-];
-
-export const getK8sDeploymentsListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sDeploymentsRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'deploymentName',
-		);
-		filteredColumns.unshift(deploymentGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sDeploymentsRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		const rawKey = group.key as string;
-
-		// Choose mapped key if present, otherwise use rawKey
-		const metaKey = (dotToUnder[rawKey] ??
-			rawKey) as keyof typeof deployment.meta;
-		const value = deployment.meta[metaKey];
-
-		groupByValues.push(value);
-	});
-
-	return (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sDeploymentsData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sDeploymentsRowData[] =>
-	data.map((deployment, index) => ({
-		key: index.toString(),
-		deploymentUID: deployment.meta.k8s_deployment_name,
-		deploymentName: (
-			<Tooltip title={deployment.meta.k8s_deployment_name}>
-				{deployment.meta.k8s_deployment_name}
-			</Tooltip>
-		),
-		available_pods: (
-			<ValidateColumnValueWrapper value={deployment.availablePods}>
-				{deployment.availablePods}
-			</ValidateColumnValueWrapper>
-		),
-		desired_pods: (
-			<ValidateColumnValueWrapper value={deployment.desiredPods}>
-				{deployment.desiredPods}
-			</ValidateColumnValueWrapper>
-		),
-		restarts: (
-			<ValidateColumnValueWrapper value={deployment.restarts}>
-				{deployment.restarts}
-			</ValidateColumnValueWrapper>
-		),
-		cpu: (
-			<ValidateColumnValueWrapper value={deployment.cpuUsage}>
-				{deployment.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		cpu_request: (
-			<ValidateColumnValueWrapper value={deployment.cpuRequest}>
-				<div className="progress-container">
-					<EntityProgressBar value={deployment.cpuRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu_limit: (
-			<ValidateColumnValueWrapper value={deployment.cpuLimit}>
-				<div className="progress-container">
-					<EntityProgressBar value={deployment.cpuLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={deployment.memoryUsage}>
-				{formatBytes(deployment.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		memory_request: (
-			<ValidateColumnValueWrapper value={deployment.memoryRequest}>
-				<div className="progress-container">
-					<EntityProgressBar value={deployment.memoryRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory_limit: (
-			<ValidateColumnValueWrapper value={deployment.memoryLimit}>
-				<div className="progress-container">
-					<EntityProgressBar value={deployment.memoryLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		clusterName: deployment.meta.k8s_cluster_name,
-		namespaceName: deployment.meta.k8s_namespace_name,
-		deploymentGroup: getGroupByEle(deployment, groupBy),
-		meta: deployment.meta,
-		...deployment.meta,
-		groupedByMeta: deployment.meta,
-	}));

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

@@ -29,6 +29,7 @@ export const QUERY_KEYS = {
 	K8S_STATEFUL_SET_NAME: 'k8s.statefulset.name',
 	K8S_JOB_NAME: 'k8s.job.name',
 	K8S_DAEMON_SET_NAME: 'k8s.daemonset.name',
+	K8S_PERSISTENT_VOLUME_CLAIM_NAME: 'k8s.persistentvolumeclaim.name',
 };
 
 /**

frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx

@@ -1,7 +1,7 @@
-import { useState } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { VerticalAlignTopOutlined } from '@ant-design/icons';
 import * as Sentry from '@sentry/react';
-import type { CollapseProps } from 'antd';
+import { Button, CollapseProps } from 'antd';
 import { Collapse, Tooltip, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
@@ -16,6 +16,7 @@ import {
 	Computer,
 	Container,
 	FilePenLine,
+	Filter,
 	Group,
 	HardDrive,
 	Workflow,
@@ -63,13 +64,11 @@ export default function InfraMonitoringK8s(): JSX.Element {
 	const [, setGroupBy] = useInfraMonitoringGroupBy();
 	const [, setOrderBy] = useInfraMonitoringOrderBy();
 
-	const [quickFiltersLastUpdated, setQuickFiltersLastUpdated] = useState(-1);
-
 	const { currentQuery } = useQueryBuilder();
 
-	const handleFilterVisibilityChange = (): void => {
-		setShowFilters(!showFilters);
-	};
+	const handleFilterVisibilityChange = useCallback((): void => {
+		setShowFilters((show) => !show);
+	}, []);
 
 	const { handleChangeQueryData } = useQueryOperations({
 		index: 0,
@@ -86,7 +85,6 @@ export default function InfraMonitoringK8s(): JSX.Element {
 		// 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
 		handleChangeQueryData('filters', query.builder.queryData[0].filters);
-		setQuickFiltersLastUpdated(Date.now());
 		setFilters(JSON.stringify(query.builder.queryData[0].filters));
 
 		logEvent(InfraMonitoringEvents.FilterApplied, {
@@ -321,6 +319,25 @@ export default function InfraMonitoringK8s(): JSX.Element {
 		}
 	};
 
+	const showFiltersComp = useMemo(() => {
+		return (
+			<>
+				{!showFilters && (
+					<div className="quick-filters-toggle-container">
+						<Button
+							className="periscope-btn ghost"
+							type="text"
+							size="small"
+							onClick={handleFilterVisibilityChange}
+						>
+							<Filter size={14} />
+						</Button>
+					</div>
+				)}
+			</>
+		);
+	}, [handleFilterVisibilityChange, showFilters]);
+
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="infra-monitoring-container">
@@ -355,75 +372,39 @@ export default function InfraMonitoringK8s(): JSX.Element {
 						}`}
 					>
 						{selectedCategory === K8sCategories.PODS && (
-							<K8sPodLists
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sPodLists controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.NODES && (
-							<K8sNodesList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sNodesList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.CLUSTERS && (
-							<K8sClustersList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sClustersList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.DEPLOYMENTS && (
-							<K8sDeploymentsList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sDeploymentsList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.NAMESPACES && (
-							<K8sNamespacesList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sNamespacesList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.STATEFULSETS && (
-							<K8sStatefulSetsList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sStatefulSetsList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.JOBS && (
-							<K8sJobsList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sJobsList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.DAEMONSETS && (
-							<K8sDaemonSetsList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sDaemonSetsList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.VOLUMES && (
-							<K8sVolumesList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sVolumesList controlListPrefix={showFiltersComp} />
 						)}
 					</div>
 				</div>

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

@@ -1,7 +0,0 @@
-import { K8sJobsData } from 'api/infraMonitoring/getK8sJobsList';
-
-export type JobDetailsProps = {
-	job: K8sJobsData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,654 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import JobEvents from '../../EntityDetailsUtils/EntityEvents';
-import JobLogs from '../../EntityDetailsUtils/EntityLogs';
-import JobMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import JobTraces from '../../EntityDetailsUtils/EntityTraces';
-import { QUERY_KEYS } from '../../EntityDetailsUtils/utils';
-import { getJobMetricsQueryPayload, jobWidgetInfo } from './constants';
-import { JobDetailsProps } from './JobDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function JobDetails({
-	job,
-	onClose,
-	isModalTimeSelection,
-}: JobDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_JOB_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_job_name--string--resource--false',
-					},
-					op: '=',
-					value: job?.meta.k8s_job_name || '',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_job_name--string--resource--false',
-					},
-					op: '=',
-					value: job?.meta.k8s_namespace_name || '',
-				},
-			],
-		};
-	}, [
-		job?.meta.k8s_job_name,
-		job?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Job',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: job?.meta.k8s_job_name || '',
-				},
-			],
-		};
-	}, [job?.meta.k8s_job_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (job) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Job,
-			});
-		}
-	}, [job]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Job,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Job,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_JOB_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_JOB_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Job,
-						view: 'logs',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_JOB_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Job,
-						view: 'traces',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_JOB_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const jobKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const jobNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Job,
-						view: 'events',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						jobKindFilter,
-						jobNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Job,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items:
-					logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{job?.meta.k8s_job_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!job}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{job && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Job Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={job.meta.k8s_job_name}>
-										{job.meta.k8s_job_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={job.meta.k8s_namespace_name}>
-										{job.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<JobMetrics
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={job}
-							category={K8sCategory.JOBS}
-							queryKey="jobMetrics"
-							entityWidgetInfo={jobWidgetInfo}
-							getEntityQueryPayload={getJobMetricsQueryPayload}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<JobLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.JOBS}
-							queryKey="jobLogs"
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_JOB_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<JobTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="jobTraces"
-							category={InfraMonitoringEvents.Job}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_JOB_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<JobEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.JOBS}
-							queryKey="jobEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default JobDetails;

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

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

frontend/src/container/InfraMonitoringK8s/Jobs/K8sJobsList.styles.scss

@@ -1,62 +0,0 @@
-.infra-monitoring-container {
-	.jobs-list-table {
-		.expanded-table-container {
-			padding-left: 40px;
-		}
-
-		.ant-table-cell.column-progress-bar {
-			min-width: 180px;
-			max-width: 180px;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-
-		.progress-container {
-			display: flex;
-			justify-content: start;
-		}
-	}
-}
-
-.ant-table-cell {
-	&:has(.job-name-header) {
-		min-width: 250px !important;
-		max-width: 250px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.namespace-name-header) {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.med-col) {
-		min-width: 200px !important;
-		max-width: 200px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.small-col) {
-		min-width: 120px !important;
-		max-width: 120px !important;
-	}
-}
-
-.expanded-jobs-list-table {
-	.ant-table-cell {
-		min-width: 200px !important;
-		max-width: 200px !important;
-	}
-
-	.ant-table-row-expand-icon-cell {
-		min-width: 30px !important;
-		max-width: 30px !important;
-	}
-}

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

@@ -1,683 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sJobsListPayload } from 'api/infraMonitoring/getK8sJobsList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sJobsList } from 'hooks/infraMonitoring/useGetK8sJobsList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sJobsList, K8sJobsData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getJobMetricsQueryPayload,
+	jobWidgetInfo,
+	k8sJobDetailsMetadataConfig,
+	k8sJobGetEntityName,
+	k8sJobGetSelectedItemFilters,
+	k8sJobInitialEventsFilter,
+	k8sJobInitialFilters,
+	k8sJobInitialLogTracesFilter,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringJobUID,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import JobDetails from './JobDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sJobsListColumns,
-	getK8sJobsListQuery,
-	K8sJobsRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sJobsList.styles.scss';
+	k8sJobsColumns,
+	k8sJobsColumnsConfig,
+	k8sJobsRenderRowData,
+} from './table';
 
 function K8sJobsList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [selectedJobUID, setselectedJobUID] = useInfraMonitoringJobUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.JOBS);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [selectedRowData, setSelectedRowData] = useState<K8sJobsRowData | null>(
-		null,
-	);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sJobsRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sJobsListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedJobUID) {
-			return [
-				'jobList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'jobList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [queryFilters, orderBy, selectedJobUID, minTime, maxTime, selectedRowData]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sJobsList(
-		fetchGroupedByRowDataQuery as K8sJobsListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.JOBS,
+			const response = await getK8sJobsList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.JOBS,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sJobsListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByJobsData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const nestedJobsData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const queryKey = useMemo(() => {
-		if (selectedJobUID) {
-			return [
-				'jobList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'jobList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedJobUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sJobsList(
-		query as K8sJobsListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const jobsData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedJobsData = useMemo(
-		() => formatDataForTable(jobsData, groupBy),
-		[jobsData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sJobsListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sJobsRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sJobsRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<K8sJobsRowData> | SorterResult<K8sJobsRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Job,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Job,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Job,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedJobData = useMemo(() => {
-		if (groupBy.length > 0) {
-			// If grouped by, return the job from the formatted grouped by data
-			return nestedJobsData.find((job) => job.jobName === selectedJobUID) || null;
-		}
-		// If not grouped by, return the job from the jobs data
-		return jobsData.find((job) => job.jobName === selectedJobUID) || null;
-	}, [selectedJobUID, groupBy.length, jobsData, nestedJobsData]);
-
-	const openJobInNewTab = (record: K8sJobsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID, record.jobUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sJobsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openJobInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedJobUID(record.jobUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Job,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sJobsListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sJobsRowData>[]}
-						dataSource={formattedGroupedByJobsData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openJobInNewTab(record);
-									return;
-								}
-								setselectedJobUID(record.jobUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sJobsRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sJobsRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseJobDetail = (): void => {
-		setselectedJobUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Job,
-			});
-		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
-	);
-
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Job,
-		});
-	};
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
+
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sJobsData | null; error?: string | null }> => {
+			const response = await getK8sJobsList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
+			);
+
+			const records = response.payload?.data.records || [];
+
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sJobsData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.JOBS}
-				showAutoRefresh={!selectedJobData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', 'jobs-list-table', {
-					'expanded-jobs-list-table': isGroupedByAttribute,
-				})}
-				dataSource={isFetching || isLoading ? [] : formattedJobsData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: isFetching || isLoading,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText:
-						isFetching || isLoading ? null : (
-							<div className="no-filtered-hosts-message-container">
-								<div className="no-filtered-hosts-message-content">
-									<img
-										src="/Icons/emptyState.svg"
-										alt="thinking-emoji"
-										className="empty-state-svg"
-									/>
-
-									<Typography.Text className="no-filtered-hosts-message">
-										This query had no results. Edit your query and try again!
-									</Typography.Text>
-								</div>
-							</div>
-						),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sJobsColumns}
+				tableColumns={k8sJobsColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sJobsRenderRowData}
+				eventCategory={InfraMonitoringEvents.Job}
 			/>
 
-			<JobDetails
-				job={selectedJobData}
-				isModalTimeSelection
-				onClose={handleCloseJobDetail}
+			<K8sBaseDetails<K8sJobsData>
+				category={K8sCategory.JOBS}
+				eventCategory={InfraMonitoringEvents.Job}
+				getSelectedItemFilters={k8sJobGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sJobGetEntityName}
+				getInitialLogTracesFilters={k8sJobInitialLogTracesFilter}
+				getInitialEventsFilters={k8sJobInitialEventsFilter}
+				primaryFilterKeys={k8sJobInitialFilters}
+				metadataConfig={k8sJobDetailsMetadataConfig}
+				entityWidgetInfo={jobWidgetInfo}
+				getEntityQueryPayload={getJobMetricsQueryPayload}
+				queryKeyPrefix="job"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Jobs/api.ts

@@ -1,22 +1,10 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 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[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sJobsData {
 	jobName: string;
@@ -68,7 +56,7 @@ export function mapJobsMeta(raw: Record<string, unknown>): K8sJobsData['meta'] {
 }
 
 export const getK8sJobsList = async (
-	props: K8sJobsListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
@@ -80,7 +68,7 @@ export const getK8sJobsList = async (
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;
@@ -113,7 +101,6 @@ export const getK8sJobsList = async (
 		});
 		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>),

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

@@ -1,11 +1,72 @@
-import { K8sJobsData } from 'api/infraMonitoring/getK8sJobsList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sJobsData } from './api';
+
+export const k8sJobGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_job_name',
+			key: {
+				key: 'k8s_job_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sJobDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sJobsData>[] = [
+	{
+		label: 'Job Name',
+		getValue: (p): string => p.meta.k8s_job_name,
+	},
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+	{
+		label: 'Namespace Name',
+		getValue: (p): string => p.meta.k8s_namespace_name,
+	},
+];
+
+export const k8sJobInitialFilters = [
+	QUERY_KEYS.K8S_JOB_NAME,
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+];
+
+export const k8sJobInitialEventsFilter = (
+	item: K8sJobsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Job'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_job_name),
+];
+
+export const k8sJobInitialLogTracesFilter = (
+	item: K8sJobsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_JOB_NAME, item.meta.k8s_job_name),
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, item.meta.k8s_namespace_name),
+];
+
+export const k8sJobGetEntityName = (item: K8sJobsData): string =>
+	item.meta.k8s_job_name;
+
 export const jobWidgetInfo = [
 	{
 		title: 'CPU usage',

frontend/src/container/InfraMonitoringK8s/Jobs/table.module.scss

@@ -0,0 +1,11 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}
+
+.progressBar {
+	display: flex;
+	justify-content: start;
+}

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

@@ -0,0 +1,330 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import {
+	EntityProgressBar,
+	formatBytes,
+	ValidateColumnValueWrapper,
+} from '../commonUtils';
+import { K8sCategory } from '../constants';
+import { K8sJobsData } from './api';
+
+import styles from './table.module.scss';
+
+export const k8sJobsColumns: IEntityColumn[] = [
+	{
+		label: 'Job Group',
+		value: 'jobGroup',
+		id: 'jobGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Job Name',
+		value: 'jobName',
+		id: 'jobName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Namespace Name',
+		value: 'namespaceName',
+		id: 'namespaceName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Successful',
+		value: 'successful_pods',
+		id: 'successful_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Failed',
+		value: 'failed_pods',
+		id: 'failed_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Desired Successful',
+		value: 'desired_successful_pods',
+		id: 'desired_successful_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Active',
+		value: 'active_pods',
+		id: 'active_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Req Usage (%)',
+		value: 'cpu_request',
+		id: 'cpu_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Limit Usage (%)',
+		value: 'cpu_limit',
+		id: 'cpu_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Req Usage (%)',
+		value: 'memory_request',
+		id: 'memory_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Limit Usage (%)',
+		value: 'memory_limit',
+		id: 'memory_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const k8sJobsColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> JOB GROUP
+			</div>
+		),
+		dataIndex: 'jobGroup',
+		key: 'jobGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Job Name</div>,
+		dataIndex: 'jobName',
+		key: 'jobName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Namespace Name</div>,
+		dataIndex: 'namespaceName',
+		key: 'namespaceName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Successful</div>,
+		dataIndex: 'successful_pods',
+		key: 'successful_pods',
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Failed</div>,
+		dataIndex: 'failed_pods',
+		key: 'failed_pods',
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Desired Successful</div>,
+		dataIndex: 'desired_successful_pods',
+		key: 'desired_successful_pods',
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Active</div>,
+		dataIndex: 'active_pods',
+		key: 'active_pods',
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Req Usage (%)</div>,
+		dataIndex: 'cpu_request',
+		key: 'cpu_request',
+		width: 180,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Limit Usage (%)</div>,
+		dataIndex: 'cpu_limit',
+		key: 'cpu_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Req Usage (%)</div>,
+		dataIndex: 'memory_request',
+		key: 'memory_request',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Limit Usage (%)</div>,
+		dataIndex: 'memory_limit',
+		key: 'memory_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 120,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sJobsRenderRowData = (
+	job: K8sJobsData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(job, () => job.jobName || job.meta.k8s_job_name || '', groupBy),
+	itemKey: job.meta.k8s_job_name,
+	jobName: (
+		<Tooltip title={job.meta.k8s_job_name}>{job.meta.k8s_job_name || ''}</Tooltip>
+	),
+	namespaceName: (
+		<Tooltip title={job.meta.k8s_namespace_name}>
+			{job.meta.k8s_namespace_name || ''}
+		</Tooltip>
+	),
+	cpu_request: (
+		<ValidateColumnValueWrapper
+			value={job.cpuRequest}
+			entity={K8sCategory.JOBS}
+			attribute="CPU Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={job.cpuRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu_limit: (
+		<ValidateColumnValueWrapper
+			value={job.cpuLimit}
+			entity={K8sCategory.JOBS}
+			attribute="CPU Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={job.cpuLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={job.cpuUsage}>
+			{job.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory_request: (
+		<ValidateColumnValueWrapper
+			value={job.memoryRequest}
+			entity={K8sCategory.JOBS}
+			attribute="Memory Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={job.memoryRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory_limit: (
+		<ValidateColumnValueWrapper
+			value={job.memoryLimit}
+			entity={K8sCategory.JOBS}
+			attribute="Memory Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={job.memoryLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={job.memoryUsage}>
+			{formatBytes(job.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	successful_pods: (
+		<ValidateColumnValueWrapper value={job.successfulPods}>
+			{job.successfulPods}
+		</ValidateColumnValueWrapper>
+	),
+	desired_successful_pods: (
+		<ValidateColumnValueWrapper value={job.desiredSuccessfulPods}>
+			{job.desiredSuccessfulPods}
+		</ValidateColumnValueWrapper>
+	),
+	failed_pods: (
+		<ValidateColumnValueWrapper value={job.failedPods}>
+			{job.failedPods}
+		</ValidateColumnValueWrapper>
+	),
+	active_pods: (
+		<ValidateColumnValueWrapper value={job.activePods}>
+			{job.activePods}
+		</ValidateColumnValueWrapper>
+	),
+	jobGroup: getGroupByEl(job, groupBy),
+	...job.meta,
+	groupedByMeta: getGroupedByMeta(job, groupBy),
+});

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

@@ -1,393 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sJobsData,
-	K8sJobsListPayload,
-} from 'api/infraMonitoring/getK8sJobsList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	EntityProgressBar,
-	formatBytes,
-	ValidateColumnValueWrapper,
-} from '../commonUtils';
-import { K8sCategory } from '../constants';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Job Name',
-		value: 'jobName',
-		id: 'jobName',
-		canRemove: false,
-	},
-	{
-		label: 'Namespace Name',
-		value: 'namespaceName',
-		id: 'namespaceName',
-		canRemove: false,
-	},
-	{
-		label: 'Successful',
-		value: 'successful_pods',
-		id: 'successful_pods',
-		canRemove: false,
-	},
-	{
-		label: 'Failed',
-		value: 'failed_pods',
-		id: 'failed_pods',
-		canRemove: false,
-	},
-	{
-		label: 'Desired Successful',
-		value: 'desired_successful_pods',
-		id: 'desired_successful_pods',
-		canRemove: false,
-	},
-	{
-		label: 'Active',
-		value: 'active_pods',
-		id: 'active_pods',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Req Usage (%)',
-		value: 'cpu_request',
-		id: 'cpu_request',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Limit Usage (%)',
-		value: 'cpu_limit',
-		id: 'cpu_limit',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Req Usage (%)',
-		value: 'memory_request',
-		id: 'memory_request',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Limit Usage (%)',
-		value: 'memory_limit',
-		id: 'memory_limit',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-];
-
-export interface K8sJobsRowData {
-	key: string;
-	jobUID: string;
-	jobName: React.ReactNode;
-	namespaceName: React.ReactNode;
-	successful_pods: React.ReactNode;
-	failed_pods: React.ReactNode;
-	active_pods: React.ReactNode;
-	desired_successful_pods: React.ReactNode;
-	cpu_request: React.ReactNode;
-	cpu_limit: React.ReactNode;
-	cpu: React.ReactNode;
-	memory_request: React.ReactNode;
-	memory_limit: React.ReactNode;
-	memory: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const jobGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> JOB GROUP
-		</div>
-	),
-	dataIndex: 'jobGroup',
-	key: 'jobGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sJobsListQuery = (): K8sJobsListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnProgressBarClassName = 'column-progress-bar';
-
-const columnsConfig = [
-	{
-		title: <div className="column-header-left job-name-header">Job Name</div>,
-		dataIndex: 'jobName',
-		key: 'jobName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: (
-			<div className="column-header-left namespace-name-header">
-				Namespace Name
-			</div>
-		),
-		dataIndex: 'namespaceName',
-		key: 'namespaceName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header small-col">Successful</div>,
-		dataIndex: 'successful_pods',
-		key: 'successful_pods',
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">Failed</div>,
-		dataIndex: 'failed_pods',
-		key: 'failed_pods',
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">Desired Successful</div>,
-		dataIndex: 'desired_successful_pods',
-		key: 'desired_successful_pods',
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">Active</div>,
-		dataIndex: 'active_pods',
-		key: 'active_pods',
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Req Usage (%)</div>,
-		dataIndex: 'cpu_request',
-		key: 'cpu_request',
-		width: 180,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Limit Usage (%)</div>,
-		dataIndex: 'cpu_limit',
-		key: 'cpu_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Req Usage (%)</div>,
-		dataIndex: 'memory_request',
-		key: 'memory_request',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Limit Usage (%)</div>,
-		dataIndex: 'memory_limit',
-		key: 'memory_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">Mem Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 120,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-];
-
-export const getK8sJobsListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sJobsRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'jobName',
-		);
-		filteredColumns.unshift(jobGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sJobsRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		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 (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sJobsData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sJobsRowData[] =>
-	data.map((job, index) => ({
-		key: index.toString(),
-		jobUID: job.jobName,
-		jobName: (
-			<Tooltip title={job.meta.k8s_job_name}>
-				{job.meta.k8s_job_name || ''}
-			</Tooltip>
-		),
-		namespaceName: (
-			<Tooltip title={job.meta.k8s_namespace_name}>
-				{job.meta.k8s_namespace_name || ''}
-			</Tooltip>
-		),
-		cpu_request: (
-			<ValidateColumnValueWrapper
-				value={job.cpuRequest}
-				entity={K8sCategory.JOBS}
-				attribute="CPU Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={job.cpuRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu_limit: (
-			<ValidateColumnValueWrapper
-				value={job.cpuLimit}
-				entity={K8sCategory.JOBS}
-				attribute="CPU Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={job.cpuLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu: (
-			<ValidateColumnValueWrapper value={job.cpuUsage}>
-				{job.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory_request: (
-			<ValidateColumnValueWrapper
-				value={job.memoryRequest}
-				entity={K8sCategory.JOBS}
-				attribute="Memory Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={job.memoryRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory_limit: (
-			<ValidateColumnValueWrapper
-				value={job.memoryLimit}
-				entity={K8sCategory.JOBS}
-				attribute="Memory Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={job.memoryLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={job.memoryUsage}>
-				{formatBytes(job.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		successful_pods: (
-			<ValidateColumnValueWrapper value={job.successfulPods}>
-				{job.successfulPods}
-			</ValidateColumnValueWrapper>
-		),
-		desired_successful_pods: (
-			<ValidateColumnValueWrapper value={job.desiredSuccessfulPods}>
-				{job.desiredSuccessfulPods}
-			</ValidateColumnValueWrapper>
-		),
-		failed_pods: (
-			<ValidateColumnValueWrapper value={job.failedPods}>
-				{job.failedPods}
-			</ValidateColumnValueWrapper>
-		),
-		active_pods: (
-			<ValidateColumnValueWrapper value={job.activePods}>
-				{job.activePods}
-			</ValidateColumnValueWrapper>
-		),
-		jobGroup: getGroupByEle(job, groupBy),
-		meta: job.meta,
-		...job.meta,
-		groupedByMeta: job.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx

@@ -1,175 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-import { useCallback, useMemo, useState } from 'react';
-import { Button, Select } from 'antd';
-import { initialQueriesMap } from 'constants/queryBuilder';
-import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import { Filter, SlidersHorizontal } from 'lucide-react';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-
-import { K8sCategory } from './constants';
-import { useInfraMonitoringFiltersK8s } from './hooks';
-import K8sFiltersSidePanel from './K8sFiltersSidePanel/K8sFiltersSidePanel';
-import { IEntityColumn } from './utils';
-
-import './InfraMonitoringK8s.styles.scss';
-
-interface K8sHeaderProps {
-	selectedGroupBy: BaseAutocompleteData[];
-	groupByOptions: { value: string; label: string }[];
-	isLoadingGroupByFilters: boolean;
-	handleFiltersChange: (value: IBuilderQuery['filters']) => void;
-	handleGroupByChange: (value: IBuilderQuery['groupBy']) => void;
-	defaultAddedColumns: IEntityColumn[];
-	addedColumns?: IEntityColumn[];
-	availableColumns?: IEntityColumn[];
-	onAddColumn?: (column: IEntityColumn) => void;
-	onRemoveColumn?: (column: IEntityColumn) => void;
-	handleFilterVisibilityChange: () => void;
-	isFiltersVisible: boolean;
-	entity: K8sCategory;
-	showAutoRefresh: boolean;
-}
-
-function K8sHeader({
-	selectedGroupBy,
-	defaultAddedColumns,
-	groupByOptions,
-	isLoadingGroupByFilters,
-	addedColumns,
-	availableColumns,
-	handleFiltersChange,
-	handleGroupByChange,
-	onAddColumn,
-	onRemoveColumn,
-	handleFilterVisibilityChange,
-	isFiltersVisible,
-	entity,
-	showAutoRefresh,
-}: K8sHeaderProps): JSX.Element {
-	const [isFiltersSidePanelOpen, setIsFiltersSidePanelOpen] = useState(false);
-	const [urlFilters, setUrlFilters] = useInfraMonitoringFiltersK8s();
-
-	const currentQuery = initialQueriesMap[DataSource.METRICS];
-
-	const updatedCurrentQuery = useMemo(() => {
-		let { filters } = currentQuery.builder.queryData[0];
-		if (urlFilters) {
-			filters = urlFilters;
-		}
-		return {
-			...currentQuery,
-			builder: {
-				...currentQuery.builder,
-				queryData: [
-					{
-						...currentQuery.builder.queryData[0],
-						aggregateOperator: 'noop',
-						aggregateAttribute: {
-							...currentQuery.builder.queryData[0].aggregateAttribute,
-						},
-						filters,
-					},
-				],
-			},
-		};
-	}, [currentQuery, urlFilters]);
-
-	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
-
-	const handleChangeTagFilters = useCallback(
-		(value: IBuilderQuery['filters']) => {
-			handleFiltersChange(value);
-			setUrlFilters(value || null);
-		},
-		[handleFiltersChange, setUrlFilters],
-	);
-
-	return (
-		<div className="k8s-list-controls">
-			<div className="k8s-list-controls-left">
-				{!isFiltersVisible && (
-					<div className="quick-filters-toggle-container">
-						<Button
-							className="periscope-btn ghost"
-							type="text"
-							size="small"
-							onClick={handleFilterVisibilityChange}
-						>
-							<Filter size={14} />
-						</Button>
-					</div>
-				)}
-
-				<div className="k8s-qb-search-container">
-					<QueryBuilderSearch
-						query={query as IBuilderQuery}
-						onChange={handleChangeTagFilters}
-						isInfraMonitoring
-						disableNavigationShortcuts
-						entity={entity}
-					/>
-				</div>
-
-				<div className="k8s-attribute-search-container">
-					<div className="group-by-label"> Group by </div>
-					<Select
-						className="group-by-select"
-						loading={isLoadingGroupByFilters}
-						mode="multiple"
-						value={selectedGroupBy}
-						allowClear
-						maxTagCount="responsive"
-						placeholder="Search for attribute"
-						style={{ width: '100%' }}
-						options={groupByOptions}
-						onChange={handleGroupByChange}
-					/>
-				</div>
-			</div>
-
-			<div className="k8s-list-controls-right">
-				<DateTimeSelectionV2
-					showAutoRefresh={showAutoRefresh}
-					showRefreshText={false}
-					hideShareModal
-				/>
-
-				<Button
-					type="text"
-					className="periscope-btn ghost"
-					disabled={selectedGroupBy?.length > 0}
-					onClick={(): void => setIsFiltersSidePanelOpen(true)}
-				>
-					<SlidersHorizontal size={14} />
-				</Button>
-			</div>
-
-			{isFiltersSidePanelOpen && (
-				<K8sFiltersSidePanel
-					defaultAddedColumns={defaultAddedColumns}
-					addedColumns={addedColumns}
-					availableColumns={availableColumns}
-					onClose={(): void => {
-						if (isFiltersSidePanelOpen) {
-							setIsFiltersSidePanelOpen(false);
-						}
-					}}
-					onAddColumn={onAddColumn}
-					onRemoveColumn={onRemoveColumn}
-				/>
-			)}
-		</div>
-	);
-}
-
-K8sHeader.defaultProps = {
-	addedColumns: [],
-	availableColumns: [],
-	onAddColumn: () => {},
-	onRemoveColumn: () => {},
-};
-
-export default K8sHeader;

frontend/src/container/InfraMonitoringK8s/Namespaces/K8sNamespacesList.styles.scss

@@ -1,17 +0,0 @@
-.infra-monitoring-container {
-	.namespaces-list-table {
-		.expanded-table-container {
-			padding-left: 80px;
-		}
-
-		.ant-table-cell {
-			min-width: 223px !important;
-			max-width: 223px !important;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}

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

@@ -1,716 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sNamespacesListPayload } from 'api/infraMonitoring/getK8sNamespacesList';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sNamespacesList } from 'hooks/infraMonitoring/useGetK8sNamespacesList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sNamespacesList, K8sNamespacesData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getNamespaceMetricsQueryPayload,
+	k8sNamespaceDetailsMetadataConfig,
+	k8sNamespaceGetEntityName,
+	k8sNamespaceGetSelectedItemFilters,
+	k8sNamespaceInitialEventsFilter,
+	k8sNamespaceInitialFilters,
+	k8sNamespaceInitialLogTracesFilter,
+	namespaceWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringNamespaceUID,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import NamespaceDetails from './NamespaceDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sNamespacesListColumns,
-	getK8sNamespacesListQuery,
-	K8sNamespacesRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sNamespacesList.styles.scss';
+	k8sNamespacesColumns,
+	k8sNamespacesColumnsConfig,
+	k8sNamespacesRenderRowData,
+} from './table';
 
 function K8sNamespacesList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [
-		selectedNamespaceUID,
-		setselectedNamespaceUID,
-	] = useInfraMonitoringNamespaceUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.NAMESPACES);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sNamespacesRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sNamespacesRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sNamespacesListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedNamespaceUID) {
-			return [
-				'namespaceList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'namespaceList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedNamespaceUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sNamespacesList(
-		fetchGroupedByRowDataQuery as K8sNamespacesListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.NAMESPACES,
+			const response = await getK8sNamespacesList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sNamespacesListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByNamespacesData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const queryKey = useMemo(() => {
-		if (selectedNamespaceUID) {
-			return [
-				'namespaceList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'namespaceList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedNamespaceUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sNamespacesList(
-		query as K8sNamespacesListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const namespacesData = useMemo(() => data?.payload?.data?.records || [], [
-		data,
-	]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedNamespacesData = useMemo(
-		() => formatDataForTable(namespacesData, groupBy),
-		[namespacesData, groupBy],
-	);
-
-	const nestedNamespacesData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const columns = useMemo(() => getK8sNamespacesListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sNamespacesRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sNamespacesRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sNamespacesRowData>
-				| SorterResult<K8sNamespacesRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Namespace,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Namespace,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Namespace,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedNamespaceData = useMemo(() => {
-		if (!selectedNamespaceUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the namespace from the formatted grouped by namespaces data
-			return (
-				nestedNamespacesData.find(
-					(namespace) => namespace.namespaceName === selectedNamespaceUID,
-				) || null
 			);
-		}
-		// If not grouped by, return the node from the nodes data
-		return (
-			namespacesData.find(
-				(namespace) => namespace.namespaceName === selectedNamespaceUID,
-			) || null
-		);
-	}, [
-		selectedNamespaceUID,
-		groupBy.length,
-		namespacesData,
-		nestedNamespacesData,
-	]);
 
-	const openNamespaceInNewTab = (record: K8sNamespacesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
-			record.namespaceUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sNamespacesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openNamespaceInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedNamespaceUID(record.namespaceUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Namespace,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sNamespacesListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sNamespacesRowData>[]}
-						dataSource={formattedGroupedByNamespacesData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openNamespaceInNewTab(record);
-									return;
-								}
-								setselectedNamespaceUID(record.namespaceUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sNamespacesRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sNamespacesRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseNamespaceDetail = (): void => {
-		setselectedNamespaceUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Namespace,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sNamespacesData | null; error?: string | null }> => {
+			const response = await getK8sNamespacesList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Namespace,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedNamespacesData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
-				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedNamespaceData}
+		<>
+			<K8sBaseList<K8sNamespacesData>
+				controlListPrefix={controlListPrefix}
+				entity={K8sCategory.NAMESPACES}
+				tableColumnsDefinitions={k8sNamespacesColumns}
+				tableColumns={k8sNamespacesColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sNamespacesRenderRowData}
+				eventCategory={InfraMonitoringEvents.Namespace}
 			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
 
-			<Table
-				className="k8s-list-table namespaces-list-table"
-				dataSource={showTableLoadingState ? [] : formattedNamespacesData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+			<K8sBaseDetails<K8sNamespacesData>
+				category={K8sCategory.NAMESPACES}
+				eventCategory={InfraMonitoringEvents.Namespace}
+				getSelectedItemFilters={k8sNamespaceGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sNamespaceGetEntityName}
+				getInitialLogTracesFilters={k8sNamespaceInitialLogTracesFilter}
+				getInitialEventsFilters={k8sNamespaceInitialEventsFilter}
+				primaryFilterKeys={k8sNamespaceInitialFilters}
+				metadataConfig={k8sNamespaceDetailsMetadataConfig}
+				entityWidgetInfo={namespaceWidgetInfo}
+				getEntityQueryPayload={getNamespaceMetricsQueryPayload}
+				queryKeyPrefix="namespace"
 			/>
-			<NamespaceDetails
-				namespace={selectedNamespaceData}
-				isModalTimeSelection
-				onClose={handleCloseNamespaceDetail}
-			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sNamespacesData } from 'api/infraMonitoring/getK8sNamespacesList';
-
-export type NamespaceDetailsProps = {
-	namespace: K8sNamespacesData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.styles.scss

@@ -1,249 +0,0 @@
-.namespace-detail-drawer {
-	border-left: 1px solid var(--bg-slate-500);
-	background: var(--bg-ink-400);
-	box-shadow: -4px 10px 16px 2px rgba(0, 0, 0, 0.2);
-
-	.ant-drawer-header {
-		padding: 8px 16px;
-		border-bottom: none;
-
-		align-items: stretch;
-
-		border-bottom: 1px solid var(--bg-slate-500);
-		background: var(--bg-ink-400);
-	}
-
-	.ant-drawer-close {
-		margin-inline-end: 0px;
-	}
-
-	.ant-drawer-body {
-		display: flex;
-		flex-direction: column;
-		padding: 16px;
-	}
-
-	.title {
-		color: var(--text-vanilla-400);
-		font-family: 'Geist Mono';
-		font-size: 14px;
-		font-style: normal;
-		font-weight: 500;
-		line-height: 20px; /* 142.857% */
-		letter-spacing: -0.07px;
-	}
-
-	.radio-button {
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		padding-top: var(--padding-1);
-		border: 1px solid var(--bg-slate-400);
-		background: var(--bg-ink-300);
-		box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-	}
-
-	.namespace-detail-drawer__namespace {
-		.namespace-details-grid {
-			.labels-row,
-			.values-row {
-				display: grid;
-				grid-template-columns: 1fr 1.5fr 1.5fr 1.5fr;
-				gap: 30px;
-				align-items: center;
-			}
-
-			.labels-row {
-				margin-bottom: 8px;
-			}
-
-			.namespace-details-metadata-label {
-				color: var(--text-vanilla-400);
-				font-family: Inter;
-				font-size: 11px;
-				font-style: normal;
-				font-weight: 500;
-				line-height: 18px; /* 163.636% */
-				letter-spacing: 0.44px;
-				text-transform: uppercase;
-			}
-
-			.namespace-details-metadata-value {
-				color: var(--text-vanilla-400);
-				font-family: 'Geist Mono';
-				font-size: 12px;
-				font-style: normal;
-				font-weight: 500;
-				line-height: 20px; /* 142.857% */
-				letter-spacing: -0.07px;
-
-				width: 100%;
-				white-space: nowrap;
-				overflow: hidden;
-				text-overflow: ellipsis;
-			}
-
-			.status-tag {
-				margin: 0;
-
-				&.active {
-					color: var(--success-500);
-					background: var(--success-100);
-					border-color: var(--success-500);
-				}
-
-				&.inactive {
-					color: var(--error-500);
-					background: var(--error-100);
-					border-color: var(--error-500);
-				}
-			}
-
-			.progress-container {
-				width: 158px;
-
-				.ant-progress {
-					margin: 0;
-
-					.ant-progress-text {
-						font-weight: 600;
-					}
-				}
-			}
-
-			.ant-card {
-				&.ant-card-bordered {
-					border: 1px solid var(--bg-slate-500) !important;
-				}
-			}
-		}
-	}
-
-	.tabs-and-search {
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		margin: 16px 0;
-
-		.action-btn {
-			border-radius: 2px;
-			border: 1px solid var(--bg-slate-400);
-			background: var(--bg-ink-300);
-			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-			display: flex;
-			align-items: center;
-			justify-content: center;
-		}
-	}
-
-	.views-tabs-container {
-		margin-top: 1.5rem;
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-
-		.views-tabs {
-			color: var(--text-vanilla-400);
-
-			.view-title {
-				display: flex;
-				gap: var(--margin-2);
-				align-items: center;
-				justify-content: center;
-				font-size: var(--font-size-xs);
-				font-style: normal;
-				font-weight: var(--font-weight-normal);
-			}
-
-			.tab {
-				border: 1px solid var(--bg-slate-400);
-				width: 114px;
-			}
-
-			.tab::before {
-				background: var(--bg-slate-400);
-			}
-
-			.selected_view {
-				background: var(--bg-slate-300);
-				color: var(--text-vanilla-100);
-				border: 1px solid var(--bg-slate-400);
-			}
-
-			.selected_view::before {
-				background: var(--bg-slate-400);
-			}
-		}
-
-		.compass-button {
-			width: 30px;
-			height: 30px;
-
-			border-radius: 2px;
-			border: 1px solid var(--bg-slate-400);
-			background: var(--bg-ink-300);
-			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-		}
-	}
-
-	.ant-drawer-close {
-		padding: 0px;
-	}
-}
-
-.lightMode {
-	.ant-drawer-header {
-		border-bottom: 1px solid var(--bg-vanilla-400);
-		background: var(--bg-vanilla-100);
-	}
-
-	.namespace-detail-drawer {
-		.title {
-			color: var(--text-ink-300);
-		}
-
-		.namespace-detail-drawer__namespace {
-			.ant-typography {
-				color: var(--text-ink-300);
-				background: transparent;
-			}
-		}
-
-		.radio-button {
-			border: 1px solid var(--bg-vanilla-400);
-			background: var(--bg-vanilla-100);
-			color: var(--text-ink-300);
-		}
-
-		.views-tabs {
-			.tab {
-				background: var(--bg-vanilla-100);
-			}
-
-			.selected_view {
-				background: var(--bg-vanilla-300);
-				border: 1px solid var(--bg-slate-300);
-				color: var(--text-ink-400);
-			}
-
-			.selected_view::before {
-				background: var(--bg-vanilla-300);
-				border-left: 1px solid var(--bg-slate-300);
-			}
-		}
-
-		.compass-button {
-			border: 1px solid var(--bg-vanilla-300);
-			background: var(--bg-vanilla-100);
-			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-		}
-
-		.tabs-and-search {
-			.action-btn {
-				border: 1px solid var(--bg-vanilla-400);
-				background: var(--bg-vanilla-100);
-				color: var(--text-ink-300);
-			}
-		}
-	}
-}

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

@@ -1,640 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sNamespacesData } from 'api/infraMonitoring/getK8sNamespacesList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import NamespaceEvents from '../../EntityDetailsUtils/EntityEvents';
-import NamespaceLogs from '../../EntityDetailsUtils/EntityLogs';
-import NamespaceMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import NamespaceTraces from '../../EntityDetailsUtils/EntityTraces';
-import {
-	getNamespaceMetricsQueryPayload,
-	namespaceWidgetInfo,
-} from './constants';
-import { NamespaceDetailsProps } from './NamespaceDetails.interfaces';
-
-import './NamespaceDetails.styles.scss';
-
-function NamespaceDetails({
-	namespace,
-	onClose,
-	isModalTimeSelection,
-}: NamespaceDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_namespace_name--string--resource--false',
-					},
-					op: '=',
-					value: namespace?.namespaceName || '',
-				},
-			],
-		};
-	}, [
-		namespace?.namespaceName,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Namespace',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: namespace?.namespaceName || '',
-				},
-			],
-		};
-	}, [namespace?.namespaceName, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (namespace) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Namespace,
-			});
-		}
-	}, [namespace]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Namespace,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Namespace,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NAMESPACE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_NAMESPACE_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Namespace,
-						view: InfraMonitoringEvents.LogsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NAMESPACE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Namespace,
-						view: InfraMonitoringEvents.TracesView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_NAMESPACE_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const namespaceKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const namespaceNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Namespace,
-						view: InfraMonitoringEvents.EventsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						namespaceKindFilter,
-						namespaceNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Namespace,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items:
-					logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{namespace?.namespaceName}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!namespace}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{namespace && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={namespace.namespaceName}>
-										{namespace.namespaceName}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title="Cluster name">
-										{namespace.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<NamespaceMetrics<K8sNamespacesData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={namespace}
-							entityWidgetInfo={namespaceWidgetInfo}
-							getEntityQueryPayload={getNamespaceMetricsQueryPayload}
-							category={K8sCategory.NAMESPACES}
-							queryKey="namespaceMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<NamespaceLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="namespaceLogs"
-							category={K8sCategory.NAMESPACES}
-							queryKeyFilters={[QUERY_KEYS.K8S_NAMESPACE_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<NamespaceTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="namespaceTraces"
-							category={InfraMonitoringEvents.Namespace}
-							queryKeyFilters={[QUERY_KEYS.K8S_NAMESPACE_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<NamespaceEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.NAMESPACES}
-							queryKey="namespaceEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default NamespaceDetails;

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/Namespaces/api.ts

@@ -1,11 +1,12 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
-import { UnderscoreToDotMap } from '../utils';
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sNamespacesListPayload {
 	filters: TagFilter;
@@ -59,7 +60,7 @@ export function mapNamespacesMeta(
 }
 
 export const getK8sNamespacesList = async (
-	props: K8sNamespacesListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
@@ -71,7 +72,7 @@ export const getK8sNamespacesList = async (
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;

frontend/src/container/InfraMonitoringK8s/Namespaces/constants.ts

@@ -1,11 +1,67 @@
-import { K8sNamespacesData } from 'api/infraMonitoring/getK8sNamespacesList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import {
+	TagFilter,
+	TagFilterItem,
+} from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sNamespacesData } from './api';
+
+export const k8sNamespaceGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_namespace_name',
+			key: {
+				key: 'k8s_namespace_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sNamespaceDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sNamespacesData>[] = [
+	{ label: 'Namespace Name', getValue: (p): string => p.namespaceName },
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+];
+
+export const k8sNamespaceInitialFilters = [
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+	QUERY_KEYS.K8S_CLUSTER_NAME,
+];
+
+export const k8sNamespaceInitialEventsFilter = (
+	item: K8sNamespacesData,
+): TagFilterItem[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Namespace'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.namespaceName),
+];
+
+export const k8sNamespaceInitialLogTracesFilter = (
+	item: K8sNamespacesData,
+): TagFilterItem[] => [
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, item.namespaceName),
+];
+
+export const k8sNamespaceGetEntityName = (item: K8sNamespacesData): string =>
+	item.namespaceName;
+
 export const namespaceWidgetInfo = [
 	{
 		title: 'CPU Usage (cores)',

frontend/src/container/InfraMonitoringK8s/Namespaces/table.module.scss

@@ -0,0 +1,6 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}

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

@@ -0,0 +1,155 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { K8sNamespacesData, K8sNamespacesListPayload } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sNamespacesRowData {
+	key: string;
+	itemKey: string;
+	namespaceUID: string;
+	namespaceName: React.ReactNode;
+	clusterName: string;
+	cpu: React.ReactNode;
+	memory: React.ReactNode;
+	groupedByMeta?: Record<string, string>;
+}
+
+export const k8sNamespacesColumns: IEntityColumn[] = [
+	{
+		label: 'Namespace Group',
+		value: 'namespaceGroup',
+		id: 'namespaceGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Namespace Name',
+		value: 'namespaceName',
+		id: 'namespaceName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterName',
+		id: 'clusterName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const getK8sNamespacesListQuery = (): K8sNamespacesListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+export const k8sNamespacesColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> NAMESPACE GROUP
+			</div>
+		),
+		dataIndex: 'namespaceGroup',
+		key: 'namespaceGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Namespace Name</div>,
+		dataIndex: 'namespaceName',
+		key: 'namespaceName',
+		ellipsis: true,
+		width: 120,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 120,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 100,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sNamespacesRenderRowData = (
+	namespace: K8sNamespacesData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		namespace,
+		() => namespace.namespaceName || namespace.meta.k8s_namespace_name,
+		groupBy,
+	),
+	itemKey: namespace.meta.k8s_namespace_name,
+	namespaceUID: namespace.namespaceName,
+	namespaceName: (
+		<Tooltip title={namespace.namespaceName}>
+			{namespace.namespaceName || ''}
+		</Tooltip>
+	),
+	clusterName: namespace.meta.k8s_cluster_name,
+	cpu: (
+		<ValidateColumnValueWrapper value={namespace.cpuUsage}>
+			{namespace.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={namespace.memoryUsage}>
+			{formatBytes(namespace.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	namespaceGroup: getGroupByEl(namespace, groupBy),
+	...namespace.meta,
+	groupedByMeta: getGroupedByMeta(namespace, groupBy),
+});

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

@@ -1,179 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag } from 'antd';
-import {
-	K8sNamespacesData,
-	K8sNamespacesListPayload,
-} from 'api/infraMonitoring/getK8sNamespacesList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Namespace Name',
-		value: 'namespaceName',
-		id: 'namespaceName',
-		canRemove: false,
-	},
-	{
-		label: 'Cluster Name',
-		value: 'clusterName',
-		id: 'clusterName',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Utilization (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Utilization (bytes)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-];
-
-export interface K8sNamespacesRowData {
-	key: string;
-	namespaceUID: string;
-	namespaceName: string;
-	clusterName: string;
-	cpu: React.ReactNode;
-	memory: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const namespaceGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> NAMESPACE GROUP
-		</div>
-	),
-	dataIndex: 'namespaceGroup',
-	key: 'namespaceGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sNamespacesListQuery = (): K8sNamespacesListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnsConfig = [
-	{
-		title: <div className="column-header-left">Namespace Name</div>,
-		dataIndex: 'namespaceName',
-		key: 'namespaceName',
-		ellipsis: true,
-		width: 120,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Cluster Name</div>,
-		dataIndex: 'clusterName',
-		key: 'clusterName',
-		ellipsis: true,
-		width: 120,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 100,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Mem Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 120,
-		sorter: true,
-		align: 'left',
-	},
-];
-
-export const getK8sNamespacesListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sNamespacesRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'namespaceName',
-		);
-		filteredColumns.unshift(namespaceGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sNamespacesRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		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 (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sNamespacesData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sNamespacesRowData[] =>
-	data.map((namespace, index) => ({
-		key: index.toString(),
-		namespaceUID: namespace.namespaceName,
-		namespaceName: namespace.namespaceName,
-		clusterName: namespace.meta.k8s_cluster_name,
-		cpu: (
-			<ValidateColumnValueWrapper value={namespace.cpuUsage}>
-				{namespace.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={namespace.memoryUsage}>
-				{formatBytes(namespace.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		namespaceGroup: getGroupByEle(namespace, groupBy),
-		meta: namespace.meta,
-		...namespace.meta,
-		groupedByMeta: namespace.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.styles.scss

@@ -1,17 +0,0 @@
-.infra-monitoring-container {
-	.nodes-list-table {
-		.expanded-table-container {
-			padding-left: 40px;
-		}
-
-		.ant-table-cell {
-			min-width: 223px !important;
-			max-width: 223px !important;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}

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

@@ -1,695 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sNodesListPayload } from 'api/infraMonitoring/getK8sNodesList';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sNodesList } from 'hooks/infraMonitoring/useGetK8sNodesList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sNodesList, K8sNodeData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getNodeMetricsQueryPayload,
+	k8sNodeDetailsMetadataConfig,
+	k8sNodeGetEntityName,
+	k8sNodeGetSelectedItemFilters,
+	k8sNodeInitialEventsFilter,
+	k8sNodeInitialFilters,
+	k8sNodeInitialLogTracesFilter,
+	nodeWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringNodeUID,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import NodeDetails from './NodeDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sNodesListColumns,
-	getK8sNodesListQuery,
-	K8sNodesRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sNodesList.styles.scss';
+	k8sNodesColumns,
+	k8sNodesColumnsConfig,
+	k8sNodesRenderRowData,
+} from './table';
 
 function K8sNodesList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [selectedNodeUID, setSelectedNodeUID] = useInfraMonitoringNodeUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.NODES);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	// These params are used only for clearing in handleCloseNodeDetail
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [selectedRowData, setSelectedRowData] = useState<K8sNodesRowData | null>(
-		null,
-	);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sNodesRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sNodesListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedNodeUID) {
-			return [
-				'nodeList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'nodeList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedNodeUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sNodesList(
-		fetchGroupedByRowDataQuery as K8sNodesListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.NODES,
+			const response = await getK8sNodesList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sNodesListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const nestedNodesData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const formattedGroupedByNodesData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const queryKey = useMemo(() => {
-		if (selectedNodeUID) {
-			return [
-				'nodeList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'nodeList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedNodeUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sNodesList(
-		query as K8sNodesListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const nodesData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedNodesData = useMemo(
-		() => formatDataForTable(nodesData, groupBy),
-		[nodesData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sNodesListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sNodesRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sNodesRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<K8sNodesRowData> | SorterResult<K8sNodesRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Node,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Node,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedNodeData = useMemo(() => {
-		if (!selectedNodeUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the node from the formatted grouped by nodes data
-			return (
-				nestedNodesData.find((node) => node.nodeUID === selectedNodeUID) || null
 			);
-		}
-		// If not grouped by, return the node from the nodes data
-		return nodesData.find((node) => node.nodeUID === selectedNodeUID) || null;
-	}, [selectedNodeUID, groupBy.length, nodesData, nestedNodesData]);
 
-	const openNodeInNewTab = (record: K8sNodesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID, record.nodeUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sNodesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openNodeInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setSelectedNodeUID(record.nodeUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sNodesListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						className="expanded-table-view"
-						columns={nestedColumns as ColumnType<K8sNodesRowData>[]}
-						dataSource={formattedGroupedByNodesData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openNodeInNewTab(record);
-									return;
-								}
-								setSelectedNodeUID(record.nodeUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sNodesRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sNodesRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseNodeDetail = (): void => {
-		setSelectedNodeUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(k) => k.key === element,
-				);
-
-				if (key) {
-					newGroupBy.push(key);
-				}
-			}
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(newGroupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Node,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sNodeData | null; error?: string | null }> => {
+			const response = await getK8sNodesList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedNodesData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sNodeData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedNodeData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className="k8s-list-table nodes-list-table"
-				dataSource={showTableLoadingState ? [] : formattedNodesData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sNodesColumns}
+				tableColumns={k8sNodesColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sNodesRenderRowData}
+				eventCategory={InfraMonitoringEvents.Node}
 			/>
 
-			<NodeDetails
-				node={selectedNodeData}
-				isModalTimeSelection
-				onClose={handleCloseNodeDetail}
+			<K8sBaseDetails<K8sNodeData>
+				category={K8sCategory.NODES}
+				eventCategory={InfraMonitoringEvents.Node}
+				getSelectedItemFilters={k8sNodeGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sNodeGetEntityName}
+				getInitialLogTracesFilters={k8sNodeInitialLogTracesFilter}
+				getInitialEventsFilters={k8sNodeInitialEventsFilter}
+				primaryFilterKeys={k8sNodeInitialFilters}
+				metadataConfig={k8sNodeDetailsMetadataConfig}
+				entityWidgetInfo={nodeWidgetInfo}
+				getEntityQueryPayload={getNodeMetricsQueryPayload}
+				queryKeyPrefix="node"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
-
-export type NodeDetailsProps = {
-	node: K8sNodesData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,635 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import NodeEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import NodeLogs from '../../EntityDetailsUtils/EntityLogs';
-import NodeMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import NodeTraces from '../../EntityDetailsUtils/EntityTraces';
-import { QUERY_KEYS } from '../../EntityDetailsUtils/utils';
-import { getNodeMetricsQueryPayload, nodeWidgetInfo } from './constants';
-import { NodeDetailsProps } from './NodeDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function NodeDetails({
-	node,
-	onClose,
-	isModalTimeSelection,
-}: NodeDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NODE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_node_name--string--resource--false',
-					},
-					op: '=',
-					value: node?.meta.k8s_node_name || '',
-				},
-			],
-		};
-	}, [
-		node?.meta.k8s_node_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Node',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: node?.meta.k8s_node_name || '',
-				},
-			],
-		};
-	}, [node?.meta.k8s_node_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (node) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Node,
-			});
-		}
-	}, [node]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Node,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Node,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_NODE_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.LogsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.TracesView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_NODE_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const nodeKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const nodeNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.EventsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						nodeKindFilter,
-						nodeNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Node,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items:
-					logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{node?.meta.k8s_node_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!node}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{node && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Node Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={node.meta.k8s_node_name}>
-										{node.meta.k8s_node_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title="Cluster name">{node.meta.k8s_cluster_name}</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<NodeMetrics<K8sNodesData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={node}
-							entityWidgetInfo={nodeWidgetInfo}
-							getEntityQueryPayload={getNodeMetricsQueryPayload}
-							category={K8sCategory.NODES}
-							queryKey="nodeMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<NodeLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKeyFilters={[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME]}
-							queryKey="nodeLogs"
-							category={K8sCategory.NODES}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<NodeTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKeyFilters={[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME]}
-							queryKey="nodeTraces"
-							category={InfraMonitoringEvents.Node}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<NodeEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.NODES}
-							queryKey="nodeEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default NodeDetails;

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/Nodes/api.ts

@@ -0,0 +1,128 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+import { K8sBaseFilters } from '../Base/K8sBaseList';
+
+export interface K8sNodesListPayload {
+	filters: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	orderBy?: {
+		columnName: string;
+		order: 'asc' | 'desc';
+	};
+}
+
+export interface K8sNodeData {
+	nodeUID: string;
+	nodeCPUUsage: number;
+	nodeCPUAllocatable: number;
+	nodeMemoryUsage: number;
+	nodeMemoryAllocatable: number;
+	meta: {
+		k8s_node_name: string;
+		k8s_node_uid: string;
+		k8s_cluster_name: string;
+	};
+}
+
+export interface K8sNodesListResponse {
+	status: string;
+	data: {
+		type: string;
+		records: K8sNodeData[];
+		groups: null;
+		total: number;
+		sentAnyHostMetricsData: boolean;
+		isSendingK8SAgentMetrics: boolean;
+	};
+}
+
+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>,
+): K8sNodeData['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 K8sNodeData['meta'];
+}
+
+export const getK8sNodesList = async (
+	props: K8sBaseFilters,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
+): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
+	try {
+		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,
+			params: requestProps,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/container/InfraMonitoringK8s/Nodes/constants.ts

@@ -1,11 +1,67 @@
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sNodeData } from './api';
+
+export const k8sNodeGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => {
+	return {
+		op: 'AND',
+		items: [
+			{
+				id: 'k8s_node_name',
+				key: {
+					key: 'k8s_node_name',
+					type: null,
+				},
+				op: '=',
+				value: selectedItemId,
+			},
+		],
+	};
+};
+
+export const k8sNodeDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sNodeData>[] = [
+	{ label: 'Node Name', getValue: (p): string => p.meta.k8s_node_name },
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+];
+
+export const k8sNodeInitialFilters = [
+	QUERY_KEYS.K8S_NODE_NAME,
+	QUERY_KEYS.K8S_CLUSTER_NAME,
+];
+
+export const k8sNodeInitialEventsFilter = (
+	item: K8sNodeData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Node'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_node_name),
+];
+
+export const k8sNodeInitialLogTracesFilter = (
+	item: K8sNodeData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_NODE_NAME, item.meta.k8s_node_name),
+	createFilterItem(QUERY_KEYS.K8S_CLUSTER_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sNodeGetEntityName = (item: K8sNodeData): string =>
+	item.meta.k8s_node_name;
+
 export const nodeWidgetInfo = [
 	{
 		title: 'CPU Usage (cores)',
@@ -50,7 +106,7 @@ export const nodeWidgetInfo = [
 ];
 
 export const getNodeMetricsQueryPayload = (
-	node: K8sNodesData,
+	node: K8sNodeData,
 	start: number,
 	end: number,
 	dotMetricsEnabled: boolean,

frontend/src/container/InfraMonitoringK8s/Nodes/table.module.scss

@@ -0,0 +1,6 @@
+.entityGroupHeader {
+	display: flex;
+	align-items: center;
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+}

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

@@ -0,0 +1,199 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { K8sNodeData, K8sNodesListPayload } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sNodesRowData {
+	key: string;
+	itemKey: string;
+	nodeUID: string;
+	nodeName: React.ReactNode;
+	clusterName: string;
+	cpu: React.ReactNode;
+	cpu_allocatable: React.ReactNode;
+	memory: React.ReactNode;
+	memory_allocatable: React.ReactNode;
+	groupedByMeta?: any;
+}
+
+export const k8sNodesColumns: IEntityColumn[] = [
+	{
+		label: 'Node Group',
+		value: 'nodeGroup',
+		id: 'nodeGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Node Name',
+		value: 'nodeName',
+		id: 'nodeName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterName',
+		id: 'clusterName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Alloc (cores)',
+		value: 'cpu_allocatable',
+		id: 'cpu_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Alloc (bytes)',
+		value: 'memory_allocatable',
+		id: 'memory_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const getK8sNodesListQuery = (): K8sNodesListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+export const k8sNodesColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> NODE GROUP
+			</div>
+		),
+		dataIndex: 'nodeGroup',
+		key: 'nodeGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Node Name</div>,
+		dataIndex: 'nodeName',
+		key: 'nodeName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Alloc (cores)</div>,
+		dataIndex: 'cpu_allocatable',
+		key: 'cpu_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Allocatable</div>,
+		dataIndex: 'memory_allocatable',
+		key: 'memory_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sNodesRenderRowData = (
+	node: K8sNodeData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		node,
+		() => node.nodeUID || node.meta.k8s_node_uid || node.meta.k8s_node_name,
+		groupBy,
+	),
+	itemKey: node.meta.k8s_node_name,
+	nodeUID: node.nodeUID || node.meta.k8s_node_uid,
+	nodeName: (
+		<Tooltip title={node.meta.k8s_node_name}>
+			{node.meta.k8s_node_name || ''}
+		</Tooltip>
+	),
+	clusterName: node.meta.k8s_cluster_name,
+	cpu: (
+		<ValidateColumnValueWrapper value={node.nodeCPUUsage}>
+			{node.nodeCPUUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={node.nodeMemoryUsage}>
+			{formatBytes(node.nodeMemoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	cpu_allocatable: (
+		<ValidateColumnValueWrapper value={node.nodeCPUAllocatable}>
+			{node.nodeCPUAllocatable}
+		</ValidateColumnValueWrapper>
+	),
+	memory_allocatable: (
+		<ValidateColumnValueWrapper value={node.nodeMemoryAllocatable}>
+			{formatBytes(node.nodeMemoryAllocatable)}
+		</ValidateColumnValueWrapper>
+	),
+	nodeGroup: getGroupByEl(node, groupBy),
+	...node.meta,
+	groupedByMeta: getGroupedByMeta(node, groupBy),
+});

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

@@ -1,225 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sNodesData,
-	K8sNodesListPayload,
-} from 'api/infraMonitoring/getK8sNodesList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Node Name',
-		value: 'nodeName',
-		id: 'nodeName',
-		canRemove: false,
-	},
-	{
-		label: 'Cluster Name',
-		value: 'clusterStatus',
-		id: 'clusterStatus',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Alloc (cores)',
-		value: 'cpu_allocatable',
-		id: 'cpu_allocatable',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Alloc (bytes)',
-		value: 'memory_allocatable',
-		id: 'memory_allocatable',
-		canRemove: false,
-	},
-];
-
-export interface K8sNodesRowData {
-	key: string;
-	nodeUID: string;
-	nodeName: React.ReactNode;
-	clusterName: string;
-	cpu: React.ReactNode;
-	cpu_allocatable: React.ReactNode;
-	memory: React.ReactNode;
-	memory_allocatable: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const nodeGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> NODE GROUP
-		</div>
-	),
-	dataIndex: 'nodeGroup',
-	key: 'nodeGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sNodesListQuery = (): K8sNodesListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnsConfig = [
-	{
-		title: <div className="column-header-left name-header">Node Name</div>,
-		dataIndex: 'nodeName',
-		key: 'nodeName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left name-header">Cluster Name</div>,
-		dataIndex: 'clusterName',
-		key: 'clusterName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Alloc (cores)</div>,
-		dataIndex: 'cpu_allocatable',
-		key: 'cpu_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Allocatable</div>,
-		dataIndex: 'memory_allocatable',
-		key: 'memory_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-];
-
-export const getK8sNodesListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sNodesRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'nodeName',
-		);
-		filteredColumns.unshift(nodeGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sNodesRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		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 (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sNodesData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sNodesRowData[] =>
-	data.map((node, index) => ({
-		key: `${node.nodeUID}-${index}`,
-		nodeUID: node.nodeUID || '',
-		nodeName: (
-			<Tooltip title={node.meta.k8s_node_name}>
-				{node.meta.k8s_node_name || ''}
-			</Tooltip>
-		),
-		clusterName: node.meta.k8s_cluster_name,
-		cpu: (
-			<ValidateColumnValueWrapper value={node.nodeCPUUsage}>
-				{node.nodeCPUUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={node.nodeMemoryUsage}>
-				{formatBytes(node.nodeMemoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		cpu_allocatable: (
-			<ValidateColumnValueWrapper value={node.nodeCPUAllocatable}>
-				{node.nodeCPUAllocatable}
-			</ValidateColumnValueWrapper>
-		),
-		memory_allocatable: (
-			<ValidateColumnValueWrapper value={node.nodeMemoryAllocatable}>
-				{formatBytes(node.nodeMemoryAllocatable)}
-			</ValidateColumnValueWrapper>
-		),
-		nodeGroup: getGroupByEle(node, groupBy),
-		meta: node.meta,
-		...node.meta,
-		groupedByMeta: node.meta,
-	}));

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

@@ -1,753 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import get from 'api/browser/localstorage/get';
-import set from 'api/browser/localstorage/set';
-import logEvent from 'api/common/logEvent';
-import { K8sPodsListPayload } from 'api/infraMonitoring/getK8sPodsList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sPodsList } from 'hooks/infraMonitoring/useGetK8sPodsList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight, CornerDownRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sPodsList, K8sPodsData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getPodMetricsQueryPayload,
+	k8sPodDetailsMetadataConfig,
+	k8sPodGetEntityName,
+	k8sPodGetSelectedItemFilters,
+	k8sPodInitialEventsFilter,
+	k8sPodInitialFilters,
+	k8sPodInitialLogTracesFilter,
+	podWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringPodUID,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import {
-	defaultAddedColumns,
-	defaultAvailableColumns,
-	formatDataForTable,
-	getK8sPodsListColumns,
-	getK8sPodsListQuery,
-	IEntityColumn,
-	K8sPodsRowData,
-	usePageSize,
-} from '../utils';
-import PodDetails from './PodDetails/PodDetails';
-
-import '../InfraMonitoringK8s.styles.scss';
+	k8sPodColumns,
+	k8sPodColumnsConfig,
+	k8sPodRenderRowData,
+} from './table';
 
 function K8sPodsList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-	const [defaultOrderBy] = useState(orderBy);
-	const [selectedPodUID, setSelectedPodUID] = useInfraMonitoringPodUID();
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [addedColumns, setAddedColumns] = useState<IEntityColumn[]>([]);
-
-	const [availableColumns, setAvailableColumns] = useState<IEntityColumn[]>(
-		defaultAvailableColumns,
-	);
-
-	const [selectedRowData, setSelectedRowData] = useState<K8sPodsRowData | null>(
-		null,
-	);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[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: GetK8sEntityToAggregateAttribute(
-				K8sCategory.PODS,
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
+
+			const response = await getK8sPodsList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true, // isInfraMonitoring
-		K8sCategory.PODS, // infraMonitoringEntity
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
-	useEffect(() => {
-		const addedColumns = JSON.parse(get('k8sPodsAddedColumns') ?? '[]');
-
-		if (addedColumns && addedColumns.length > 0) {
-			const availableColumns = defaultAvailableColumns.filter(
-				(column) => !addedColumns.includes(column.id),
 			);
 
-			const newAddedColumns = defaultAvailableColumns.filter((column) =>
-				addedColumns.includes(column.id),
-			);
-
-			setAvailableColumns(availableColumns);
-			setAddedColumns(newAddedColumns);
-		}
-	}, []);
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.PODS);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sPodsListQuery();
-
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const queryKey = useMemo(() => {
-		if (selectedPodUID) {
-			return [
-				'podList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'podList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedPodUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sPodsList(
-		query as K8sPodsListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		undefined,
-		dotMetricsEnabled,
+		[dotMetricsEnabled],
 	);
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sPodsRowData,
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
-
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of Object.keys(groupedByMeta)) {
-			baseFilters.items.push({
-				key: {
-					key,
-					type: null,
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sPodsData | null; error?: string | null }> => {
+			const response = await getK8sPodsList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
 				},
-				op: '=',
-				value: groupedByMeta[key],
-				id: key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sPodsListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedPodUID) {
-			return [
-				'podList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'podList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [queryFilters, orderBy, selectedPodUID, minTime, maxTime, selectedRowData]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sPodsList(
-		fetchGroupedByRowDataQuery as K8sPodsListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const podsData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const nestedPodsData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const formattedPodsData = useMemo(
-		() => formatDataForTable(podsData, groupBy),
-		[podsData, groupBy],
-	);
-
-	const formattedGroupedByPodsData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const columns = useMemo(
-		() => getK8sPodsListColumns(addedColumns, groupBy, defaultOrderBy),
-		[addedColumns, groupBy, defaultOrderBy],
-	);
-
-	const handleTableChange: TableProps<K8sPodsRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<K8sPodsRowData> | SorterResult<K8sPodsRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Pod,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Pod,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(k) => k.key === element,
-				);
-
-				if (key) {
-					newGroupBy.push(key);
-				}
-			}
-
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(newGroupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Pod,
-			});
-		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Pod,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedPodData = useMemo(() => {
-		if (!selectedPodUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the pod from the formatted grouped by pods data
-			return nestedPodsData.find((pod) => pod.podUID === selectedPodUID) || null;
-		}
-		// If not grouped by, return the node from the nodes data
-		return podsData.find((pod) => pod.podUID === selectedPodUID) || null;
-	}, [selectedPodUID, groupBy.length, podsData, nestedPodsData]);
-
-	const handleGroupByRowClick = (record: K8sPodsRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const openPodInNewTab = (record: K8sPodsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID, record.podUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sPodsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openPodInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedPodUID(record.podUID);
-			setSelectedRowData(null);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Pod,
-		});
-	};
-
-	const handleClosePodDetail = (): void => {
-		setSelectedPodUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleAddColumn = useCallback(
-		(column: IEntityColumn): void => {
-			setAddedColumns((prev) => [...prev, column]);
-
-			setAvailableColumns((prev) => prev.filter((c) => c.value !== column.value));
-		},
-		[setAddedColumns, setAvailableColumns],
-	);
-
-	// Update local storage when added columns updated
-	useEffect(() => {
-		const addedColumnIDs = addedColumns.map((column) => column.id);
-
-		set('k8sPodsAddedColumns', JSON.stringify(addedColumnIDs));
-	}, [addedColumns]);
-
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const handleRemoveColumn = useCallback(
-		(column: IEntityColumn): void => {
-			setAddedColumns((prev) => prev.filter((c) => c.value !== column.value));
+			const records = response.payload?.data.records || [];
 
-			setAvailableColumns((prev) => [...prev, column]);
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
 		},
-		[setAddedColumns, setAvailableColumns],
+		[dotMetricsEnabled],
 	);
 
-	const nestedColumns = useMemo(
-		() => getK8sPodsListColumns(addedColumns, [], defaultOrderBy),
-		[addedColumns, defaultOrderBy],
-	);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sPodsRowData>[]}
-						dataSource={formattedGroupedByPodsData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						showHeader={false}
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						onRow={(
-							record: K8sPodsRowData,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openPodInNewTab(record);
-									return;
-								}
-								setSelectedPodUID(record.podUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-						groupedByRowData?.payload?.data?.total > 10 && (
-							<div className="expanded-table-footer">
-								<Button
-									type="default"
-									size="small"
-									className="periscope-btn secondary"
-									onClick={handleExpandedRowViewAllClick}
-								>
-									<CornerDownRight size={14} />
-									View All
-								</Button>
-							</div>
-						)}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sPodsRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sPodsRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Pod,
-		});
-	};
-
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedPodsData.length === 0;
-
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				selectedGroupBy={groupBy}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				addedColumns={addedColumns}
-				availableColumns={availableColumns}
-				handleFiltersChange={handleFiltersChange}
-				handleGroupByChange={handleGroupByChange}
-				onAddColumn={handleAddColumn}
-				onRemoveColumn={handleRemoveColumn}
+		<>
+			<K8sBaseList<K8sPodsData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.PODS}
-				showAutoRefresh={!selectedPodData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', {
-					'expanded-k8s-list-table': isGroupedByAttribute,
-				})}
-				dataSource={showTableLoadingState ? [] : formattedPodsData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				scroll={{ x: true }}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record: K8sPodsRowData,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sPodColumns}
+				tableColumns={k8sPodColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sPodRenderRowData}
+				eventCategory={InfraMonitoringEvents.Pod}
 			/>
 
-			{selectedPodData && (
-				<PodDetails
-					pod={selectedPodData}
-					isModalTimeSelection
-					onClose={handleClosePodDetail}
-				/>
-			)}
-		</div>
+			<K8sBaseDetails<K8sPodsData>
+				category={K8sCategory.PODS}
+				eventCategory={InfraMonitoringEvents.Pod}
+				getSelectedItemFilters={k8sPodGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sPodGetEntityName}
+				getInitialLogTracesFilters={k8sPodInitialLogTracesFilter}
+				getInitialEventsFilters={k8sPodInitialEventsFilter}
+				primaryFilterKeys={k8sPodInitialFilters}
+				metadataConfig={k8sPodDetailsMetadataConfig}
+				entityWidgetInfo={podWidgetInfo}
+				getEntityQueryPayload={getPodMetricsQueryPayload}
+				queryKeyPrefix="pod"
+			/>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetail.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sPodsData } from 'api/infraMonitoring/getK8sPodsList';
-
-export type PodDetailProps = {
-	pod: K8sPodsData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/index.tsx

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

frontend/src/container/InfraMonitoringK8s/Pods/api.ts

@@ -1,21 +1,35 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
-import { UnderscoreToDotMap } from '../utils';
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
-export interface K8sPodsListPayload {
-	filters: TagFilter;
-	groupBy?: BaseAutocompleteData[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
+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'];
 }
 
 export interface TimeSeriesValue {
@@ -71,35 +85,9 @@ 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
+// TODO: Remove this method once we move this to OpenAPI
 export const getK8sPodsList = async (
-	props: K8sPodsListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
@@ -111,7 +99,7 @@ export const getK8sPodsList = async (
 						...props,
 						filters: {
 							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
+							items: props.filters?.items.reduce<typeof props.filters.items>(
 								(acc, item) => {
 									if (item.value === undefined) {
 										return acc;

frontend/src/container/InfraMonitoringK8s/Pods/constants.ts

@@ -1,11 +1,69 @@
-import { K8sPodsData } from 'api/infraMonitoring/getK8sPodsList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sPodsData } from './api';
+
+export const k8sPodGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => {
+	return {
+		op: 'AND',
+		items: [
+			{
+				id: 'k8s_pod_uid',
+				key: {
+					key: 'k8s_pod_uid',
+					type: null,
+				},
+				op: '=',
+				value: selectedItemId,
+			},
+		],
+	};
+};
+
+export const k8sPodDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sPodsData>[] = [
+	{ label: 'NAMESPACE', getValue: (p): string => p.meta.k8s_namespace_name },
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+	{ label: 'Node', getValue: (p): string => p.meta.k8s_node_name },
+];
+
+export const k8sPodInitialFilters = [
+	QUERY_KEYS.K8S_POD_NAME,
+	QUERY_KEYS.K8S_CLUSTER_NAME,
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+];
+
+export const k8sPodInitialEventsFilter = (
+	pod: K8sPodsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Pod'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, pod.meta.k8s_pod_name),
+];
+
+export const k8sPodInitialLogTracesFilter = (
+	pod: K8sPodsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_POD_NAME, pod.meta.k8s_pod_name),
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, pod.meta.k8s_namespace_name),
+];
+
+export const k8sPodGetEntityName = (pod: K8sPodsData): string =>
+	pod.meta.k8s_pod_name;
+
 export const podWidgetInfo = [
 	{
 		title: 'CPU Usage (cores)',

frontend/src/container/InfraMonitoringK8s/Pods/table.module.scss

@@ -0,0 +1,11 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}
+
+.progressBar {
+	display: flex;
+	justify-content: start;
+}

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

@@ -0,0 +1,328 @@
+import React from 'react';
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import {
+	EntityProgressBar,
+	formatBytes,
+	ValidateColumnValueWrapper,
+} from '../commonUtils';
+import { K8sCategory } from '../constants';
+import { K8sPodsData } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sPodsRowData {
+	key: string;
+	podName: React.ReactNode;
+	podUID: string;
+	cpu_request: React.ReactNode;
+	cpu_limit: React.ReactNode;
+	cpu: React.ReactNode;
+	memory_request: React.ReactNode;
+	memory_limit: React.ReactNode;
+	memory: React.ReactNode;
+	restarts: React.ReactNode;
+	groupedByMeta?: any;
+}
+
+export const k8sPodColumns: IEntityColumn[] = [
+	{
+		label: 'Pod Group',
+		value: 'podGroup',
+		id: 'podGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Pod name',
+		value: 'podName',
+		id: 'podName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'CPU Req Usage (%)',
+		value: 'cpu_request',
+		id: 'cpu_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Limit Usage (%)',
+		value: 'cpu_limit',
+		id: 'cpu_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Req Usage (%)',
+		value: 'memory_request',
+		id: 'memory_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Limit Usage (%)',
+		value: 'memory_limit',
+		id: 'memory_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Namespace name',
+		value: 'namespace',
+		id: 'namespace',
+		canBeHidden: true,
+		defaultVisibility: false,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Node name',
+		value: 'node',
+		id: 'node',
+		canBeHidden: true,
+		defaultVisibility: false,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Cluster name',
+		value: 'cluster',
+		id: 'cluster',
+		canBeHidden: true,
+		defaultVisibility: false,
+		behavior: 'always-visible',
+	},
+	// TODO - Re-enable the column once backend issue is fixed
+	// {
+	// 	label: 'Restarts',
+	// 	value: 'restarts',
+	// 	id: 'restarts',
+	// 	canRemove: false,
+	// },
+];
+
+export const k8sPodColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> POD GROUP
+			</div>
+		),
+		dataIndex: 'podGroup',
+		key: 'podGroup',
+		ellipsis: true,
+		width: 180,
+		sorter: false,
+	},
+	{
+		title: <div>Pod Name</div>,
+		dataIndex: 'podName',
+		key: 'podName',
+		width: 180,
+		ellipsis: true,
+		sorter: false,
+	},
+	{
+		title: <div>CPU Req Usage (%)</div>,
+		dataIndex: 'cpu_request',
+		key: 'cpu_request',
+		width: 180,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Limit Usage (%)</div>,
+		dataIndex: 'cpu_limit',
+		key: 'cpu_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Req Usage (%)</div>,
+		dataIndex: 'memory_request',
+		key: 'memory_request',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Limit Usage (%)</div>,
+		dataIndex: 'memory_limit',
+		key: 'memory_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 120,
+		ellipsis: true,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Namespace</div>,
+		dataIndex: 'namespace',
+		key: 'namespace',
+		width: 100,
+		sorter: false,
+		ellipsis: true,
+		align: 'left',
+	},
+	{
+		title: <div>Node</div>,
+		dataIndex: 'node',
+		key: 'node',
+		width: 100,
+		sorter: false,
+		ellipsis: true,
+		align: 'left',
+	},
+	{
+		title: <div>Cluster</div>,
+		dataIndex: 'cluster',
+		key: 'cluster',
+		width: 100,
+		sorter: false,
+		ellipsis: true,
+		align: 'left',
+	},
+	// TODO - Re-enable the column once backend issue is fixed
+	// {
+	// 	title: (
+	// 		<div className="column-header">
+	// 			<Tooltip title="Container Restarts">Restarts</Tooltip>
+	// 		</div>
+	// 	),
+	// 	dataIndex: 'restarts',
+	// 	key: 'restarts',
+	// 	width: 40,
+	// 	ellipsis: true,
+	// 	sorter: true,
+	// 	align: 'left',
+	// 	className: `column ${columnProgressBarClassName}`,
+	// },
+];
+
+export const k8sPodRenderRowData = (
+	pod: K8sPodsData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		pod,
+		() => pod.podUID || pod.meta.k8s_pod_uid || pod.meta.k8s_pod_name,
+		groupBy,
+	),
+	itemKey: pod.podUID,
+	podName: (
+		<Tooltip title={pod.meta.k8s_pod_name || ''}>
+			{pod.meta.k8s_pod_name || ''}
+		</Tooltip>
+	),
+	podUID: pod.podUID || '',
+	cpu_request: (
+		<ValidateColumnValueWrapper
+			value={pod.podCPURequest}
+			entity={K8sCategory.PODS}
+			attribute="CPU Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={pod.podCPURequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu_limit: (
+		<ValidateColumnValueWrapper
+			value={pod.podCPULimit}
+			entity={K8sCategory.PODS}
+			attribute="CPU Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={pod.podCPULimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={pod.podCPU}>
+			{pod.podCPU}
+		</ValidateColumnValueWrapper>
+	),
+	memory_request: (
+		<ValidateColumnValueWrapper
+			value={pod.podMemoryRequest}
+			entity={K8sCategory.PODS}
+			attribute="Memory Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={pod.podMemoryRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory_limit: (
+		<ValidateColumnValueWrapper
+			value={pod.podMemoryLimit}
+			entity={K8sCategory.PODS}
+			attribute="Memory Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={pod.podMemoryLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={pod.podMemory}>
+			{formatBytes(pod.podMemory)}
+		</ValidateColumnValueWrapper>
+	),
+	restarts: (
+		<ValidateColumnValueWrapper value={pod.restartCount}>
+			{pod.restartCount}
+		</ValidateColumnValueWrapper>
+	),
+	namespace: pod.meta.k8s_namespace_name,
+	node: pod.meta.k8s_node_name,
+	cluster: pod.meta.k8s_cluster_name,
+	meta: pod.meta,
+	podGroup: getGroupByEl(pod, groupBy),
+	...pod.meta,
+	groupedByMeta: getGroupedByMeta(pod, groupBy),
+});

frontend/src/container/InfraMonitoringK8s/StatefulSets/K8sStatefulSetsList.styles.scss

@@ -1,62 +0,0 @@
-.infra-monitoring-container {
-	.statefulSets-list-table {
-		.expanded-table-container {
-			padding-left: 20px;
-		}
-
-		.ant-table-cell.column-progress-bar {
-			min-width: 180px;
-			max-width: 180px;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-
-		.progress-container {
-			display: flex;
-			justify-content: start;
-		}
-	}
-}
-
-.ant-table-cell {
-	&:has(.statefulset-name-header) {
-		min-width: 250px !important;
-		max-width: 250px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.namespace-name-header) {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.med-col) {
-		min-width: 200px !important;
-		max-width: 200px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.small-col) {
-		min-width: 120px !important;
-		max-width: 120px !important;
-	}
-}
-
-.expanded-statefulsets-list-table {
-	.ant-table-cell {
-		min-width: 180px !important;
-		max-width: 180px !important;
-	}
-
-	.ant-table-row-expand-icon-cell {
-		min-width: 30px !important;
-		max-width: 30px !important;
-	}
-}

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

@@ -1,719 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sStatefulSetsListPayload } from 'api/infraMonitoring/getsK8sStatefulSetsList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sStatefulSetsList } from 'hooks/infraMonitoring/useGetK8sStatefulSetsList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sStatefulSetsList, K8sStatefulSetsData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getStatefulSetMetricsQueryPayload,
+	k8sStatefulSetDetailsMetadataConfig,
+	k8sStatefulSetGetEntityName,
+	k8sStatefulSetGetSelectedItemFilters,
+	k8sStatefulSetInitialEventsFilter,
+	k8sStatefulSetInitialFilters,
+	k8sStatefulSetInitialLogTracesFilter,
+	statefulSetWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringStatefulSetUID,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import StatefulSetDetails from './StatefulSetDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sStatefulSetsListColumns,
-	getK8sStatefulSetsListQuery,
-	K8sStatefulSetsRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sStatefulSetsList.styles.scss';
+	k8sStatefulSetsColumns,
+	k8sStatefulSetsColumnsConfig,
+	k8sStatefulSetsRenderRowData,
+} from './table';
 
 function K8sStatefulSetsList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [
-		selectedStatefulSetUID,
-		setselectedStatefulSetUID,
-	] = useInfraMonitoringStatefulSetUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.STATEFULSETS);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sStatefulSetsRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sStatefulSetsRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sStatefulSetsListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedStatefulSetUID) {
-			return [
-				'statefulSetList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'statefulSetList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedStatefulSetUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sStatefulSetsList(
-		fetchGroupedByRowDataQuery as K8sStatefulSetsListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.STATEFULSETS,
+			const response = await getK8sStatefulSetsList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.STATEFULSETS,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sStatefulSetsListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByStatefulSetsData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const nestedStatefulSetsData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const queryKey = useMemo(() => {
-		if (selectedStatefulSetUID) {
-			return [
-				'statefulSetList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'statefulSetList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedStatefulSetUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sStatefulSetsList(
-		query as K8sStatefulSetsListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const statefulSetsData = useMemo(() => data?.payload?.data?.records || [], [
-		data,
-	]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedStatefulSetsData = useMemo(
-		() => formatDataForTable(statefulSetsData, groupBy),
-		[statefulSetsData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sStatefulSetsListColumns(groupBy), [
-		groupBy,
-	]);
-
-	const handleGroupByRowClick = (record: K8sStatefulSetsRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sStatefulSetsRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sStatefulSetsRowData>
-				| SorterResult<K8sStatefulSetsRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.StatefulSet,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.StatefulSet,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.StatefulSet,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedStatefulSetData = useMemo(() => {
-		if (!selectedStatefulSetUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			return (
-				nestedStatefulSetsData.find(
-					(statefulSet) => statefulSet.statefulSetName === selectedStatefulSetUID,
-				) || null
 			);
-		}
-		return (
-			statefulSetsData.find(
-				(statefulSet) => statefulSet.statefulSetName === selectedStatefulSetUID,
-			) || null
-		);
-	}, [
-		selectedStatefulSetUID,
-		groupBy.length,
-		statefulSetsData,
-		nestedStatefulSetsData,
-	]);
 
-	const openStatefulSetInNewTab = (record: K8sStatefulSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
-			record.statefulsetUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sStatefulSetsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openStatefulSetInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedStatefulSetUID(record.statefulsetUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.StatefulSet,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sStatefulSetsListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sStatefulSetsRowData>[]}
-						dataSource={formattedGroupedByStatefulSetsData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openStatefulSetInNewTab(record);
-									return;
-								}
-								setselectedStatefulSetUID(record.statefulsetUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sStatefulSetsRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sStatefulSetsRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseStatefulSetDetail = (): void => {
-		setselectedStatefulSetUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.StatefulSet,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sStatefulSetsData | null; error?: string | null }> => {
+			const response = await getK8sStatefulSetsList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.StatefulSet,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedStatefulSetsData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sStatefulSetsData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.STATEFULSETS}
-				showAutoRefresh={!selectedStatefulSetData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', 'statefulSets-list-table', {
-					'expanded-statefulsets-list-table': isGroupedByAttribute,
-				})}
-				dataSource={showTableLoadingState ? [] : formattedStatefulSetsData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sStatefulSetsColumns}
+				tableColumns={k8sStatefulSetsColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sStatefulSetsRenderRowData}
+				eventCategory={InfraMonitoringEvents.StatefulSet}
 			/>
 
-			<StatefulSetDetails
-				statefulSet={selectedStatefulSetData}
-				isModalTimeSelection
-				onClose={handleCloseStatefulSetDetail}
+			<K8sBaseDetails<K8sStatefulSetsData>
+				category={K8sCategory.STATEFULSETS}
+				eventCategory={InfraMonitoringEvents.StatefulSet}
+				getSelectedItemFilters={k8sStatefulSetGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sStatefulSetGetEntityName}
+				getInitialLogTracesFilters={k8sStatefulSetInitialLogTracesFilter}
+				getInitialEventsFilters={k8sStatefulSetInitialEventsFilter}
+				primaryFilterKeys={k8sStatefulSetInitialFilters}
+				metadataConfig={k8sStatefulSetDetailsMetadataConfig}
+				entityWidgetInfo={statefulSetWidgetInfo}
+				getEntityQueryPayload={getStatefulSetMetricsQueryPayload}
+				queryKeyPrefix="statefulSet"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/StatefulSetDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sStatefulSetsData } from 'api/infraMonitoring/getsK8sStatefulSetsList';
-
-export type StatefulSetDetailsProps = {
-	statefulSet: K8sStatefulSetsData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

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

@@ -1,658 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import EntityEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
-import EntityLogs from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityLogs';
-import EntityMetrics from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityMetrics';
-import EntityTraces from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import {
-	getStatefulSetMetricsQueryPayload,
-	statefulSetWidgetInfo,
-} from './constants';
-import { StatefulSetDetailsProps } from './StatefulSetDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function StatefulSetDetails({
-	statefulSet,
-	onClose,
-	isModalTimeSelection,
-}: StatefulSetDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_statefulset_name--string--resource--false',
-					},
-					op: '=',
-					value: statefulSet?.meta.k8s_statefulset_name || '',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_namespace_name--string--resource--false',
-					},
-					op: '=',
-					value: statefulSet?.meta.k8s_namespace_name || '',
-				},
-			],
-		};
-	}, [
-		statefulSet?.meta.k8s_statefulset_name,
-		statefulSet?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'StatefulSet',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: statefulSet?.meta.k8s_statefulset_name || '',
-				},
-			],
-		};
-	}, [statefulSet?.meta.k8s_statefulset_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (statefulSet) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.StatefulSet,
-			});
-		}
-	}, [statefulSet]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.StatefulSet,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.StatefulSet,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_STATEFUL_SET_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' &&
-						item.key?.key !== QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.StatefulSet,
-						view: 'logs',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_STATEFUL_SET_NAME, QUERY_KEYS.K8S_NAMESPACE_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.StatefulSet,
-						view: 'traces',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const statefulSetKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const statefulSetNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.StatefulSet,
-						view: 'logs',
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						statefulSetKindFilter,
-						statefulSetNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.StatefulSet,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items:
-					logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{statefulSet?.meta.k8s_statefulset_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!statefulSet}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{statefulSet && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Statefulset Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={statefulSet.meta.k8s_statefulset_name}>
-										{statefulSet.meta.k8s_statefulset_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={statefulSet.meta.k8s_namespace_name}>
-										{statefulSet.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<EntityMetrics
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={statefulSet}
-							entityWidgetInfo={statefulSetWidgetInfo}
-							getEntityQueryPayload={getStatefulSetMetricsQueryPayload}
-							category={K8sCategory.STATEFULSETS}
-							queryKey="statefulsetMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<EntityLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="statefulsetLogs"
-							category={K8sCategory.STATEFULSETS}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<EntityTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="statefulsetTraces"
-							category={InfraMonitoringEvents.StatefulSet}
-							queryKeyFilters={[
-								QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-								QUERY_KEYS.K8S_NAMESPACE_NAME,
-							]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<EntityEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.STATEFULSETS}
-							queryKey="statefulsetEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default StatefulSetDetails;

frontend/src/container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/StatefulSets/api.ts

@@ -1,11 +1,12 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 
-import { UnderscoreToDotMap } from '../utils';
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sStatefulSetsListPayload {
 	filters: TagFilter;
@@ -66,39 +67,35 @@ export function mapStatefulSetsMeta(
 }
 
 export const getK8sStatefulSetsList = async (
-	props: K8sStatefulSetsListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sStatefulSetsListResponse> | ErrorResponse> => {
 	try {
-		// Prepare filters
 		const requestProps =
-			dotMetricsEnabled && Array.isArray(props.filters?.items)
+			dotMetricsEnabled && props.filters && 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);
-									}
+							items: props.filters.items.reduce<TagFilter['items']>((acc, item) => {
+								if (item.value === undefined) {
 									return acc;
-								},
-								[] as typeof props.filters.items,
-							),
+								}
+								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 TagFilter['items']),
 						},
 				  }
 				: props;
@@ -109,7 +106,6 @@ export const getK8sStatefulSetsList = async (
 		});
 		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>),

frontend/src/container/InfraMonitoringK8s/StatefulSets/constants.ts

@@ -1,11 +1,72 @@
-import { K8sStatefulSetsData } from 'api/infraMonitoring/getsK8sStatefulSetsList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sStatefulSetsData } from './api';
+
+export const k8sStatefulSetGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_statefulset_name',
+			key: {
+				key: 'k8s_statefulset_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sStatefulSetDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sStatefulSetsData>[] = [
+	{
+		label: 'Statefulset Name',
+		getValue: (p): string => p.meta.k8s_statefulset_name,
+	},
+	{
+		label: 'Namespace Name',
+		getValue: (p): string => p.meta.k8s_namespace_name,
+	},
+];
+
+export const k8sStatefulSetInitialFilters = [
+	QUERY_KEYS.K8S_STATEFUL_SET_NAME,
+	QUERY_KEYS.K8S_NAMESPACE_NAME,
+];
+
+export const k8sStatefulSetInitialEventsFilter = (
+	item: K8sStatefulSetsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'StatefulSet'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_statefulset_name),
+];
+
+export const k8sStatefulSetInitialLogTracesFilter = (
+	item: K8sStatefulSetsData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(
+		QUERY_KEYS.K8S_STATEFUL_SET_NAME,
+		item.meta.k8s_statefulset_name,
+	),
+	createFilterItem(QUERY_KEYS.K8S_NAMESPACE_NAME, item.meta.k8s_namespace_name),
+];
+
+export const k8sStatefulSetGetEntityName = (
+	item: K8sStatefulSetsData,
+): string => item.meta.k8s_statefulset_name;
+
 export const statefulSetWidgetInfo = [
 	{
 		title: 'CPU usage, request, limits',

frontend/src/container/InfraMonitoringK8s/StatefulSets/table.module.scss

@@ -0,0 +1,11 @@
+.entityGroupHeader {
+	display: flex;
+	align-items: center;
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+}
+
+.progressBar {
+	display: flex;
+	justify-content: start;
+}

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

@@ -0,0 +1,295 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import {
+	EntityProgressBar,
+	formatBytes,
+	ValidateColumnValueWrapper,
+} from '../commonUtils';
+import { K8sCategory } from '../constants';
+import { K8sStatefulSetsData } from './api';
+
+import styles from './table.module.scss';
+
+export const k8sStatefulSetsColumns: IEntityColumn[] = [
+	{
+		label: 'StatefulSet Group',
+		value: 'statefulSetGroup',
+		id: 'statefulSetGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'StatefulSet Name',
+		value: 'statefulsetName',
+		id: 'statefulsetName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Namespace Name',
+		value: 'namespaceName',
+		id: 'namespaceName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Available',
+		value: 'available_pods',
+		id: 'available_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Desired',
+		value: 'desired_pods',
+		id: 'desired_pods',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Req Usage (%)',
+		value: 'cpu_request',
+		id: 'cpu_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Limit Usage (%)',
+		value: 'cpu_limit',
+		id: 'cpu_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Req Usage (%)',
+		value: 'memory_request',
+		id: 'memory_request',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Limit Usage (%)',
+		value: 'memory_limit',
+		id: 'memory_limit',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Mem Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const k8sStatefulSetsColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> STATEFULSET GROUP
+			</div>
+		),
+		dataIndex: 'statefulSetGroup',
+		key: 'statefulSetGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>StatefulSet Name</div>,
+		dataIndex: 'statefulsetName',
+		key: 'statefulsetName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Namespace Name</div>,
+		dataIndex: 'namespaceName',
+		key: 'namespaceName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Available</div>,
+		dataIndex: 'available_pods',
+		key: 'available_pods',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Desired</div>,
+		dataIndex: 'desired_pods',
+		key: 'desired_pods',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Req Usage (%)</div>,
+		dataIndex: 'cpu_request',
+		key: 'cpu_request',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Limit Usage (%)</div>,
+		dataIndex: 'cpu_limit',
+		key: 'cpu_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Req Usage (%)</div>,
+		dataIndex: 'memory_request',
+		key: 'memory_request',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Limit Usage (%)</div>,
+		dataIndex: 'memory_limit',
+		key: 'memory_limit',
+		width: 120,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Mem Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sStatefulSetsRenderRowData = (
+	statefulSet: K8sStatefulSetsData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		statefulSet,
+		() =>
+			statefulSet.statefulSetName || statefulSet.meta.k8s_statefulset_name || '',
+		groupBy,
+	),
+	itemKey: statefulSet.meta.k8s_statefulset_name,
+	statefulsetName: (
+		<Tooltip title={statefulSet.meta.k8s_statefulset_name}>
+			{statefulSet.meta.k8s_statefulset_name || ''}
+		</Tooltip>
+	),
+	namespaceName: (
+		<Tooltip title={statefulSet.meta.k8s_namespace_name}>
+			{statefulSet.meta.k8s_namespace_name || ''}
+		</Tooltip>
+	),
+	cpu_request: (
+		<ValidateColumnValueWrapper
+			value={statefulSet.cpuRequest}
+			entity={K8sCategory.STATEFULSETS}
+			attribute="CPU Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={statefulSet.cpuRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu_limit: (
+		<ValidateColumnValueWrapper
+			value={statefulSet.cpuLimit}
+			entity={K8sCategory.STATEFULSETS}
+			attribute="CPU Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={statefulSet.cpuLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={statefulSet.cpuUsage}>
+			{statefulSet.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory_request: (
+		<ValidateColumnValueWrapper
+			value={statefulSet.memoryRequest}
+			entity={K8sCategory.STATEFULSETS}
+			attribute="Memory Request"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={statefulSet.memoryRequest} type="request" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory_limit: (
+		<ValidateColumnValueWrapper
+			value={statefulSet.memoryLimit}
+			entity={K8sCategory.STATEFULSETS}
+			attribute="Memory Limit"
+		>
+			<div className={styles.progressBar}>
+				<EntityProgressBar value={statefulSet.memoryLimit} type="limit" />
+			</div>
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={statefulSet.memoryUsage}>
+			{formatBytes(statefulSet.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	available_pods: (
+		<ValidateColumnValueWrapper value={statefulSet.availablePods}>
+			{statefulSet.availablePods}
+		</ValidateColumnValueWrapper>
+	),
+	desired_pods: (
+		<ValidateColumnValueWrapper value={statefulSet.desiredPods}>
+			{statefulSet.desiredPods}
+		</ValidateColumnValueWrapper>
+	),
+	statefulSetGroup: getGroupByEl(statefulSet, groupBy),
+	...statefulSet.meta,
+	groupedByMeta: getGroupedByMeta(statefulSet, groupBy),
+});

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

@@ -1,356 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sStatefulSetsData,
-	K8sStatefulSetsListPayload,
-} from 'api/infraMonitoring/getsK8sStatefulSetsList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	EntityProgressBar,
-	formatBytes,
-	ValidateColumnValueWrapper,
-} from '../commonUtils';
-import { K8sCategory } from '../constants';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'StatefulSet Name',
-		value: 'statefulsetName',
-		id: 'statefulsetName',
-		canRemove: false,
-	},
-	{
-		label: 'Namespace Name',
-		value: 'namespaceName',
-		id: 'namespaceName',
-		canRemove: false,
-	},
-	{
-		label: 'Available',
-		value: 'available_pods',
-		id: 'available_pods',
-		canRemove: false,
-	},
-	{
-		label: 'Desired',
-		value: 'desired_pods',
-		id: 'desired_pods',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Req Usage (%)',
-		value: 'cpu_request',
-		id: 'cpu_request',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Limit Usage (%)',
-		value: 'cpu_limit',
-		id: 'cpu_limit',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Req Usage (%)',
-		value: 'memory_request',
-		id: 'memory_request',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Limit Usage (%)',
-		value: 'memory_limit',
-		id: 'memory_limit',
-		canRemove: false,
-	},
-	{
-		label: 'Mem Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-];
-
-export interface K8sStatefulSetsRowData {
-	key: string;
-	statefulsetUID: string;
-	statefulsetName: React.ReactNode;
-	cpu_request: React.ReactNode;
-	cpu_limit: React.ReactNode;
-	cpu: React.ReactNode;
-	memory_request: React.ReactNode;
-	memory_limit: React.ReactNode;
-	memory: React.ReactNode;
-	desired_pods: React.ReactNode;
-	available_pods: React.ReactNode;
-	namespaceName: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const statefulSetGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> STATEFULSET GROUP
-		</div>
-	),
-	dataIndex: 'statefulSetGroup',
-	key: 'statefulSetGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sStatefulSetsListQuery = (): K8sStatefulSetsListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnProgressBarClassName = 'column-progress-bar';
-
-const columnsConfig = [
-	{
-		title: (
-			<div className="column-header-left statefulset-name-header">
-				StatefulSet Name
-			</div>
-		),
-		dataIndex: 'statefulsetName',
-		key: 'statefulsetName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: (
-			<div className="column-header-left namespace-name-header">
-				Namespace Name
-			</div>
-		),
-		dataIndex: 'namespaceName',
-		key: 'namespaceName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header small-col">Available</div>,
-		dataIndex: 'available_pods',
-		key: 'available_pods',
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column small-col`,
-	},
-	{
-		title: <div className="column-header small-col">Desired</div>,
-		dataIndex: 'desired_pods',
-		key: 'desired_pods',
-		sorter: true,
-		align: 'left',
-		className: `column small-col`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Req Usage (%)</div>,
-		dataIndex: 'cpu_request',
-		key: 'cpu_request',
-		width: 180,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">CPU Limit Usage (%)</div>,
-		dataIndex: 'cpu_limit',
-		key: 'cpu_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header small-col">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Req Usage (%)</div>,
-		dataIndex: 'memory_request',
-		key: 'memory_request',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Limit Usage (%)</div>,
-		dataIndex: 'memory_limit',
-		key: 'memory_limit',
-		width: 120,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-	{
-		title: <div className="column-header med-col">Mem Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 120,
-		ellipsis: true,
-		sorter: true,
-		align: 'left',
-		className: `column ${columnProgressBarClassName}`,
-	},
-];
-
-export const getK8sStatefulSetsListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sStatefulSetsRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'statefulsetName',
-		);
-		filteredColumns.unshift(statefulSetGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sStatefulSetsRowData>[];
-	}
-
-	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'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		const rawKey = group.key as string;
-
-		// Choose mapped key if present, otherwise use rawKey
-		const metaKey = (dotToUnder[rawKey] ??
-			rawKey) as keyof typeof statefulSet.meta;
-		const value = statefulSet.meta[metaKey];
-
-		groupByValues.push(value);
-	});
-
-	return (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sStatefulSetsData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sStatefulSetsRowData[] =>
-	data.map((statefulSet, index) => ({
-		key: index.toString(),
-		statefulsetUID: statefulSet.statefulSetName,
-		statefulsetName: (
-			<Tooltip title={statefulSet.meta.k8s_statefulset_name}>
-				{statefulSet.meta.k8s_statefulset_name || ''}
-			</Tooltip>
-		),
-		namespaceName: (
-			<Tooltip title={statefulSet.meta.k8s_namespace_name}>
-				{statefulSet.meta.k8s_namespace_name || ''}
-			</Tooltip>
-		),
-		cpu_request: (
-			<ValidateColumnValueWrapper
-				value={statefulSet.cpuRequest}
-				entity={K8sCategory.STATEFULSETS}
-				attribute="CPU Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={statefulSet.cpuRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu_limit: (
-			<ValidateColumnValueWrapper
-				value={statefulSet.cpuLimit}
-				entity={K8sCategory.STATEFULSETS}
-				attribute="CPU Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={statefulSet.cpuLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		cpu: (
-			<ValidateColumnValueWrapper value={statefulSet.cpuUsage}>
-				{statefulSet.cpuUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory_request: (
-			<ValidateColumnValueWrapper
-				value={statefulSet.memoryRequest}
-				entity={K8sCategory.STATEFULSETS}
-				attribute="Memory Request"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={statefulSet.memoryRequest} type="request" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory_limit: (
-			<ValidateColumnValueWrapper
-				value={statefulSet.memoryLimit}
-				entity={K8sCategory.STATEFULSETS}
-				attribute="Memory Limit"
-			>
-				<div className="progress-container">
-					<EntityProgressBar value={statefulSet.memoryLimit} type="limit" />
-				</div>
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={statefulSet.memoryUsage}>
-				{formatBytes(statefulSet.memoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		available_pods: (
-			<ValidateColumnValueWrapper value={statefulSet.availablePods}>
-				{statefulSet.availablePods}
-			</ValidateColumnValueWrapper>
-		),
-		desired_pods: (
-			<ValidateColumnValueWrapper value={statefulSet.desiredPods}>
-				{statefulSet.desiredPods}
-			</ValidateColumnValueWrapper>
-		),
-		statefulSetGroup: getGroupByEle(statefulSet, groupBy),
-		meta: statefulSet.meta,
-		...statefulSet.meta,
-		groupedByMeta: statefulSet.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/Volumes/K8sVolumesList.styles.scss

@@ -1,45 +0,0 @@
-.infra-monitoring-container {
-	.volumes-list-table {
-		.expanded-table-container {
-			padding-left: 60px;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}
-
-.ant-table-cell {
-	&:has(.pvc-name-header) {
-		min-width: 250px !important;
-		max-width: 250px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.namespace-name-header) {
-		min-width: 220px !important;
-		max-width: 220px !important;
-	}
-}
-
-.ant-table-cell {
-	&:has(.small-col) {
-		min-width: 120px !important;
-		max-width: 120px !important;
-	}
-}
-
-.expanded-volumes-list-table {
-	.ant-table-cell {
-		min-width: 223px !important;
-		max-width: 223px !important;
-	}
-
-	.ant-table-row-expand-icon-cell {
-		min-width: 30px !important;
-		max-width: 30px !important;
-	}
-}

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

@@ -1,674 +1,117 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sVolumesListPayload } from 'api/infraMonitoring/getK8sVolumesList';
-import classNames from 'classnames';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sVolumesList } from 'hooks/infraMonitoring/useGetK8sVolumesList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sVolumesList, K8sVolumesData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getVolumeMetricsQueryPayload,
+	k8sVolumeDetailsMetadataConfig,
+	k8sVolumeGetEntityName,
+	k8sVolumeGetSelectedItemFilters,
+	k8sVolumeInitialEventsFilter,
+	k8sVolumeInitialFilters,
+	k8sVolumeInitialLogTracesFilter,
+	volumeWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringVolumeUID,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sVolumesListColumns,
-	getK8sVolumesListQuery,
-	getVolumeListGroupedByRowDataQueryKey,
-	getVolumesListQueryKey,
-	K8sVolumesRowData,
-} from './utils';
-import VolumeDetails from './VolumeDetails';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sVolumesList.styles.scss';
+	k8sVolumesColumns,
+	k8sVolumesColumnsConfig,
+	k8sVolumesRenderRowData,
+} from './table';
 
 function K8sVolumesList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [
-		selectedVolumeUID,
-		setselectedVolumeUID,
-	] = useInfraMonitoringVolumeUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.VOLUMES);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sVolumesRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sVolumesRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'usage',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sVolumesListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(
-		() =>
-			getVolumeListGroupedByRowDataQueryKey(
-				selectedRowData?.groupedByMeta,
-				queryFilters,
-				orderBy,
-				groupBy,
-				minTime,
-				maxTime,
-			),
-		[
-			selectedRowData?.groupedByMeta,
-			queryFilters,
-			orderBy,
-			groupBy,
-			minTime,
-			maxTime,
-		],
-	);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sVolumesList(
-		fetchGroupedByRowDataQuery as K8sVolumesListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.VOLUMES,
+			const response = await getK8sVolumesList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.VOLUMES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sVolumesListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const volumesListQueryKey = useMemo(() => {
-		return getVolumesListQueryKey(
-			selectedVolumeUID,
-			pageSize,
-			currentPage,
-			queryFilters,
-			orderBy,
-			groupBy,
-			minTime,
-			maxTime,
-		);
-	}, [
-		selectedVolumeUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		groupBy,
-		orderBy,
-		minTime,
-		maxTime,
-	]);
-
-	const formattedGroupedByVolumesData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const nestedVolumesData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sVolumesList(
-		query as K8sVolumesListPayload,
-		{
-			queryKey: volumesListQueryKey,
-			enabled: !!query,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const volumesData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedVolumesData = useMemo(
-		() => formatDataForTable(volumesData, groupBy),
-		[volumesData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sVolumesListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sVolumesRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sVolumesRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<K8sVolumesRowData> | SorterResult<K8sVolumesRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Volumes,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Volumes,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Volumes,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedVolumeData = useMemo(() => {
-		if (!selectedVolumeUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			return (
-				nestedVolumesData.find(
-					(volume) => volume.persistentVolumeClaimName === selectedVolumeUID,
-				) || null
 			);
-		}
-		return (
-			volumesData.find(
-				(volume) => volume.persistentVolumeClaimName === selectedVolumeUID,
-			) || null
-		);
-	}, [selectedVolumeUID, volumesData, groupBy.length, nestedVolumesData]);
 
-	const openVolumeInNewTab = (record: K8sVolumesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID, record.volumeUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sVolumesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openVolumeInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedVolumeUID(record.volumeUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Volumes,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sVolumesListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sVolumesRowData>[]}
-						dataSource={formattedGroupedByVolumesData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openVolumeInNewTab(record);
-									return;
-								}
-								setselectedVolumeUID(record.volumeUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sVolumesRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sVolumesRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseVolumeDetail = (): void => {
-		setselectedVolumeUID(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const groupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					groupBy.push(key);
-				}
-			}
-
-			setCurrentPage(1);
-			setGroupBy(groupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Volumes,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData?.payload?.attributeKeys, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sVolumesData | null; error?: string | null }> => {
+			const response = await getK8sVolumesList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Volumes,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedVolumesData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sVolumesData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.VOLUMES}
-				showAutoRefresh={!selectedVolumeData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className={classNames('k8s-list-table', 'volumes-list-table', {
-					'expanded-volumes-list-table': isGroupedByAttribute,
-				})}
-				dataSource={showTableLoadingState ? [] : formattedVolumesData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sVolumesColumns}
+				tableColumns={k8sVolumesColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sVolumesRenderRowData}
+				eventCategory={InfraMonitoringEvents.Volumes}
 			/>
 
-			<VolumeDetails
-				volume={selectedVolumeData}
-				isModalTimeSelection
-				onClose={handleCloseVolumeDetail}
+			<K8sBaseDetails<K8sVolumesData>
+				category={K8sCategory.VOLUMES}
+				eventCategory={InfraMonitoringEvents.Volume}
+				getSelectedItemFilters={k8sVolumeGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sVolumeGetEntityName}
+				getInitialLogTracesFilters={k8sVolumeInitialLogTracesFilter}
+				getInitialEventsFilters={k8sVolumeInitialEventsFilter}
+				primaryFilterKeys={k8sVolumeInitialFilters}
+				metadataConfig={k8sVolumeDetailsMetadataConfig}
+				entityWidgetInfo={volumeWidgetInfo}
+				getEntityQueryPayload={getVolumeMetricsQueryPayload}
+				queryKeyPrefix="volume"
+				hideDetailViewTabs
 			/>
-		</div>
+		</>
 	);
 }
 

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

@@ -1,208 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Divider, Drawer, Tooltip, Typography } from 'antd';
-import logEvent from 'api/common/logEvent';
-import { InfraMonitoringEvents } from 'constants/events';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import GetMinMax from 'lib/getMinMax';
-import { X } from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import VolumeMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import { getVolumeQueryPayload, volumeWidgetInfo } from './constants';
-import { VolumeDetailsProps } from './VoumeDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function VolumeDetails({
-	volume,
-	onClose,
-	isModalTimeSelection,
-}: VolumeDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const isDarkMode = useIsDarkMode();
-
-	useEffect(() => {
-		if (volume) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Volume,
-			});
-		}
-	}, [volume]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Volume,
-				interval,
-			});
-		},
-		[],
-	);
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{volume?.persistentVolumeClaimName}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!volume}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{volume && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									PVC Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Namespace Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={volume.persistentVolumeClaimName}>
-										{volume.persistentVolumeClaimName}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={volume.meta.k8s_cluster_name}>
-										{volume.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={volume.meta.k8s_namespace_name}>
-										{volume.meta.k8s_namespace_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<VolumeMetrics
-						timeRange={modalTimeRange}
-						isModalTimeSelection={isModalTimeSelection}
-						handleTimeChange={handleTimeChange}
-						selectedInterval={selectedInterval}
-						entity={volume}
-						entityWidgetInfo={volumeWidgetInfo}
-						getEntityQueryPayload={getVolumeQueryPayload}
-						queryKey="volumeMetrics"
-						category={K8sCategory.VOLUMES}
-					/>
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default VolumeDetails;

frontend/src/container/InfraMonitoringK8s/Volumes/VolumeDetails/VoumeDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sVolumesData } from 'api/infraMonitoring/getK8sVolumesList';
-
-export type VolumeDetailsProps = {
-	volume: K8sVolumesData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

frontend/src/container/InfraMonitoringK8s/Volumes/VolumeDetails/index.ts

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

frontend/src/container/InfraMonitoringK8s/Volumes/api.ts

@@ -1,22 +1,10 @@
 import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
 import { AxiosError } from 'axios';
 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[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
+import { K8sBaseFilters } from '../Base/K8sBaseList';
 
 export interface K8sVolumesData {
 	persistentVolumeClaimName: string;
@@ -68,10 +56,8 @@ export const volumesMetaMap: Array<{
 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];
@@ -83,42 +69,47 @@ export function mapVolumesMeta(
 }
 
 export const getK8sVolumesList = async (
-	props: K8sVolumesListPayload,
+	props: K8sBaseFilters,
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
 	dotMetricsEnabled = false,
 ): Promise<SuccessResponse<K8sVolumesListResponse> | ErrorResponse> => {
 	try {
-		// Prepare filters
+		const { orderBy, ...rest } = props;
+		const basePayload = {
+			...rest,
+			filters: props.filters ?? { items: [], op: 'and' },
+			...(orderBy != null ? { orderBy } : {}),
+		};
+
 		const requestProps =
-			dotMetricsEnabled && Array.isArray(props.filters?.items)
+			dotMetricsEnabled && Array.isArray(basePayload.filters?.items)
 				? {
-						...props,
+						...basePayload,
 						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);
-									}
+							...basePayload.filters,
+							items: basePayload.filters.items.reduce<
+								typeof basePayload.filters.items
+							>((acc, item) => {
+								if (item.value === undefined) {
 									return acc;
-								},
-								[] as typeof props.filters.items,
-							),
+								}
+								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 basePayload.filters.items),
 						},
 				  }
-				: props;
+				: basePayload;
 
 		const response = await axios.post('/pvcs/list', requestProps, {
 			signal,