fix(api): use UPSTREAM_UNAVAILABLE code for non-envelope error bodies

Address review: when the response body isn't a V2 envelope (e.g. a gateway
5xx during a deploy), throw a stable UPSTREAM_UNAVAILABLE code instead of
the stringified HTTP status, and trim the guard comment.

frontend/package.json

@@ -89,7 +89,7 @@
     "lodash-es": "^4.17.21",
     "motion": "12.4.13",
     "nuqs": "2.8.8",
-    "overlayscrollbars": "^2.16.0",
+    "overlayscrollbars": "^2.8.1",
     "overlayscrollbars-react": "^0.5.6",
     "papaparse": "5.4.1",
     "posthog-js": "1.298.0",
@@ -221,18 +221,5 @@
     "*.(scss|css)": [
       "stylelint"
     ]
-  },
-  "overrides": {
-    "@babel/core@<=7.29.0": ">=7.29.6 <8",
-    "@istanbuljs/load-nyc-config>js-yaml": ">=4.2.0 <5",
-    "cookie@<0.7.0": ">=0.7.1 <1",
-    "dompurify@<=3.4.10": ">=3.4.11 <4",
-    "esbuild@>=0.27.3 <0.28.1": ">=0.28.1 <0.29.0",
-    "js-cookie@<=3.0.5": ">=3.0.7 <4",
-    "js-yaml@>=4.0.0 <=4.1.1": ">=4.2.0 <5",
-    "prismjs@<1.30.0": ">=1.30.0 <2",
-    "react-router@>=6.7.0 <6.30.4": ">=6.30.4 <7",
-    "tmp@<0.2.6": ">=0.2.6 <0.3.0",
-    "yaml@>=1.0.0 <1.10.3": ">=1.10.3 <2"
   }
-}
+}

frontend/pnpm-lock.yaml

@@ -187,11 +187,11 @@ importers:
         specifier: 2.8.8
         version: 2.8.8(react-router-dom@5.3.4(react@18.2.0))(react-router@6.30.4(react@18.2.0))(react@18.2.0)
       overlayscrollbars:
-        specifier: ^2.16.0
-        version: 2.16.0
+        specifier: ^2.8.1
+        version: 2.9.2
       overlayscrollbars-react:
         specifier: ^0.5.6
-        version: 0.5.6(overlayscrollbars@2.16.0)(react@18.2.0)
+        version: 0.5.6(overlayscrollbars@2.9.2)(react@18.2.0)
       papaparse:
         specifier: 5.4.1
         version: 5.4.1
@@ -6941,8 +6941,8 @@ packages:
       overlayscrollbars: ^2.0.0
       react: '>=16.8.0'
 
-  overlayscrollbars@2.16.0:
-    resolution: {integrity: sha512-N03oje/q7j93D0aLZtoCdsDSYLmhheSsv8H7oSLE7HhdV9P/bmCURtLV/KbPye7P/bpfyt/obSfDpGUYoJ0OWg==}
+  overlayscrollbars@2.9.2:
+    resolution: {integrity: sha512-iDT84r39i7oWP72diZN2mbJUsn/taCq568aQaIrc84S87PunBT7qtsVltAF2esk7ORTRjQDnfjVYoqqTzgs8QA==}
 
   oxfmt@0.54.0:
     resolution: {integrity: sha512-DjnMwn7smSLF+Mc2+pRItnuPftm/dkUFpY/d4+33y9TfKrsHZo8GLhmUg9BrOIUEy94Rlom1Q11N6vuhE+e0oQ==}
@@ -16456,12 +16456,12 @@ snapshots:
 
   outvariant@1.4.0: {}
 
-  overlayscrollbars-react@0.5.6(overlayscrollbars@2.16.0)(react@18.2.0):
+  overlayscrollbars-react@0.5.6(overlayscrollbars@2.9.2)(react@18.2.0):
     dependencies:
-      overlayscrollbars: 2.16.0
+      overlayscrollbars: 2.9.2
       react: 18.2.0
 
-  overlayscrollbars@2.16.0: {}
+  overlayscrollbars@2.9.2: {}
 
   oxfmt@0.54.0:
     dependencies:

frontend/src/__tests__/fields_api.util.ts

@@ -1,20 +0,0 @@
-import { ENVIRONMENT } from 'constants/env';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-
-export function mockFieldsAPIsWithEmptyResponse(): void {
-	server.use(
-		rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/keys`, (_, res, ctx) =>
-			res(
-				ctx.status(200),
-				ctx.json({ status: 'success', data: { keys: {}, complete: true } }),
-			),
-		),
-		rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/values`, (_, res, ctx) =>
-			res(
-				ctx.status(200),
-				ctx.json({ status: 'success', data: { values: {}, complete: true } }),
-			),
-		),
-	);
-}

frontend/src/api/ErrorResponseHandlerV2.ts

@@ -2,19 +2,38 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp } from 'types/api';
 import APIError from 'types/api/error';
 
+function isErrorV2Resp(data: unknown): data is ErrorV2Resp {
+	return (
+		typeof data === 'object' &&
+		data !== null &&
+		'error' in data &&
+		typeof (data as ErrorV2Resp).error?.code === 'string'
+	);
+}
+
 // reference - https://axios-http.com/docs/handling_errors
 export function ErrorResponseHandlerV2(error: AxiosError<ErrorV2Resp>): never {
 	const { response, request } = error;
 	// The request was made and the server responded with a status code
 	// that falls out of the range of 2xx
 	if (response) {
+		// response.data isn't guaranteed to be a V2 envelope (e.g. a gateway 5xx
+		// with an HTML/empty body during a deploy), so verify the shape first.
+		const data: unknown = response.data;
+		if (isErrorV2Resp(data)) {
+			const { code, message, url, errors } = data.error;
+			throw new APIError({
+				httpStatusCode: response.status || 500,
+				error: { code, message, url, errors },
+			});
+		}
 		throw new APIError({
 			httpStatusCode: response.status || 500,
 			error: {
-				code: response.data.error.code,
-				message: response.data.error.message,
-				url: response.data.error.url,
-				errors: response.data.error.errors,
+				code: 'UPSTREAM_UNAVAILABLE',
+				message: error.message || 'Something went wrong',
+				url: '',
+				errors: [],
 			},
 		});
 	}

frontend/src/api/__tests__/ErrorResponseHandlerV2.test.ts

@@ -0,0 +1,98 @@
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp } from 'types/api';
+import APIError from 'types/api/error';
+
+function asAxiosError(partial: Partial<AxiosError>): AxiosError<ErrorV2Resp> {
+	return partial as AxiosError<ErrorV2Resp>;
+}
+
+// ErrorResponseHandlerV2 always throws — capture the APIError so assertions stay
+// unconditional.
+function runHandler(error: AxiosError<ErrorV2Resp>): APIError {
+	try {
+		ErrorResponseHandlerV2(error);
+	} catch (thrown) {
+		return thrown as APIError;
+	}
+	throw new Error('expected ErrorResponseHandlerV2 to throw');
+}
+
+describe('ErrorResponseHandlerV2', () => {
+	it('surfaces the V2 error envelope when the body is well-formed', () => {
+		const apiError = runHandler(
+			asAxiosError({
+				message: 'Request failed with status code 400',
+				response: {
+					status: 400,
+					data: {
+						error: {
+							code: 'bad_request',
+							message: 'Invalid dashboard payload',
+							url: 'https://signoz.io/docs',
+							errors: [{ message: 'name is required' }],
+						},
+					},
+				} as AxiosError['response'],
+			}),
+		);
+
+		expect(apiError).toBeInstanceOf(APIError);
+		expect(apiError.getHttpStatusCode()).toBe(400);
+		expect(apiError.getErrorCode()).toBe('bad_request');
+		expect(apiError.getErrorMessage()).toBe('Invalid dashboard payload');
+	});
+
+	// Regression: during a deployment the gateway returns a 5xx with a non-envelope
+	// (HTML/empty) body. Reading response.data.error.code used to throw a TypeError
+	// from inside the handler itself. See engineering-pod#5760.
+	it('does not throw a TypeError when the 5xx body is not a V2 envelope', () => {
+		const apiError = runHandler(
+			asAxiosError({
+				message: 'Request failed with status code 503',
+				response: {
+					status: 503,
+					data: '<html><body>503 Service Temporarily Unavailable</body></html>',
+				} as AxiosError['response'],
+			}),
+		);
+
+		expect(apiError).toBeInstanceOf(APIError);
+		expect(apiError.getHttpStatusCode()).toBe(503);
+		expect(apiError.getErrorCode()).toBe('UPSTREAM_UNAVAILABLE');
+		expect(apiError.getErrorMessage()).toBe(
+			'Request failed with status code 503',
+		);
+	});
+
+	it('handles a 5xx with an empty body', () => {
+		const apiError = runHandler(
+			asAxiosError({
+				message: 'Request failed with status code 502',
+				response: {
+					status: 502,
+					data: undefined,
+				} as AxiosError['response'],
+			}),
+		);
+
+		expect(apiError).toBeInstanceOf(APIError);
+		expect(apiError.getHttpStatusCode()).toBe(502);
+		expect(apiError.getErrorCode()).toBe('UPSTREAM_UNAVAILABLE');
+	});
+
+	it('falls back to error metadata when no response was received', () => {
+		const apiError = runHandler(
+			asAxiosError({
+				message: 'Network Error',
+				code: 'ERR_NETWORK',
+				name: 'AxiosError',
+				request: {},
+			}),
+		);
+
+		expect(apiError).toBeInstanceOf(APIError);
+		expect(apiError.getErrorCode()).toBe('ERR_NETWORK');
+		expect(apiError.getErrorMessage()).toBe('Network Error');
+	});
+});

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

@@ -1,39 +1,148 @@
-import { useCallback, useEffect, useMemo } from 'react';
+import React, {
+	useCallback,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from 'react';
 import { useQuery } from 'react-query';
 import { Color, Spacing } from '@signozhq/design-tokens';
-import { X } from '@signozhq/icons';
+import { Button, Drawer, Tooltip } from 'antd';
+import { ToggleGroupSimple } from '@signozhq/ui/toggle-group';
 import { Divider } from '@signozhq/ui/divider';
 import { Typography } from '@signozhq/ui/typography';
-import { Drawer } from 'antd';
 import logEvent from 'api/common/logEvent';
 import ErrorContent from 'components/ErrorModal/components/ErrorContent';
 import APIError from 'types/api/error';
+import { combineInitialAndUserExpression } from 'components/QueryBuilderV2/QueryV2/QuerySearch/utils';
 import { InfraMonitoringEvents } from 'constants/events';
-import { useIsDarkMode } from 'hooks/useDarkMode';
+import { QueryParams } from 'constants/query';
 import {
-	GlobalTimeProvider,
-	NANO_SECOND_MULTIPLIER,
-	useGlobalTimeStore,
-} from 'store/globalTime';
+	initialQueryBuilderFormValuesMap,
+	initialQueryState,
+} from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
+import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import GetMinMax from 'lib/getMinMax';
+import {
+	BarChart,
+	ChevronsLeftRight,
+	Compass,
+	DraftingCompass,
+	ScrollText,
+	X,
+} from '@signozhq/icons';
+import { isCustomTimeRange, useGlobalTimeStore } from 'store/globalTime';
+import { NANO_SECOND_MULTIPLIER } from 'store/globalTime/utils';
+import {
+	LogsAggregatorOperator,
+	TracesAggregatorOperator,
+} from 'types/common/queryBuilder';
+import { openInNewTab } from 'utils/navigation';
 
-import { INFRA_MONITORING_K8S_PARAMS_KEYS } from '../constants';
-import { useInfraMonitoringSelectedItemParams } from '../hooks';
+import { InfraMonitoringEntity, VIEW_TYPES } from '../constants';
+import EntityEvents from '../EntityDetailsUtils/EntityEvents';
+import EntityLogs from '../EntityDetailsUtils/EntityLogs';
+import { K8S_ENTITY_LOGS_EXPRESSION_KEY } from '../EntityDetailsUtils/EntityLogs/hooks';
+import EntityMetrics from '../EntityDetailsUtils/EntityMetrics';
+import EntityTraces from '../EntityDetailsUtils/EntityTraces';
+import { K8S_ENTITY_TRACES_EXPRESSION_KEY } from '../EntityDetailsUtils/EntityTraces/hooks';
+import {
+	SelectedItemParams,
+	useInfraMonitoringEventsFilters,
+	useInfraMonitoringLogFilters,
+	useInfraMonitoringSelectedItemParams,
+	useInfraMonitoringTracesFilters,
+	useInfraMonitoringView,
+} from '../hooks';
 import LoadingContainer from '../LoadingContainer';
 
-import K8sBaseDetailsContent from './K8sBaseDetailsContent';
-import { K8sBaseDetailsProps } from './types';
-
 import '../EntityDetailsUtils/entityDetails.styles.scss';
+import { parseAsString, useQueryState } from 'nuqs';
+import {
+	EntityCountConfig,
+	EntityCountsSection,
+} from './components/EntityCountsSection/EntityCountsSection';
 
-export type {
-	CustomTab,
-	CustomTabRenderProps,
-	K8sBaseDetailsProps,
-	K8sDetailsCountConfig,
-	K8sDetailsFilters,
-	K8sDetailsMetadataConfig,
-} from './types';
+const TimeRangeOffset = 1000000000;
 
+export interface K8sDetailsMetadataConfig<T> {
+	label: string;
+	getValue: (entity: T) => string | number;
+	render?: (value: string | number, entity: T) => React.ReactNode;
+}
+
+export type K8sDetailsCountConfig<T> = EntityCountConfig<T>;
+
+export interface K8sDetailsFilters {
+	filter: { expression: string };
+	start: number;
+	end: number;
+}
+
+export interface CustomTabRenderProps<T> {
+	entity: T;
+	timeRange: { startTime: number; endTime: number };
+	selectedInterval: Time;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+}
+
+export interface CustomTab<T> {
+	key: string;
+	label: string;
+	icon: React.ReactNode;
+	render: (props: CustomTabRenderProps<T>) => React.ReactNode;
+}
+
+export interface K8sBaseDetailsProps<T> {
+	category: InfraMonitoringEntity;
+	eventCategory: string;
+	// Data fetching configuration
+	getSelectedItemExpression: (params: SelectedItemParams) => string;
+	fetchEntityData: (
+		filters: K8sDetailsFilters,
+		signal?: AbortSignal,
+	) => Promise<{ data: T | null; error?: APIError | null }>;
+	// Entity configuration
+	getEntityName: (entity: T) => string;
+	getInitialLogTracesExpression: (entity: T) => string;
+	getInitialEventsExpression: (entity: T) => string;
+	metadataConfig: K8sDetailsMetadataConfig<T>[];
+	countsConfig?: K8sDetailsCountConfig<T>[];
+	getCountsFilterExpression?: (entity: T) => string;
+	entityWidgetInfo: {
+		title: string;
+		yAxisUnit: string;
+		docPath?: 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;
+	tabsConfig?: {
+		showMetrics?: boolean;
+		showLogs?: boolean;
+		showTraces?: boolean;
+		showEvents?: boolean;
+	};
+	customTabs?: Array<CustomTab<T>>;
+}
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
 export default function K8sBaseDetails<T>({
 	category,
 	eventCategory,
@@ -54,6 +163,7 @@ export default function K8sBaseDetails<T>({
 }: K8sBaseDetailsProps<T>): JSX.Element {
 	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
 	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+	const lastComputedMinMax = useGlobalTimeStore((s) => s.lastComputedMinMax);
 	const getAutoRefreshQueryKey = useGlobalTimeStore(
 		(s) => s.getAutoRefreshQueryKey,
 	);
@@ -127,9 +237,86 @@ export default function K8sBaseDetails<T>({
 
 	const entityName = entity ? getEntityName(entity) : '';
 
+	// Content state (previously in K8sBaseDetailsContent)
+	const tabVisibility = useMemo(
+		() => ({
+			showMetrics: true,
+			showLogs: true,
+			showTraces: true,
+			showEvents: true,
+			...tabsConfig,
+		}),
+		[tabsConfig],
+	);
+
+	const { startMs, endMs } = useMemo(
+		() => ({
+			startMs: Math.floor(lastComputedMinMax.minTime / NANO_SECOND_MULTIPLIER),
+			endMs: Math.floor(lastComputedMinMax.maxTime / NANO_SECOND_MULTIPLIER),
+		}),
+		[lastComputedMinMax],
+	);
+
+	const [modalTimeRange, setModalTimeRange] = useState(() => ({
+		startTime: startMs,
+		endTime: endMs,
+	}));
+
+	// TODO(h4ad): Remove this and use context/zustand
+	const lastSelectedInterval = useRef<Time | null>(null);
+	const [selectedInterval, setSelectedInterval] = useState<Time>(
+		lastSelectedInterval.current
+			? lastSelectedInterval.current
+			: isCustomTimeRange(selectedTime)
+				? DEFAULT_TIME_RANGE
+				: selectedTime,
+	);
+
+	const [selectedView, setSelectedView] = useInfraMonitoringView();
+	const effectiveView = hideDetailViewTabs ? VIEW_TYPES.METRICS : selectedView;
+
+	const validTabs = useMemo(() => {
+		const tabs: string[] = [];
+		if (tabVisibility.showMetrics) {
+			tabs.push(VIEW_TYPES.METRICS);
+		}
+		if (tabVisibility.showLogs) {
+			tabs.push(VIEW_TYPES.LOGS);
+		}
+		if (tabVisibility.showTraces) {
+			tabs.push(VIEW_TYPES.TRACES);
+		}
+		if (tabVisibility.showEvents) {
+			tabs.push(VIEW_TYPES.EVENTS);
+		}
+		if (customTabs) {
+			tabs.push(...customTabs.map((t) => t.key));
+		}
+		return tabs;
+	}, [tabVisibility, customTabs]);
+
+	useEffect(() => {
+		if (!hideDetailViewTabs && !validTabs.includes(selectedView)) {
+			const firstValid = validTabs[0] || VIEW_TYPES.METRICS;
+			void setSelectedView(firstValid);
+		}
+	}, [hideDetailViewTabs, selectedView, validTabs, setSelectedView]);
+
+	const [, setLogFiltersParam] = useInfraMonitoringLogFilters();
+	const [, setTracesFiltersParam] = useInfraMonitoringTracesFilters();
+	const [, setEventsFiltersParam] = useInfraMonitoringEventsFilters();
+	const [userLogsExpression] = useQueryState(
+		K8S_ENTITY_LOGS_EXPRESSION_KEY,
+		parseAsString,
+	);
+	const [userTracesExpression] = useQueryState(
+		K8S_ENTITY_TRACES_EXPRESSION_KEY,
+		parseAsString,
+	);
+
 	useEffect(() => {
 		if (entity) {
-			void logEvent(InfraMonitoringEvents.PageVisited, {
+			logEvent(InfraMonitoringEvents.PageVisited, {
 				entity: InfraMonitoringEvents.K8sEntity,
 				page: InfraMonitoringEvents.DetailedPage,
 				category: eventCategory,
@@ -137,6 +324,136 @@ export default function K8sBaseDetails<T>({
 		}
 	}, [entity, eventCategory]);
 
+	useEffect(() => {
+		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
+		if (!isCustomTimeRange(currentSelectedInterval)) {
+			setSelectedInterval(currentSelectedInterval);
+			const { minTime, maxTime } = getMinMaxTime();
+
+			setModalTimeRange({
+				startTime: Math.floor(minTime / TimeRangeOffset),
+				endTime: Math.floor(maxTime / TimeRangeOffset),
+			});
+		}
+	}, [getMinMaxTime, selectedTime]);
+
+	const handleTabChange = (value: string | null): void => {
+		if (!value) {
+			return;
+		}
+		setSelectedView(value);
+		setLogFiltersParam(null);
+		setTracesFiltersParam(null);
+		setEventsFiltersParam(null);
+		logEvent(InfraMonitoringEvents.TabChanged, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.DetailedPage,
+			category: eventCategory,
+			view: 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 / TimeRangeOffset),
+					endTime: Math.floor(maxTime / TimeRangeOffset),
+				});
+			}
+
+			logEvent(InfraMonitoringEvents.TimeUpdated, {
+				entity: InfraMonitoringEvents.K8sEntity,
+				page: InfraMonitoringEvents.DetailedPage,
+				category: eventCategory,
+				interval,
+				view: effectiveView,
+			});
+		},
+		[eventCategory, effectiveView],
+	);
+
+	const handleExplorePagesRedirect = (): void => {
+		const urlQuery = new URLSearchParams();
+
+		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: eventCategory,
+			view: selectedView,
+		});
+
+		if (selectedView === VIEW_TYPES.LOGS) {
+			const fullExpression = combineInitialAndUserExpression(
+				logsAndTracesInitialExpression,
+				userLogsExpression || '',
+			);
+
+			const compositeQuery = {
+				...initialQueryState,
+				queryType: 'builder',
+				builder: {
+					...initialQueryState.builder,
+					queryData: [
+						{
+							...initialQueryBuilderFormValuesMap.logs,
+							aggregateOperator: LogsAggregatorOperator.NOOP,
+							expression: fullExpression,
+							filter: { expression: fullExpression },
+						},
+					],
+				},
+			};
+
+			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
+
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
+		} else if (selectedView === VIEW_TYPES.TRACES) {
+			const fullExpression = combineInitialAndUserExpression(
+				logsAndTracesInitialExpression,
+				userTracesExpression || '',
+			);
+
+			const compositeQuery = {
+				...initialQueryState,
+				queryType: 'builder',
+				builder: {
+					...initialQueryState.builder,
+					queryData: [
+						{
+							...initialQueryBuilderFormValuesMap.traces,
+							aggregateOperator: TracesAggregatorOperator.NOOP,
+							expression: fullExpression,
+							filter: { expression: fullExpression },
+						},
+					],
+				},
+			};
+
+			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
+
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
+		}
+	};
+
 	return (
 		<Drawer
 			width="70%"
@@ -181,33 +498,207 @@ export default function K8sBaseDetails<T>({
 				</div>
 			)}
 			{entity && !isEntityLoading && !hasResponseError && (
-				<GlobalTimeProvider
-					inheritGlobalTime
-					enableUrlParams={{
-						relativeTimeKey: INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_RELATIVE_TIME,
-						startTimeKey: INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_START_TIME,
-						endTimeKey: INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_END_TIME,
-					}}
-				>
-					<K8sBaseDetailsContent<T>
-						entity={entity}
-						category={category}
-						eventCategory={eventCategory}
-						metadataConfig={metadataConfig}
-						countsConfig={countsConfig}
-						getCountsFilterExpression={getCountsFilterExpression}
-						selectedItem={selectedItem}
-						handleClose={handleClose}
-						entityWidgetInfo={entityWidgetInfo}
-						getEntityQueryPayload={getEntityQueryPayload}
-						queryKeyPrefix={queryKeyPrefix}
-						hideDetailViewTabs={hideDetailViewTabs}
-						tabsConfig={tabsConfig}
-						customTabs={customTabs}
-						logsAndTracesInitialExpression={logsAndTracesInitialExpression}
-						eventsInitialExpression={eventsInitialExpression}
-					/>
-				</GlobalTimeProvider>
+				<>
+					<div className="entity-detail-drawer__entity">
+						<div className="entity-details-grid">
+							<div className="labels-row">
+								{metadataConfig.map((config) => (
+									<Typography.Text
+										key={config.label}
+										color="muted"
+										className="entity-details-metadata-label"
+									>
+										{config.label}
+									</Typography.Text>
+								))}
+							</div>
+
+							<div className="values-row">
+								{metadataConfig.map((config) => {
+									const value = config.getValue(entity);
+									const displayValue = String(value);
+									return (
+										<Typography.Text
+											key={config.label}
+											className="entity-details-metadata-value"
+										>
+											{config.render ? (
+												config.render(value, entity)
+											) : (
+												<Tooltip title={displayValue}>{displayValue}</Tooltip>
+											)}
+										</Typography.Text>
+									);
+								})}
+							</div>
+						</div>
+
+						{countsConfig &&
+							countsConfig.length > 0 &&
+							selectedItem &&
+							getCountsFilterExpression && (
+								<EntityCountsSection
+									entity={entity}
+									countsConfig={countsConfig}
+									selectedItem={selectedItem}
+									filterExpression={getCountsFilterExpression(entity)}
+									closeDrawer={handleClose}
+								/>
+							)}
+					</div>
+
+					{!hideDetailViewTabs && (
+						<div className="views-tabs-container">
+							<ToggleGroupSimple
+								type="single"
+								className="views-tabs"
+								onChange={handleTabChange}
+								value={selectedView}
+								items={[
+									...(tabVisibility.showMetrics
+										? [
+												{
+													value: VIEW_TYPES.METRICS,
+													label: (
+														<div className="view-title">
+															<BarChart size={14} />
+															Metrics
+														</div>
+													),
+												},
+											]
+										: []),
+									...(tabVisibility.showLogs
+										? [
+												{
+													value: VIEW_TYPES.LOGS,
+													label: (
+														<div className="view-title">
+															<ScrollText size={14} />
+															Logs
+														</div>
+													),
+												},
+											]
+										: []),
+									...(tabVisibility.showTraces
+										? [
+												{
+													value: VIEW_TYPES.TRACES,
+													label: (
+														<div className="view-title">
+															<DraftingCompass size={14} />
+															Traces
+														</div>
+													),
+												},
+											]
+										: []),
+									...(tabVisibility.showEvents
+										? [
+												{
+													value: VIEW_TYPES.EVENTS,
+													label: (
+														<div className="view-title">
+															<ChevronsLeftRight size={14} />
+															Events
+														</div>
+													),
+												},
+											]
+										: []),
+									...(customTabs?.map((tab) => ({
+										value: tab.key,
+										label: (
+											<div className="view-title">
+												{tab.icon}
+												{tab.label}
+											</div>
+										),
+									})) ?? []),
+								]}
+							/>
+
+							{selectedView === VIEW_TYPES.LOGS && (
+								<Tooltip title="Go to Logs Explorer" placement="left">
+									<Button
+										icon={<Compass size={18} />}
+										className="compass-button"
+										onClick={handleExplorePagesRedirect}
+									/>
+								</Tooltip>
+							)}
+							{selectedView === VIEW_TYPES.TRACES && (
+								<Tooltip title="Go to Traces Explorer" placement="left">
+									<Button
+										icon={<Compass size={18} />}
+										className="compass-button"
+										onClick={handleExplorePagesRedirect}
+									/>
+								</Tooltip>
+							)}
+						</div>
+					)}
+
+					{effectiveView === VIEW_TYPES.METRICS && (
+						<EntityMetrics<T>
+							entity={entity}
+							selectedInterval={selectedInterval}
+							timeRange={modalTimeRange}
+							handleTimeChange={handleTimeChange}
+							isModalTimeSelection
+							entityWidgetInfo={entityWidgetInfo}
+							getEntityQueryPayload={getEntityQueryPayload}
+							category={category}
+							queryKey={`${queryKeyPrefix}Metrics`}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.LOGS && (
+						<EntityLogs
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							selectedInterval={selectedInterval}
+							queryKey={`${queryKeyPrefix}Logs`}
+							category={category}
+							initialExpression={logsAndTracesInitialExpression}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.TRACES && (
+						<EntityTraces
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							selectedInterval={selectedInterval}
+							queryKey={`${queryKeyPrefix}Traces`}
+							category={category}
+							initialExpression={logsAndTracesInitialExpression}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.EVENTS && tabVisibility.showEvents && (
+						<EntityEvents
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							selectedInterval={selectedInterval}
+							category={category}
+							queryKey={`${queryKeyPrefix}Events`}
+							initialExpression={eventsInitialExpression}
+						/>
+					)}
+					{customTabs?.map((tab) =>
+						selectedView === tab.key ? (
+							<React.Fragment key={tab.key}>
+								{tab.render({
+									entity,
+									timeRange: modalTimeRange,
+									selectedInterval,
+									handleTimeChange,
+								})}
+							</React.Fragment>
+						) : null,
+					)}
+				</>
 			)}
 		</Drawer>
 	);

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetailsContent.tsx

@@ -1,401 +0,0 @@
-import { Fragment, useEffect, useMemo } from 'react';
-import {
-	BarChart,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-} from '@signozhq/icons';
-import { ToggleGroupSimple } from '@signozhq/ui/toggle-group';
-import { Typography } from '@signozhq/ui/typography';
-import { Button, Tooltip } from 'antd';
-import logEvent from 'api/common/logEvent';
-import { combineInitialAndUserExpression } from 'components/QueryBuilderV2/QueryV2/QuerySearch/utils';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { parseAsString, useQueryState } from 'nuqs';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { openInNewTab } from 'utils/navigation';
-
-import { VIEW_TYPES } from '../constants';
-import { useEntityDetailsTime } from '../EntityDetailsUtils/EntityDateTimeSelector/useEntityDetailsTime';
-import EntityEvents from '../EntityDetailsUtils/EntityEvents';
-import EntityLogs from '../EntityDetailsUtils/EntityLogs';
-import { K8S_ENTITY_LOGS_EXPRESSION_KEY } from '../EntityDetailsUtils/EntityLogs/hooks';
-import EntityMetrics from '../EntityDetailsUtils/EntityMetrics';
-import EntityTraces from '../EntityDetailsUtils/EntityTraces';
-import { K8S_ENTITY_TRACES_EXPRESSION_KEY } from '../EntityDetailsUtils/EntityTraces/hooks';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-
-import { EntityCountsSection } from './components/EntityCountsSection/EntityCountsSection';
-import { K8sBaseDetailsContentProps } from './types';
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export default function K8sBaseDetailsContent<T>({
-	entity,
-	category,
-	eventCategory,
-	metadataConfig,
-	countsConfig,
-	getCountsFilterExpression,
-	selectedItem,
-	handleClose,
-	entityWidgetInfo,
-	getEntityQueryPayload,
-	queryKeyPrefix,
-	hideDetailViewTabs,
-	tabsConfig,
-	customTabs,
-	logsAndTracesInitialExpression,
-	eventsInitialExpression,
-}: K8sBaseDetailsContentProps<T>): JSX.Element {
-	const { timeRange, selectedInterval, handleTimeChange } =
-		useEntityDetailsTime();
-
-	const tabVisibility = useMemo(
-		() => ({
-			showMetrics: true,
-			showLogs: true,
-			showTraces: true,
-			showEvents: true,
-			...tabsConfig,
-		}),
-		[tabsConfig],
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-
-	const validTabs = useMemo(() => {
-		const tabs: string[] = [];
-		if (tabVisibility.showMetrics) {
-			tabs.push(VIEW_TYPES.METRICS);
-		}
-		if (tabVisibility.showLogs) {
-			tabs.push(VIEW_TYPES.LOGS);
-		}
-		if (tabVisibility.showTraces) {
-			tabs.push(VIEW_TYPES.TRACES);
-		}
-		if (tabVisibility.showEvents) {
-			tabs.push(VIEW_TYPES.EVENTS);
-		}
-		if (customTabs) {
-			tabs.push(...customTabs.map((t) => t.key));
-		}
-		return tabs;
-	}, [tabVisibility, customTabs]);
-
-	useEffect(() => {
-		if (!hideDetailViewTabs && !validTabs.includes(selectedView)) {
-			const firstValid = validTabs[0] || VIEW_TYPES.METRICS;
-			void setSelectedView(firstValid);
-		}
-	}, [hideDetailViewTabs, selectedView, validTabs, setSelectedView]);
-
-	const effectiveView = hideDetailViewTabs ? VIEW_TYPES.METRICS : selectedView;
-
-	const [, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [, setTracesFiltersParam] = useInfraMonitoringTracesFilters();
-	const [, setEventsFiltersParam] = useInfraMonitoringEventsFilters();
-	const [userLogsExpression] = useQueryState(
-		K8S_ENTITY_LOGS_EXPRESSION_KEY,
-		parseAsString,
-	);
-	const [userTracesExpression] = useQueryState(
-		K8S_ENTITY_TRACES_EXPRESSION_KEY,
-		parseAsString,
-	);
-
-	const handleTabChange = (value: string | null): void => {
-		if (!value) {
-			return;
-		}
-		void setSelectedView(value);
-		void setLogFiltersParam(null);
-		void setTracesFiltersParam(null);
-		void setEventsFiltersParam(null);
-		void logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: eventCategory,
-			view: value,
-		});
-	};
-
-	const handleExplorePagesRedirect = (): void => {
-		const urlQuery = new URLSearchParams();
-
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			// Explorer URL params are in milliseconds, timeRange is in seconds
-			urlQuery.set(QueryParams.startTime, (timeRange.startTime * 1000).toString());
-			urlQuery.set(QueryParams.endTime, (timeRange.endTime * 1000).toString());
-		}
-
-		void logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: eventCategory,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const fullExpression = combineInitialAndUserExpression(
-				logsAndTracesInitialExpression,
-				userLogsExpression || '',
-			);
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							expression: fullExpression,
-							filter: { expression: fullExpression },
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const fullExpression = combineInitialAndUserExpression(
-				logsAndTracesInitialExpression,
-				userTracesExpression || '',
-			);
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							expression: fullExpression,
-							filter: { expression: fullExpression },
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
-		}
-	};
-
-	return (
-		<>
-			<div className="entity-detail-drawer__entity">
-				<div className="entity-details-grid">
-					<div className="labels-row">
-						{metadataConfig.map((config) => (
-							<Typography.Text
-								key={config.label}
-								color="muted"
-								className="entity-details-metadata-label"
-							>
-								{config.label}
-							</Typography.Text>
-						))}
-					</div>
-
-					<div className="values-row">
-						{metadataConfig.map((config) => {
-							const value = config.getValue(entity);
-							const displayValue = String(value);
-							return (
-								<Typography.Text
-									key={config.label}
-									className="entity-details-metadata-value"
-								>
-									{config.render ? (
-										config.render(value, entity)
-									) : (
-										<Tooltip title={displayValue}>{displayValue}</Tooltip>
-									)}
-								</Typography.Text>
-							);
-						})}
-					</div>
-				</div>
-
-				{countsConfig &&
-					countsConfig.length > 0 &&
-					selectedItem &&
-					getCountsFilterExpression && (
-						<EntityCountsSection
-							entity={entity}
-							countsConfig={countsConfig}
-							selectedItem={selectedItem}
-							filterExpression={getCountsFilterExpression(entity)}
-							closeDrawer={handleClose}
-						/>
-					)}
-			</div>
-
-			{!hideDetailViewTabs && (
-				<div className="views-tabs-container">
-					<ToggleGroupSimple
-						type="single"
-						className="views-tabs"
-						onChange={handleTabChange}
-						value={selectedView}
-						items={[
-							...(tabVisibility.showMetrics
-								? [
-										{
-											value: VIEW_TYPES.METRICS,
-											label: (
-												<div className="view-title">
-													<BarChart size={14} />
-													Metrics
-												</div>
-											),
-										},
-									]
-								: []),
-							...(tabVisibility.showLogs
-								? [
-										{
-											value: VIEW_TYPES.LOGS,
-											label: (
-												<div className="view-title">
-													<ScrollText size={14} />
-													Logs
-												</div>
-											),
-										},
-									]
-								: []),
-							...(tabVisibility.showTraces
-								? [
-										{
-											value: VIEW_TYPES.TRACES,
-											label: (
-												<div className="view-title">
-													<DraftingCompass size={14} />
-													Traces
-												</div>
-											),
-										},
-									]
-								: []),
-							...(tabVisibility.showEvents
-								? [
-										{
-											value: VIEW_TYPES.EVENTS,
-											label: (
-												<div className="view-title">
-													<ChevronsLeftRight size={14} />
-													Events
-												</div>
-											),
-										},
-									]
-								: []),
-							...(customTabs?.map((tab) => ({
-								value: tab.key,
-								label: (
-									<div className="view-title">
-										{tab.icon}
-										{tab.label}
-									</div>
-								),
-							})) ?? []),
-						]}
-					/>
-
-					{selectedView === VIEW_TYPES.LOGS && (
-						<Tooltip title="Go to Logs Explorer" placement="left">
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						</Tooltip>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<Tooltip title="Go to Traces Explorer" placement="left">
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						</Tooltip>
-					)}
-				</div>
-			)}
-
-			{effectiveView === VIEW_TYPES.METRICS && (
-				<EntityMetrics<T>
-					entity={entity}
-					eventEntity={eventCategory}
-					entityWidgetInfo={entityWidgetInfo}
-					getEntityQueryPayload={getEntityQueryPayload}
-					category={category}
-					queryKey={`${queryKeyPrefix}Metrics`}
-				/>
-			)}
-			{effectiveView === VIEW_TYPES.LOGS && (
-				<EntityLogs
-					eventEntity={eventCategory}
-					queryKey={`${queryKeyPrefix}Logs`}
-					category={category}
-					initialExpression={logsAndTracesInitialExpression}
-				/>
-			)}
-			{effectiveView === VIEW_TYPES.TRACES && (
-				<EntityTraces
-					eventEntity={eventCategory}
-					queryKey={`${queryKeyPrefix}Traces`}
-					category={category}
-					initialExpression={logsAndTracesInitialExpression}
-				/>
-			)}
-			{effectiveView === VIEW_TYPES.EVENTS && tabVisibility.showEvents && (
-				<EntityEvents
-					eventEntity={eventCategory}
-					queryKey={`${queryKeyPrefix}Events`}
-					initialExpression={eventsInitialExpression}
-					category={category}
-				/>
-			)}
-			{customTabs?.map((tab) =>
-				selectedView === tab.key ? (
-					<Fragment key={tab.key}>
-						{tab.render({
-							entity,
-							timeRange,
-							selectedInterval,
-							handleTimeChange,
-						})}
-					</Fragment>
-				) : null,
-			)}
-		</>
-	);
-}

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

@@ -245,7 +245,6 @@ function K8sHeader<TData>({
 						showAutoRefresh={showAutoRefresh}
 						showRefreshText={false}
 						hideShareModal
-						defaultRelativeTime="30m"
 					/>
 				</div>
 

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityCountsSection/EntityCountsSection.tsx

@@ -52,6 +52,7 @@ export function EntityCountsSection<T>({
 			},
 		};
 
+		// TODO(H4ad): After https://github.com/SigNoz/signoz/pull/12038, inherit custom time of drawer to list
 		const urlParams = new URLSearchParams();
 		urlParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY, targetCategory);
 		urlParams.set(
@@ -59,44 +60,6 @@ export function EntityCountsSection<T>({
 			encodeURIComponent(JSON.stringify(compositeQuery)),
 		);
 
-		const currentSearchParams = new URLSearchParams(window.location.search);
-		const detailRelativeTime = currentSearchParams.get(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_RELATIVE_TIME,
-		);
-		const detailStartTime = currentSearchParams.get(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_START_TIME,
-		);
-		const detailEndTime = currentSearchParams.get(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_END_TIME,
-		);
-
-		const listRelativeTime = currentSearchParams.get(QueryParams.relativeTime);
-		const listStartTime = currentSearchParams.get(QueryParams.startTime);
-		const listEndTime = currentSearchParams.get(QueryParams.endTime);
-
-		if (listRelativeTime) {
-			urlParams.set(QueryParams.relativeTime, listRelativeTime);
-		} else if (listStartTime && listEndTime) {
-			urlParams.set(QueryParams.startTime, listStartTime);
-			urlParams.set(QueryParams.endTime, listEndTime);
-		}
-
-		if (detailRelativeTime) {
-			urlParams.set(
-				INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_RELATIVE_TIME,
-				detailRelativeTime,
-			);
-		} else if (detailStartTime && detailEndTime) {
-			urlParams.set(
-				INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_START_TIME,
-				detailStartTime,
-			);
-			urlParams.set(
-				INFRA_MONITORING_K8S_PARAMS_KEYS.DETAIL_END_TIME,
-				detailEndTime,
-			);
-		}
-
 		return `${ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES}?${urlParams.toString()}`;
 	};
 

frontend/src/container/InfraMonitoringK8sV2/Base/types.ts

@@ -1,17 +1,3 @@
-import { ReactNode } from 'react';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import APIError from 'types/api/error';
-
-import { EntityCountConfig } from './components/EntityCountsSection/EntityCountsSection';
-import { InfraMonitoringEntity } from '../constants';
-import { SelectedItemParams } from '../hooks';
-
-export type K8sDetailsCountConfig<T> = EntityCountConfig<T>;
-
 export type K8sBaseFilters = {
 	filter: {
 		expression: string;
@@ -47,100 +33,3 @@ export type K8sTableRowData<T> = T & {
 	/** Metadata about which attributes were used for grouping */
 	groupedByMeta?: Record<string, string>;
 };
-
-export interface K8sDetailsMetadataConfig<T> {
-	label: string;
-	getValue: (entity: T) => string | number;
-	render?: (value: string | number, entity: T) => ReactNode;
-}
-
-export interface K8sDetailsFilters {
-	filter: { expression: string };
-	start: number;
-	end: number;
-}
-
-export interface K8sDetailsWidgetInfo {
-	title: string;
-	yAxisUnit: string;
-}
-
-export type GetEntityQueryPayload<T> = (
-	entity: T,
-	start: number,
-	end: number,
-	dotMetricsEnabled: boolean,
-) => GetQueryResultsProps[];
-
-export interface K8sDetailsTabsConfig {
-	showMetrics?: boolean;
-	showLogs?: boolean;
-	showTraces?: boolean;
-	showEvents?: boolean;
-}
-
-export interface K8sDetailsCustomTabRenderProps<T> {
-	entity: T;
-	/** Time range in seconds — see useEntityDetailsTime */
-	timeRange: { startTime: number; endTime: number };
-	selectedInterval: Time;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-}
-
-export interface K8sDetailsCustomTab<T> {
-	key: string;
-	label: string;
-	icon: ReactNode;
-	render: (props: K8sDetailsCustomTabRenderProps<T>) => ReactNode;
-}
-
-export interface K8sBaseDetailsProps<T> {
-	category: InfraMonitoringEntity;
-	eventCategory: string;
-	// Data fetching configuration
-	getSelectedItemExpression: (params: SelectedItemParams) => string;
-	fetchEntityData: (
-		filters: K8sDetailsFilters,
-		signal?: AbortSignal,
-	) => Promise<{ data: T | null; error?: APIError | null }>;
-	// Entity configuration
-	getEntityName: (entity: T) => string;
-	getInitialLogTracesExpression: (entity: T) => string;
-	getInitialEventsExpression: (entity: T) => string;
-	metadataConfig: K8sDetailsMetadataConfig<T>[];
-	countsConfig?: K8sDetailsCountConfig<T>[];
-	getCountsFilterExpression?: (entity: T) => string;
-	entityWidgetInfo: K8sDetailsWidgetInfo[];
-	getEntityQueryPayload: GetEntityQueryPayload<T>;
-	queryKeyPrefix: string;
-	/** When true, only metrics are shown and the Metrics/Logs/Traces/Events tab bar is hidden. */
-	hideDetailViewTabs?: boolean;
-	tabsConfig?: K8sDetailsTabsConfig;
-	customTabs?: K8sDetailsCustomTab<T>[];
-}
-
-export interface K8sBaseDetailsContentProps<T> {
-	entity: T;
-	category: InfraMonitoringEntity;
-	eventCategory: string;
-	metadataConfig: K8sDetailsMetadataConfig<T>[];
-	countsConfig?: K8sDetailsCountConfig<T>[];
-	getCountsFilterExpression?: (entity: T) => string;
-	selectedItem: string | null;
-	handleClose: () => void;
-	entityWidgetInfo: K8sDetailsWidgetInfo[];
-	getEntityQueryPayload: GetEntityQueryPayload<T>;
-	queryKeyPrefix: string;
-	hideDetailViewTabs: boolean;
-	tabsConfig?: K8sDetailsTabsConfig;
-	customTabs?: K8sDetailsCustomTab<T>[];
-	logsAndTracesInitialExpression: string;
-	eventsInitialExpression: string;
-}
-
-// Aliases for backward compatibility
-export type CustomTab<T> = K8sDetailsCustomTab<T>;
-export type CustomTabRenderProps<T> = K8sDetailsCustomTabRenderProps<T>;

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityDateTimeSelector/EntityDateTimeSelector.tsx

@@ -1,78 +0,0 @@
-import { useCallback } from 'react';
-import { Undo } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
-import logEvent from 'api/common/logEvent';
-import { InfraMonitoringEvents } from 'constants/events';
-import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-
-import { useEntityDetailsTime } from './useEntityDetailsTime';
-
-interface EntityDateTimeSelectorProps {
-	eventEntity: string;
-	category: InfraMonitoringEntity;
-	view: string;
-}
-
-function EntityDateTimeSelector({
-	eventEntity,
-	category,
-	view,
-}: EntityDateTimeSelectorProps): JSX.Element {
-	const {
-		timeRange,
-		selectedInterval,
-		handleTimeChange,
-		handleResetToParentTime,
-		hasTimeChanged,
-	} = useEntityDetailsTime();
-
-	const onTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			void logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: eventEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category,
-				view,
-				interval,
-			});
-			handleTimeChange(interval, dateTimeRange);
-		},
-		[category, view, eventEntity, handleTimeChange],
-	);
-
-	return (
-		<div className="entity-date-time-selector">
-			{hasTimeChanged && (
-				<TooltipSimple title="Reset to list time" side="bottom">
-					<Button
-						variant="outlined"
-						color="secondary"
-						onClick={handleResetToParentTime}
-						data-testid="reset-to-list-time-button"
-						prefix={<Undo size={14} />}
-					>
-						Reset
-					</Button>
-				</TooltipSimple>
-			)}
-			<DateTimeSelectionV2
-				showAutoRefresh
-				showRefreshText={false}
-				hideShareModal
-				isModalTimeSelection
-				onTimeChange={onTimeChange}
-				modalSelectedInterval={selectedInterval}
-				modalInitialStartTime={timeRange.startTime * 1000}
-				modalInitialEndTime={timeRange.endTime * 1000}
-			/>
-		</div>
-	);
-}
-
-export default EntityDateTimeSelector;

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityDateTimeSelector/useEntityDetailsTime.ts

@@ -1,95 +0,0 @@
-import { useCallback, useMemo } from 'react';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import {
-	createCustomTimeRange,
-	isCustomTimeRange,
-	NANO_SECOND_MULTIPLIER,
-	useGlobalTime,
-} from 'store/globalTime';
-
-export interface EntityDetailsTimeRange {
-	/** Unix timestamp in seconds — the unit API payload builders expect. Multiply by 1000 for ms-based UI (modals, URL params). */
-	startTime: number;
-	/** Unix timestamp in seconds — the unit API payload builders expect. Multiply by 1000 for ms-based UI (modals, URL params). */
-	endTime: number;
-}
-
-export interface UseEntityDetailsTimeResult {
-	/** Time range in seconds */
-	timeRange: EntityDetailsTimeRange;
-	selectedInterval: Time;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-	handleResetToParentTime: () => boolean;
-	canResetToParent: boolean;
-	hasTimeChanged: boolean;
-}
-
-export function useEntityDetailsTime(): UseEntityDetailsTimeResult {
-	const selectedTime = useGlobalTime((s) => s.selectedTime);
-	const lastComputedMinMax = useGlobalTime((s) => s.lastComputedMinMax);
-	const setSelectedTime = useGlobalTime((s) => s.setSelectedTime);
-	const handleResetToParentTime = useGlobalTime((s) => s.resetToParentTime);
-	const parentStore = useGlobalTime((s) => s.parentStore);
-
-	const canResetToParent = !!parentStore;
-
-	const hasTimeChanged = useMemo(() => {
-		if (!parentStore) {
-			return false;
-		}
-		return selectedTime !== parentStore.getState().selectedTime;
-	}, [parentStore, selectedTime]);
-
-	const timeRange = useMemo<EntityDetailsTimeRange>(
-		() => ({
-			startTime: Math.floor(
-				lastComputedMinMax.minTime / NANO_SECOND_MULTIPLIER / 1000,
-			),
-			endTime: Math.floor(
-				lastComputedMinMax.maxTime / NANO_SECOND_MULTIPLIER / 1000,
-			),
-		}),
-		[lastComputedMinMax],
-	);
-
-	const selectedInterval = useMemo<Time>(
-		() =>
-			isCustomTimeRange(selectedTime)
-				? ('custom' as Time)
-				: (selectedTime as Time),
-		[selectedTime],
-	);
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			if (interval === 'custom' && dateTimeRange) {
-				// DateTimeSelector delivers milliseconds; the store keys custom
-				// ranges by nanoseconds.
-				setSelectedTime(
-					createCustomTimeRange(
-						dateTimeRange[0] * NANO_SECOND_MULTIPLIER,
-						dateTimeRange[1] * NANO_SECOND_MULTIPLIER,
-					),
-				);
-			} else {
-				setSelectedTime(interval as Time);
-			}
-		},
-		[setSelectedTime],
-	);
-
-	return {
-		timeRange,
-		selectedInterval,
-		handleTimeChange,
-		handleResetToParentTime,
-		canResetToParent,
-		hasTimeChanged,
-	};
-}

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityEvents/EntityEvents.tsx

@@ -21,14 +21,17 @@ import Controls from 'container/Controls';
 import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
 import LoadingContainer from 'container/InfraMonitoringK8sV2/LoadingContainer';
 import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
 import { ChevronDown, ChevronRight } from '@signozhq/icons';
 import { useQueryState } from 'nuqs';
 import { DataSource } from 'types/common/queryBuilder';
 import { parseAsJsonNoValidate } from 'utils/nuqsParsers';
 import { validateQuery } from 'utils/queryValidationUtils';
 
-import EntityDateTimeSelector from '../EntityDateTimeSelector/EntityDateTimeSelector';
-import { useEntityDetailsTime } from '../EntityDateTimeSelector/useEntityDetailsTime';
 import EntityEmptyState from '../EntityEmptyState/EntityEmptyState';
 import EntityError from '../EntityError/EntityError';
 import { EventContents } from './EventsContent';
@@ -50,7 +53,16 @@ interface EventDataType {
 }
 
 interface Props {
-	eventEntity: string;
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
 	queryKey: string;
 	category: InfraMonitoringEntity;
 	initialExpression: string;
@@ -65,11 +77,13 @@ const handleExpandRow = (record: EventDataType): JSX.Element => (
 );
 
 function EntityEventsContent({
-	eventEntity,
+	timeRange,
+	isModalTimeSelection,
+	handleTimeChange,
+	selectedInterval,
 	queryKey,
 	category,
 }: Omit<Props, 'initialExpression'>): JSX.Element {
-	const { timeRange } = useEntityDetailsTime();
 	const expression = useExpression();
 	const inputExpression = useInputExpression();
 	const userExpression = useUserExpression();
@@ -117,8 +131,8 @@ function EntityEventsContent({
 			if (validation.isValid) {
 				querySearchOnRun(newUserExpression || '');
 
-				void logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: eventEntity,
+				logEvent(InfraMonitoringEvents.FilterApplied, {
+					entity: InfraMonitoringEvents.K8sEntity,
 					page: InfraMonitoringEvents.DetailedPage,
 					category,
 					view: InfraMonitoringEvents.EventsView,
@@ -127,14 +141,7 @@ function EntityEventsContent({
 				refetch();
 			}
 		},
-		[
-			inputExpression,
-			initialExpression,
-			refetch,
-			querySearchOnRun,
-			category,
-			eventEntity,
-		],
+		[inputExpression, initialExpression, refetch, querySearchOnRun, category],
 	);
 
 	const queryData = useMemo(
@@ -222,10 +229,16 @@ function EntityEventsContent({
 		<div className={styles.container}>
 			<div className={styles.filterContainer}>
 				<div className={styles.filterContainerTime}>
-					<EntityDateTimeSelector
-						eventEntity={eventEntity}
-						category={category}
-						view={InfraMonitoringEvents.EventsView}
+					<DateTimeSelectionV2
+						showAutoRefresh
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+						modalInitialStartTime={timeRange.startTime * 1000}
+						modalInitialEndTime={timeRange.endTime * 1000}
 					/>
 
 					<RunQueryBtn

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityEvents/__tests__/EntityEvents.test.tsx

@@ -29,25 +29,25 @@ function verifyEntityEventsV5Request({
 	expect(orderKeys).toContain('timestamp');
 }
 
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
+jest.mock('container/TopNav/DateTimeSelectionV2/index.tsx', () => ({
 	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
+	default: ({
+		onTimeChange,
+	}: {
+		onTimeChange?: (interval: string, dateTimeRange?: [number, number]) => void;
+	}): JSX.Element => (
+		<button
+			type="button"
+			data-testid="mock-datetime-selection"
+			onClick={(): void => {
+				onTimeChange?.('5m');
+			}}
+		>
+			Select Time
+		</button>
 	),
 }));
 
-jest.mock('../../EntityDateTimeSelector/useEntityDetailsTime', () => ({
-	useEntityDetailsTime: (): {
-		timeRange: { startTime: number; endTime: number };
-		selectedInterval: string;
-		handleTimeChange: jest.Mock;
-	} => ({
-		timeRange: { startTime: 1, endTime: 2 },
-		selectedInterval: '5m',
-		handleTimeChange: jest.fn(),
-	}),
-}));
-
 describe('EntityEvents', () => {
 	let capturedQueryRangePayloads: QueryRangePayloadV5[] = [];
 
@@ -69,7 +69,10 @@ describe('EntityEvents', () => {
 					searchParams={`${K8S_ENTITY_EVENTS_EXPRESSION_KEY}=k8s.pod.name+%3D+%22x%22`}
 				>
 					<EntityEvents
-						eventEntity="test"
+						timeRange={{ startTime: 1, endTime: 2 }}
+						isModalTimeSelection={false}
+						handleTimeChange={jest.fn()}
+						selectedInterval="5m"
 						queryKey="test"
 						category={InfraMonitoringEntity.PODS}
 						initialExpression='k8s.pod.name = "x"'

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityEvents/__tests__/EntityEvents.timeRange.test.tsx

@@ -1,81 +0,0 @@
-import { mockFieldsAPIsWithEmptyResponse } from '__tests__/fields_api.util';
-import { mockQueryRangeV5WithEventsResponse } from '__tests__/query_range_v5.util';
-import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import {
-	createCustomTimeRange,
-	createGlobalTimeStore,
-	GlobalTimeContext,
-	NANO_SECOND_MULTIPLIER,
-} from 'store/globalTime';
-import { act, render, waitFor } from 'tests/test-utils';
-import { QueryRangePayloadV5 } from 'types/api/v5/queryRange';
-
-import EntityEvents from '../EntityEvents';
-import { K8S_ENTITY_EVENTS_EXPRESSION_KEY } from '../hooks';
-
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
-	),
-}));
-
-const START_MS = 1705315200000; // 2024-01-15T10:40:00Z
-const END_MS = 1705318800000; // 2024-01-15T11:40:00Z
-
-describe('EntityEvents time range wiring', () => {
-	let capturedPayloads: QueryRangePayloadV5[] = [];
-
-	beforeEach(() => {
-		capturedPayloads = [];
-		mockQueryRangeV5WithEventsResponse({
-			onReceiveRequest: async (req) => {
-				const body = (await req.json()) as QueryRangePayloadV5;
-				capturedPayloads.push(body);
-				return {};
-			},
-		});
-		mockFieldsAPIsWithEmptyResponse();
-	});
-
-	it('should query the V5 API with the global time range converted to milliseconds', async () => {
-		const store = createGlobalTimeStore();
-		store
-			.getState()
-			.setSelectedTime(
-				createCustomTimeRange(
-					START_MS * NANO_SECOND_MULTIPLIER,
-					END_MS * NANO_SECOND_MULTIPLIER,
-				),
-			);
-
-		const expression = 'k8s.pod.name = "test-pod"';
-
-		act(() => {
-			render(
-				<GlobalTimeContext.Provider value={store}>
-					<NuqsTestingAdapter
-						searchParams={`${K8S_ENTITY_EVENTS_EXPRESSION_KEY}=${encodeURIComponent(
-							expression,
-						)}`}
-					>
-						<EntityEvents
-							eventEntity="test"
-							queryKey="test"
-							category={InfraMonitoringEntity.PODS}
-							initialExpression={expression}
-						/>
-					</NuqsTestingAdapter>
-				</GlobalTimeContext.Provider>,
-			);
-		});
-
-		await waitFor(() => {
-			expect(capturedPayloads).toHaveLength(1);
-		});
-
-		expect(capturedPayloads[0].start).toBe(START_MS);
-		expect(capturedPayloads[0].end).toBe(END_MS);
-	});
-});

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityLogs/EntityLogs.tsx

@@ -25,6 +25,11 @@ import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants'
 import { LogsLoading } from 'container/LogsLoading/LogsLoading';
 import { FontSize } from 'container/OptionsMenu/types';
 import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
 import { getOldLogsOperatorFromNew } from 'hooks/logs/useActiveLog';
 import useLogDetailHandlers from 'hooks/logs/useLogDetailHandlers';
 import useScrollToLog from 'hooks/logs/useScrollToLog';
@@ -33,8 +38,6 @@ import { ILog } from 'types/api/logs/log';
 import { DataSource } from 'types/common/queryBuilder';
 import { validateQuery } from 'utils/queryValidationUtils';
 
-import EntityDateTimeSelector from '../EntityDateTimeSelector/EntityDateTimeSelector';
-import { useEntityDetailsTime } from '../EntityDateTimeSelector/useEntityDetailsTime';
 import EntityEmptyState from '../EntityEmptyState/EntityEmptyState';
 import EntityError from '../EntityError/EntityError';
 import { isKeyNotFoundError } from '../utils';
@@ -44,18 +47,29 @@ import { getEntityLogsQueryPayload } from './utils';
 import styles from './EntityLogs.module.scss';
 
 interface Props {
-	eventEntity: string;
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
 	queryKey: string;
 	category: InfraMonitoringEntity;
 	initialExpression: string;
 }
 
 function EntityLogsContent({
-	eventEntity,
+	timeRange,
+	isModalTimeSelection,
+	handleTimeChange,
+	selectedInterval,
 	queryKey,
 	category,
 }: Omit<Props, 'initialExpression'>): JSX.Element {
-	const { timeRange } = useEntityDetailsTime();
 	const virtuosoRef = useRef<VirtuosoHandle>(null);
 
 	const expression = useExpression();
@@ -120,7 +134,7 @@ function EntityLogsContent({
 			if (validation.isValid) {
 				querySearchOnRun(newUserExpression);
 
-				void logEvent(InfraMonitoringEvents.FilterApplied, {
+				logEvent(InfraMonitoringEvents.FilterApplied, {
 					entity: InfraMonitoringEvents.K8sEntity,
 					page: InfraMonitoringEvents.DetailedPage,
 					category,
@@ -225,10 +239,16 @@ function EntityLogsContent({
 		<div className={styles.container}>
 			<div className={styles.filterContainer}>
 				<div className={styles.filterContainerTime}>
-					<EntityDateTimeSelector
-						eventEntity={eventEntity}
-						category={category}
-						view={InfraMonitoringEvents.LogsView}
+					<DateTimeSelectionV2
+						showAutoRefresh
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+						modalInitialStartTime={timeRange.startTime * 1000}
+						modalInitialEndTime={timeRange.endTime * 1000}
 					/>
 
 					<RunQueryBtn

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityLogs/__tests__/EntityLogs.test.tsx

@@ -50,25 +50,25 @@ jest.mock(
 		},
 );
 
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
+jest.mock('container/TopNav/DateTimeSelectionV2/index.tsx', () => ({
 	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
+	default: ({
+		onTimeChange,
+	}: {
+		onTimeChange?: (interval: string, dateTimeRange?: [number, number]) => void;
+	}): JSX.Element => (
+		<button
+			type="button"
+			data-testid="mock-datetime-selection"
+			onClick={(): void => {
+				onTimeChange?.('5m');
+			}}
+		>
+			Select Time
+		</button>
 	),
 }));
 
-jest.mock('../../EntityDateTimeSelector/useEntityDetailsTime', () => ({
-	useEntityDetailsTime: (): {
-		timeRange: { startTime: number; endTime: number };
-		selectedInterval: string;
-		handleTimeChange: jest.Mock;
-	} => ({
-		timeRange: { startTime: 1, endTime: 2 },
-		selectedInterval: '5m',
-		handleTimeChange: jest.fn(),
-	}),
-}));
-
 describe('EntityLogs', () => {
 	let capturedQueryRangePayloads: QueryRangePayloadV5[] = [];
 	const itemHeight = 100;
@@ -94,7 +94,10 @@ describe('EntityLogs', () => {
 				>
 					<VirtuosoMockContext.Provider value={{ viewportHeight: 500, itemHeight }}>
 						<EntityLogs
-							eventEntity="test"
+							timeRange={{ startTime: 1, endTime: 2 }}
+							isModalTimeSelection={false}
+							handleTimeChange={jest.fn()}
+							selectedInterval="5m"
 							queryKey="test"
 							category={InfraMonitoringEntity.PODS}
 							initialExpression='k8s.pod.name = "x"'

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityLogs/__tests__/EntityLogs.timeRange.test.tsx

@@ -1,93 +0,0 @@
-import { mockFieldsAPIsWithEmptyResponse } from '__tests__/fields_api.util';
-import { mockQueryRangeV5WithLogsResponse } from '__tests__/query_range_v5.util';
-import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import {
-	createCustomTimeRange,
-	createGlobalTimeStore,
-	GlobalTimeContext,
-	NANO_SECOND_MULTIPLIER,
-} from 'store/globalTime';
-import { act, render, waitFor } from 'tests/test-utils';
-import { QueryRangePayloadV5 } from 'types/api/v5/queryRange';
-
-import EntityLogs from '../EntityLogs';
-import { K8S_ENTITY_LOGS_EXPRESSION_KEY } from '../hooks';
-
-jest.mock(
-	'components/OverlayScrollbar/OverlayScrollbar',
-	() =>
-		function MockOverlayScrollbar({
-			children,
-		}: {
-			children: React.ReactNode;
-		}): JSX.Element {
-			return <div>{children}</div>;
-		},
-);
-
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
-	),
-}));
-
-const START_MS = 1705315200000; // 2024-01-15T10:40:00Z
-const END_MS = 1705318800000; // 2024-01-15T11:40:00Z
-
-describe('EntityLogs time range wiring', () => {
-	let capturedPayloads: QueryRangePayloadV5[] = [];
-
-	beforeEach(() => {
-		capturedPayloads = [];
-		mockQueryRangeV5WithLogsResponse({
-			onReceiveRequest: async (req) => {
-				const body = (await req.json()) as QueryRangePayloadV5;
-				capturedPayloads.push(body);
-				return {};
-			},
-		});
-		mockFieldsAPIsWithEmptyResponse();
-	});
-
-	it('should query the V5 API with the global time range converted to milliseconds', async () => {
-		const store = createGlobalTimeStore();
-		store
-			.getState()
-			.setSelectedTime(
-				createCustomTimeRange(
-					START_MS * NANO_SECOND_MULTIPLIER,
-					END_MS * NANO_SECOND_MULTIPLIER,
-				),
-			);
-
-		const expression = 'k8s.pod.name = "test-pod"';
-
-		act(() => {
-			render(
-				<GlobalTimeContext.Provider value={store}>
-					<NuqsTestingAdapter
-						searchParams={`${K8S_ENTITY_LOGS_EXPRESSION_KEY}=${encodeURIComponent(
-							expression,
-						)}`}
-					>
-						<EntityLogs
-							eventEntity="test"
-							queryKey="test"
-							category={InfraMonitoringEntity.PODS}
-							initialExpression={expression}
-						/>
-					</NuqsTestingAdapter>
-				</GlobalTimeContext.Provider>,
-			);
-		});
-
-		await waitFor(() => {
-			expect(capturedPayloads.length).toBeGreaterThanOrEqual(1);
-		});
-
-		expect(capturedPayloads[0].start).toBe(START_MS);
-		expect(capturedPayloads[0].end).toBe(END_MS);
-	});
-});

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

@@ -2,11 +2,15 @@ import { useCallback, useMemo, useRef } from 'react';
 import { UseQueryResult } from 'react-query';
 import { Skeleton } from 'antd';
 import cx from 'classnames';
-import { InfraMonitoringEvents } from 'constants/events';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import TimeSeries from 'container/DashboardContainer/visualization/charts/TimeSeries/TimeSeries';
 import { LegendPosition } from 'lib/uPlotV2/components/types';
 import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useResizeObserver } from 'hooks/useDimensions';
@@ -20,17 +24,25 @@ import { getMetricsExplorerUrl } from 'utils/explorerUtils';
 import { buildEntityMetricsChartConfig } from './configBuilder';
 import ChartHeader from './ChartHeader';
 
-import EntityDateTimeSelector from '../EntityDateTimeSelector/EntityDateTimeSelector';
-import { useEntityDetailsTime } from '../EntityDateTimeSelector/useEntityDetailsTime';
 import { useEntityMetrics } from './hooks';
 import { isKeyNotFoundError } from '../utils';
 
 import styles from './EntityMetrics.module.scss';
 import { MetricsTable } from './MetricsTable';
+import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
 
 interface EntityMetricsProps<T> {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
 	entity: T;
-	eventEntity: string;
 	entityWidgetInfo: {
 		title: string;
 		yAxisUnit: string;
@@ -47,16 +59,16 @@ interface EntityMetricsProps<T> {
 }
 
 function EntityMetrics<T>({
+	selectedInterval,
 	entity,
-	eventEntity,
+	timeRange,
+	handleTimeChange,
+	isModalTimeSelection,
 	entityWidgetInfo,
 	getEntityQueryPayload,
 	queryKey,
 	category,
 }: EntityMetricsProps<T>): JSX.Element {
-	const { timeRange, selectedInterval, handleTimeChange } =
-		useEntityDetailsTime();
-
 	const { visibilities, setElement } = useMultiIntersectionObserver(
 		entityWidgetInfo.length,
 		{ threshold: 0.1 },
@@ -79,8 +91,10 @@ function EntityMetrics<T>({
 
 	const onDragSelect = useCallback(
 		(start: number, end: number): void => {
-			// UPlotConfigBuilder's setSelect hook already delivers milliseconds
-			handleTimeChange('custom', [Math.trunc(start), Math.trunc(end)]);
+			const startTimestamp = Math.trunc(start);
+			const endTimestamp = Math.trunc(end);
+
+			handleTimeChange('custom', [startTimestamp, endTimestamp]);
 		},
 		[handleTimeChange],
 	);
@@ -174,10 +188,16 @@ function EntityMetrics<T>({
 	return (
 		<>
 			<div className={styles.metricsHeader}>
-				<EntityDateTimeSelector
-					eventEntity={eventEntity}
-					category={category}
-					view={InfraMonitoringEvents.MetricsView}
+				<DateTimeSelectionV2
+					showAutoRefresh
+					showRefreshText={false}
+					hideShareModal
+					onTimeChange={handleTimeChange}
+					defaultRelativeTime={DEFAULT_TIME_RANGE}
+					isModalTimeSelection={isModalTimeSelection}
+					modalSelectedInterval={selectedInterval}
+					modalInitialStartTime={timeRange.startTime * 1000}
+					modalInitialEndTime={timeRange.endTime * 1000}
 				/>
 			</div>
 			<div className={styles.entityMetricsContainer}>

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityMetrics/__tests__/EntityMetrics.test.tsx

@@ -1,6 +1,7 @@
 import { render, screen } from '@testing-library/react';
 import { MemoryRouter } from 'react-router-dom';
 import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
+import { Time } from 'container/TopNav/DateTimeSelectionV2/types';
 import * as appContextHooks from 'providers/App/App';
 import { LicenseEvent } from 'types/api/licensesV3/getActive';
 import uPlot from 'uplot';
@@ -27,28 +28,13 @@ jest.mock('lib/uPlotV2/utils/dataUtils', () => ({
 	hasSingleVisiblePoint: jest.fn().mockReturnValue(false),
 }));
 
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
+jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
 	__esModule: true,
 	default: (): JSX.Element => (
 		<div data-testid="date-time-selection">Date Time</div>
 	),
 }));
 
-const mockTimeRange = { startTime: 1705315200, endTime: 1705318800 };
-let mockSelectedInterval = '5m';
-
-jest.mock('../../EntityDateTimeSelector/useEntityDetailsTime', () => ({
-	useEntityDetailsTime: (): {
-		timeRange: { startTime: number; endTime: number };
-		selectedInterval: string;
-		handleTimeChange: jest.Mock;
-	} => ({
-		timeRange: mockTimeRange,
-		selectedInterval: mockSelectedInterval,
-		handleTimeChange: jest.fn(),
-	}),
-}));
-
 jest.mock(
 	'container/DashboardContainer/visualization/charts/TimeSeries/TimeSeries',
 	() => ({
@@ -158,6 +144,13 @@ const mockGetEntityQueryPayload = jest.fn().mockReturnValue([
 	},
 ]);
 
+const mockTimeRange = {
+	startTime: 1705315200,
+	endTime: 1705318800,
+};
+
+const mockHandleTimeChange = jest.fn();
+
 const mockQueries = [
 	{
 		data: {
@@ -290,6 +283,10 @@ const mockEmptyQueries = [
 
 const renderEntityMetrics = (overrides = {}): any => {
 	const defaultProps = {
+		timeRange: mockTimeRange,
+		isModalTimeSelection: false,
+		handleTimeChange: mockHandleTimeChange,
+		selectedInterval: '5m' as Time,
 		entity: mockEntity,
 		entityWidgetInfo: mockEntityWidgetInfo,
 		getEntityQueryPayload: mockGetEntityQueryPayload,
@@ -301,8 +298,11 @@ const renderEntityMetrics = (overrides = {}): any => {
 	return render(
 		<MemoryRouter>
 			<EntityMetrics
+				timeRange={defaultProps.timeRange}
+				isModalTimeSelection={defaultProps.isModalTimeSelection}
+				handleTimeChange={defaultProps.handleTimeChange}
+				selectedInterval={defaultProps.selectedInterval}
 				entity={defaultProps.entity}
-				eventEntity="test"
 				entityWidgetInfo={defaultProps.entityWidgetInfo}
 				getEntityQueryPayload={defaultProps.getEntityQueryPayload}
 				queryKey={defaultProps.queryKey}
@@ -344,7 +344,6 @@ const mockQueryPayloads = [
 describe('EntityMetrics', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
-		mockSelectedInterval = '5m';
 		mockUseEntityMetrics.mockReturnValue({
 			queries: mockQueries as any,
 			chartData: mockChartData,
@@ -455,8 +454,7 @@ describe('EntityMetrics', () => {
 	});
 
 	it('builds metrics explorer link with relativeTime when a relative interval is selected', () => {
-		mockSelectedInterval = '5m';
-		renderEntityMetrics();
+		renderEntityMetrics({ selectedInterval: '5m' as Time });
 		const href = screen
 			.getByTestId('open-metrics-explorer-0')
 			.getAttribute('href');
@@ -466,8 +464,7 @@ describe('EntityMetrics', () => {
 	});
 
 	it('builds metrics explorer link with absolute time range in milliseconds for custom interval', () => {
-		mockSelectedInterval = 'custom';
-		renderEntityMetrics();
+		renderEntityMetrics({ selectedInterval: 'custom' as Time });
 		const href = screen
 			.getByTestId('open-metrics-explorer-0')
 			.getAttribute('href');
@@ -481,6 +478,7 @@ describe('EntityMetrics', () => {
 		expect(mockUseEntityMetrics).toHaveBeenCalledWith(
 			expect.objectContaining({
 				queryKey: 'test-query-key',
+				timeRange: mockTimeRange,
 				entity: mockEntity,
 				category: InfraMonitoringEntity.PODS,
 			}),

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityMetrics/__tests__/EntityMetrics.timeRange.test.tsx

@@ -1,119 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import {
-	createCustomTimeRange,
-	createGlobalTimeStore,
-	GlobalTimeContext,
-	GlobalTimeStoreApi,
-	NANO_SECOND_MULTIPLIER,
-} from 'store/globalTime';
-import { act, render } from 'tests/test-utils';
-
-import { buildEntityMetricsChartConfig } from '../configBuilder';
-import EntityMetrics from '../EntityMetrics';
-
-jest.mock('../configBuilder', () => ({
-	buildEntityMetricsChartConfig: jest.fn().mockReturnValue({
-		getId: jest.fn().mockReturnValue('mock-id'),
-	}),
-}));
-
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="date-time-selection">Date Time</div>
-	),
-}));
-
-const mockBuildChartConfig = buildEntityMetricsChartConfig as jest.Mock;
-
-const START_MS = 1705315200000; // 2024-01-15T10:40:00Z
-const END_MS = 1705318800000; // 2024-01-15T11:40:00Z
-const START_SECONDS = 1705315200;
-const END_SECONDS = 1705318800;
-
-const entity = { id: 'test-entity-1' };
-
-// The jsdom IntersectionObserver polyfill never reports visibility, so the
-// queries stay disabled and no network request is issued.
-const queryPayload = {
-	graphType: PANEL_TYPES.TIME_SERIES,
-} as unknown as GetQueryResultsProps;
-
-function createStoreWithCustomRange(): GlobalTimeStoreApi {
-	const store = createGlobalTimeStore();
-	store
-		.getState()
-		.setSelectedTime(
-			createCustomTimeRange(
-				START_MS * NANO_SECOND_MULTIPLIER,
-				END_MS * NANO_SECOND_MULTIPLIER,
-			),
-		);
-	return store;
-}
-
-function renderEntityMetrics(store: GlobalTimeStoreApi): jest.Mock {
-	const getEntityQueryPayload = jest.fn().mockReturnValue([queryPayload]);
-	render(
-		<GlobalTimeContext.Provider value={store}>
-			<EntityMetrics
-				entity={entity}
-				eventEntity="test"
-				entityWidgetInfo={[{ title: 'CPU Usage', yAxisUnit: 'percentage' }]}
-				getEntityQueryPayload={getEntityQueryPayload}
-				queryKey="test-query-key"
-				category={InfraMonitoringEntity.PODS}
-			/>
-		</GlobalTimeContext.Provider>,
-	);
-	return getEntityQueryPayload;
-}
-
-describe('EntityMetrics time range wiring', () => {
-	beforeEach(() => {
-		mockBuildChartConfig.mockClear();
-	});
-
-	it('should build the metrics query payloads and chart config from the global time range in seconds', () => {
-		const store = createStoreWithCustomRange();
-
-		const getEntityQueryPayload = renderEntityMetrics(store);
-
-		expect(getEntityQueryPayload).toHaveBeenCalledWith(
-			entity,
-			START_SECONDS,
-			END_SECONDS,
-			false,
-		);
-		expect(mockBuildChartConfig).toHaveBeenCalledWith(
-			expect.objectContaining({
-				minTimeScale: START_SECONDS,
-				maxTimeScale: END_SECONDS,
-			}),
-		);
-	});
-
-	it('should store a drag selection (received in milliseconds) as the equivalent custom range', () => {
-		const store = createStoreWithCustomRange();
-
-		renderEntityMetrics(store);
-
-		const { onDragSelect } = mockBuildChartConfig.mock.calls[0][0];
-
-		// UPlotConfigBuilder's setSelect hook calls onDragSelect with milliseconds
-		const dragStartMs = 1705316000000;
-		const dragEndMs = 1705317000000;
-		act(() => {
-			onDragSelect(dragStartMs, dragEndMs);
-		});
-
-		expect(store.getState().selectedTime).toBe(
-			createCustomTimeRange(
-				dragStartMs * NANO_SECOND_MULTIPLIER,
-				dragEndMs * NANO_SECOND_MULTIPLIER,
-			),
-		);
-	});
-});

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityTraces/EntityTraces.tsx

@@ -20,6 +20,11 @@ import { InfraMonitoringEvents } from 'constants/events';
 import Controls from 'container/Controls';
 import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
 import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
 import { PER_PAGE_OPTIONS } from 'container/TracesExplorer/ListView/configs';
 import { TracesLoading } from 'container/TracesExplorer/TraceLoading/TraceLoading';
 import { useQueryState } from 'nuqs';
@@ -27,11 +32,10 @@ import { DataSource } from 'types/common/queryBuilder';
 import { parseAsJsonNoValidate } from 'utils/nuqsParsers';
 import { validateQuery } from 'utils/queryValidationUtils';
 
-import EntityDateTimeSelector from '../EntityDateTimeSelector/EntityDateTimeSelector';
-import { useEntityDetailsTime } from '../EntityDateTimeSelector/useEntityDetailsTime';
 import EntityEmptyState from '../EntityEmptyState/EntityEmptyState';
 import EntityError from '../EntityError/EntityError';
-import { isKeyNotFoundError, selectedEntityTracesColumns } from '../utils';
+import { selectedEntityTracesColumns } from '../utils';
+import { isKeyNotFoundError } from '../utils';
 import { K8S_ENTITY_TRACES_EXPRESSION_KEY, useEntityTraces } from './hooks';
 import { getTraceListColumns } from './traceListColumns';
 import { getEntityTracesQueryPayload } from './utils';
@@ -40,18 +44,29 @@ import styles from './EntityTraces.module.scss';
 import { useTimezone } from 'providers/Timezone';
 
 interface Props {
-	eventEntity: string;
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
 	queryKey: string;
 	category: InfraMonitoringEntity;
 	initialExpression: string;
 }
 
 function EntityTracesContent({
-	eventEntity,
+	timeRange,
+	isModalTimeSelection,
+	handleTimeChange,
+	selectedInterval,
 	queryKey,
 	category,
 }: Omit<Props, 'initialExpression'>): JSX.Element {
-	const { timeRange } = useEntityDetailsTime();
 	const expression = useExpression();
 	const inputExpression = useInputExpression();
 	const userExpression = useUserExpression();
@@ -99,8 +114,8 @@ function EntityTracesContent({
 			if (validation.isValid) {
 				querySearchOnRun(newUserExpression || '');
 
-				void logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: eventEntity,
+				logEvent(InfraMonitoringEvents.FilterApplied, {
+					entity: InfraMonitoringEvents.K8sEntity,
 					page: InfraMonitoringEvents.DetailedPage,
 					category,
 					view: InfraMonitoringEvents.TracesView,
@@ -109,14 +124,7 @@ function EntityTracesContent({
 				refetch();
 			}
 		},
-		[
-			inputExpression,
-			initialExpression,
-			refetch,
-			querySearchOnRun,
-			category,
-			eventEntity,
-		],
+		[inputExpression, initialExpression, refetch, querySearchOnRun, category],
 	);
 
 	const queryData = useMemo(
@@ -144,7 +152,7 @@ function EntityTracesContent({
 	const hasAdditionalFilters = !!userExpression?.trim();
 
 	const handleRowClick = useCallback(() => {
-		void logEvent(InfraMonitoringEvents.ItemClicked, {
+		logEvent(InfraMonitoringEvents.ItemClicked, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			category,
 			view: InfraMonitoringEvents.TracesView,
@@ -161,10 +169,16 @@ function EntityTracesContent({
 		<div className={styles.container}>
 			<div className={styles.filterContainer}>
 				<div className={styles.filterContainerTime}>
-					<EntityDateTimeSelector
-						eventEntity={eventEntity}
-						category={category}
-						view={InfraMonitoringEvents.TracesView}
+					<DateTimeSelectionV2
+						showAutoRefresh
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+						modalInitialStartTime={timeRange.startTime * 1000}
+						modalInitialEndTime={timeRange.endTime * 1000}
 					/>
 
 					<RunQueryBtn

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityTraces/__tests__/EntityTraces.default.test.tsx

@@ -34,8 +34,10 @@ describe('EntityTraces - Default Behavior', () => {
 	});
 
 	it('should pass time range to API (converted to milliseconds)', async () => {
+		const timeRange = { startTime: 1000, endTime: 2000 };
+
 		act(() => {
-			renderEntityTraces();
+			renderEntityTraces({ timeRange });
 		});
 
 		await waitFor(() => {
@@ -45,8 +47,8 @@ describe('EntityTraces - Default Behavior', () => {
 		verifyQueryPayload({
 			payload: capturedPayloads[0],
 			expectedTimeRange: {
-				start: 1 * 1000,
-				end: 2 * 1000,
+				start: timeRange.startTime * 1000,
+				end: timeRange.endTime * 1000,
 			},
 		});
 	});

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityTraces/__tests__/EntityTraces.timeRange.test.tsx

@@ -1,81 +0,0 @@
-import { mockFieldsAPIsWithEmptyResponse } from '__tests__/fields_api.util';
-import { mockQueryRangeV5WithTracesResponse } from '__tests__/query_range_v5.util';
-import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import {
-	createCustomTimeRange,
-	createGlobalTimeStore,
-	GlobalTimeContext,
-	NANO_SECOND_MULTIPLIER,
-} from 'store/globalTime';
-import { act, render, waitFor } from 'tests/test-utils';
-import { QueryRangePayloadV5 } from 'types/api/v5/queryRange';
-
-import EntityTraces from '../EntityTraces';
-import { K8S_ENTITY_TRACES_EXPRESSION_KEY } from '../hooks';
-
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
-	),
-}));
-
-const START_MS = 1705315200000; // 2024-01-15T10:40:00Z
-const END_MS = 1705318800000; // 2024-01-15T11:40:00Z
-
-describe('EntityTraces time range wiring', () => {
-	let capturedPayloads: QueryRangePayloadV5[] = [];
-
-	beforeEach(() => {
-		capturedPayloads = [];
-		mockQueryRangeV5WithTracesResponse({
-			onReceiveRequest: async (req) => {
-				const body = (await req.json()) as QueryRangePayloadV5;
-				capturedPayloads.push(body);
-				return {};
-			},
-		});
-		mockFieldsAPIsWithEmptyResponse();
-	});
-
-	it('should query the V5 API with the global time range converted to milliseconds', async () => {
-		const store = createGlobalTimeStore();
-		store
-			.getState()
-			.setSelectedTime(
-				createCustomTimeRange(
-					START_MS * NANO_SECOND_MULTIPLIER,
-					END_MS * NANO_SECOND_MULTIPLIER,
-				),
-			);
-
-		const expression = 'k8s.pod.name = "test-pod"';
-
-		act(() => {
-			render(
-				<GlobalTimeContext.Provider value={store}>
-					<NuqsTestingAdapter
-						searchParams={`${K8S_ENTITY_TRACES_EXPRESSION_KEY}=${encodeURIComponent(
-							expression,
-						)}`}
-					>
-						<EntityTraces
-							eventEntity="test"
-							queryKey="test"
-							category={InfraMonitoringEntity.PODS}
-							initialExpression={expression}
-						/>
-					</NuqsTestingAdapter>
-				</GlobalTimeContext.Provider>,
-			);
-		});
-
-		await waitFor(() => {
-			expect(capturedPayloads).toHaveLength(1);
-		});
-
-		expect(capturedPayloads[0].start).toBe(START_MS);
-		expect(capturedPayloads[0].end).toBe(END_MS);
-	});
-});

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityTraces/__tests__/testUtils.tsx

@@ -1,5 +1,7 @@
-import { mockFieldsAPIsWithEmptyResponse } from '__tests__/fields_api.util';
+import { ENVIRONMENT } from 'constants/env';
 import { InfraMonitoringEntity } from 'container/InfraMonitoringK8sV2/constants';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
 import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
 import { render, RenderResult } from 'tests/test-utils';
 import { QueryRangePayloadV5 } from 'types/api/v5/queryRange';
@@ -7,19 +9,39 @@ import { QueryRangePayloadV5 } from 'types/api/v5/queryRange';
 import EntityTraces from '../EntityTraces';
 import { K8S_ENTITY_TRACES_EXPRESSION_KEY } from '../hooks';
 
+// QuerySearch fires autocomplete requests on mount; without handlers MSW
+// passes them through to the real network and the resulting AxiosError fails
+// whichever test happens to be running.
 beforeEach(() => {
-	mockFieldsAPIsWithEmptyResponse();
+	server.use(
+		rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/keys`, (_, res, ctx) =>
+			res(
+				ctx.status(200),
+				ctx.json({ status: 'success', data: { keys: {}, complete: true } }),
+			),
+		),
+		rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/values`, (_, res, ctx) =>
+			res(
+				ctx.status(200),
+				ctx.json({ status: 'success', data: { values: {}, complete: true } }),
+			),
+		),
+	);
 });
 
 export interface RenderEntityTracesOptions {
 	expression?: string;
+	timeRange?: { startTime: number; endTime: number };
 	category?: InfraMonitoringEntity;
+	selectedInterval?: '5m' | '15m' | '30m' | '1h';
 	pagination?: { offset: number; limit: number };
 }
 
 export function renderEntityTraces({
 	expression = 'k8s.pod.name = "test-pod"',
+	timeRange = { startTime: 1, endTime: 2 },
 	category = InfraMonitoringEntity.PODS,
+	selectedInterval = '5m',
 	pagination,
 }: RenderEntityTracesOptions = {}): RenderResult {
 	const encodedExpression = encodeURIComponent(expression);
@@ -33,7 +55,10 @@ export function renderEntityTraces({
 	return render(
 		<NuqsTestingAdapter searchParams={searchParams}>
 			<EntityTraces
-				eventEntity="test"
+				timeRange={timeRange}
+				isModalTimeSelection={false}
+				handleTimeChange={jest.fn()}
+				selectedInterval={selectedInterval}
 				queryKey="test"
 				category={category}
 				initialExpression={expression}
@@ -76,21 +101,21 @@ export function verifyQueryPayload({
 	expect(orderKeys).toContain('timestamp');
 }
 
-jest.mock('../../EntityDateTimeSelector/EntityDateTimeSelector', () => ({
+jest.mock('container/TopNav/DateTimeSelectionV2/index.tsx', () => ({
 	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="mock-datetime-selection">Date Time</div>
+	default: ({
+		onTimeChange,
+	}: {
+		onTimeChange?: (interval: string, dateTimeRange?: [number, number]) => void;
+	}): JSX.Element => (
+		<button
+			type="button"
+			data-testid="mock-datetime-selection"
+			onClick={(): void => {
+				onTimeChange?.('5m');
+			}}
+		>
+			Select Time
+		</button>
 	),
 }));
-
-jest.mock('../../EntityDateTimeSelector/useEntityDetailsTime', () => ({
-	useEntityDetailsTime: (): {
-		timeRange: { startTime: number; endTime: number };
-		selectedInterval: string;
-		handleTimeChange: jest.Mock;
-	} => ({
-		timeRange: { startTime: 1, endTime: 2 },
-		selectedInterval: '5m',
-		handleTimeChange: jest.fn(),
-	}),
-}));

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/createPodMetricsTab.tsx

@@ -1,5 +1,4 @@
 import { Container } from '@signozhq/icons';
-import { InfraMonitoringEvents } from 'constants/events';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 
 import { CustomTab } from '../Base/K8sBaseDetails';
@@ -11,20 +10,6 @@ import {
 
 import EntityMetrics from './EntityMetrics';
 
-const categoryToEventEntity: Record<InfraMonitoringEntity, string> = {
-	[InfraMonitoringEntity.DAEMONSETS]: InfraMonitoringEvents.DaemonSet,
-	[InfraMonitoringEntity.DEPLOYMENTS]: InfraMonitoringEvents.Deployment,
-	[InfraMonitoringEntity.JOBS]: InfraMonitoringEvents.Job,
-	[InfraMonitoringEntity.NAMESPACES]: InfraMonitoringEvents.Namespace,
-	[InfraMonitoringEntity.STATEFULSETS]: InfraMonitoringEvents.StatefulSet,
-	[InfraMonitoringEntity.PODS]: InfraMonitoringEvents.Pod,
-	[InfraMonitoringEntity.NODES]: InfraMonitoringEvents.Node,
-	[InfraMonitoringEntity.CLUSTERS]: InfraMonitoringEvents.Cluster,
-	[InfraMonitoringEntity.VOLUMES]: InfraMonitoringEvents.Volume,
-	[InfraMonitoringEntity.HOSTS]: InfraMonitoringEvents.HostEntity,
-	[InfraMonitoringEntity.CONTAINERS]: 'container',
-};
-
 interface CreatePodMetricsTabParams<T> {
 	getQueryPayload: (
 		entity: T,
@@ -32,29 +17,30 @@ interface CreatePodMetricsTabParams<T> {
 		end: number,
 		dotMetricsEnabled: boolean,
 	) => GetQueryResultsProps[];
-	queryKey: string;
 	category: InfraMonitoringEntity;
+	queryKey: string;
 }
 
 export function createPodMetricsTab<T>({
 	getQueryPayload,
-	queryKey,
 	category,
+	queryKey,
 }: CreatePodMetricsTabParams<T>): CustomTab<T> {
-	const eventEntity = categoryToEventEntity[category];
-
 	return {
 		key: VIEW_TYPES.POD_METRICS,
 		label: 'Pod Metrics',
 		icon: <Container size={14} />,
-		render: ({ entity }) => (
+		render: ({ entity, timeRange, selectedInterval, handleTimeChange }) => (
 			<EntityMetrics
 				entity={entity}
-				eventEntity={eventEntity}
+				selectedInterval={selectedInterval}
+				timeRange={timeRange}
+				handleTimeChange={handleTimeChange}
+				isModalTimeSelection
 				entityWidgetInfo={podUtilizationByPodWidgetInfo}
 				getEntityQueryPayload={getQueryPayload}
-				queryKey={queryKey}
 				category={category}
+				queryKey={queryKey}
 			/>
 		),
 	};

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/entityDetails.styles.scss

@@ -454,9 +454,3 @@
 		gap: 16px;
 	}
 }
-
-.entity-date-time-selector {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-}

frontend/src/container/InfraMonitoringK8sV2/constants.ts

@@ -905,9 +905,6 @@ export const INFRA_MONITORING_K8S_PARAMS_KEYS = {
 	SELECTED_ITEM: 'selectedItem',
 	SELECTED_ITEM_CLUSTER_NAME: 'selectedItemClusterName',
 	SELECTED_ITEM_NAMESPACE_NAME: 'selectedItemNamespaceName',
-	DETAIL_RELATIVE_TIME: 'detailRelativeTime',
-	DETAIL_START_TIME: 'detailStartTime',
-	DETAIL_END_TIME: 'detailEndTime',
 };
 
 /** Metric namespace prefixes for /fields/keys and /fields/values APIs */

frontend/src/index.tsx

@@ -7,7 +7,6 @@ import AppRoutes from 'AppRoutes';
 import { AxiosError } from 'axios';
 import { GlobalTimeStoreAdapter } from 'components/GlobalTimeStoreAdapter/GlobalTimeStoreAdapter';
 import { ThemeProvider } from 'hooks/useDarkMode';
-import { configureOverlayScrollbars } from 'lib/configureOverlayScrollbars';
 import { NuqsAdapter } from 'nuqs/adapters/react';
 import { AppProvider } from 'providers/App/App';
 import TimezoneProvider from 'providers/Timezone';
@@ -18,8 +17,6 @@ import './ReactI18';
 
 import 'styles.scss';
 
-configureOverlayScrollbars();
-
 const queryClient = new QueryClient({
 	defaultOptions: {
 		queries: {

frontend/src/lib/configureOverlayScrollbars.ts

@@ -1,22 +0,0 @@
-import { OverlayScrollbars } from 'overlayscrollbars';
-
-/**
- * Disables the content `elementEvents` option (default: `[['img', 'load']]`)
- * for every OverlayScrollbars instance.
- *
- * The per-element event cleanups OverlayScrollbars stores in its internal
- * WeakMap close over the MutationObserver callback scope, which holds arrays
- * with every node added/removed in that mutation batch. A single long-lived
- * reference to one of those elements (e.g. CodeMirror's EditContext or its
- * module-level scratch Range pinning a detached editor) then retains entire
- * unmounted subtrees as detached DOM — ~1.3k nodes per InfraMonitoring
- * category switch.
- *
- * Content size changes from loading images are still handled by the
- * scrollbars' size observer, so scrollbar geometry stays correct.
- */
-export function configureOverlayScrollbars(): void {
-	OverlayScrollbars.env().setDefaultOptions({
-		update: { elementEvents: null },
-	});
-}

frontend/src/store/globalTime/GlobalTimeContext.tsx

@@ -55,7 +55,6 @@ export function GlobalTimeProvider({
 			name,
 			selectedTime: resolveInitialTime(),
 			refreshInterval: initialRefreshInterval ?? 0,
-			parentStore: inheritGlobalTime ? globalStore : undefined,
 		}),
 	);
 

frontend/src/store/globalTime/__tests__/GlobalTimeContext.test.tsx

@@ -38,36 +38,6 @@ const createWrapper = (
 	};
 };
 
-const createNestedWrapper = (
-	parentProps: GlobalTimeProviderOptions,
-	childProps: GlobalTimeProviderOptions,
-	nuqsProps?: {
-		searchParams?: string;
-		onUrlUpdate?: (event: { queryString: string }) => void;
-	},
-) => {
-	const queryClient = createTestQueryClient();
-
-	return function NestedWrapper({
-		children,
-	}: {
-		children: ReactNode;
-	}): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<NuqsTestingAdapter
-					searchParams={nuqsProps?.searchParams}
-					onUrlUpdate={nuqsProps?.onUrlUpdate}
-				>
-					<GlobalTimeProvider {...parentProps}>
-						<GlobalTimeProvider {...childProps}>{children}</GlobalTimeProvider>
-					</GlobalTimeProvider>
-				</NuqsTestingAdapter>
-			</QueryClientProvider>
-		);
-	};
-};
-
 describe('GlobalTimeProvider', () => {
 	describe('name prop', () => {
 		it('should pass name to store when provided', () => {
@@ -112,73 +82,138 @@ describe('GlobalTimeProvider', () => {
 
 	describe('inheritGlobalTime', () => {
 		it('should inherit time from parent store when inheritGlobalTime is true', () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true },
+			const queryClient = createTestQueryClient();
+
+			const NestedWrapper = ({
+				children,
+			}: {
+				children: React.ReactNode;
+			}): JSX.Element => (
+				<QueryClientProvider client={queryClient}>
+					<NuqsTestingAdapter>
+						<GlobalTimeProvider initialTime="6h">
+							<GlobalTimeProvider inheritGlobalTime>{children}</GlobalTimeProvider>
+						</GlobalTimeProvider>
+					</NuqsTestingAdapter>
+				</QueryClientProvider>
 			);
 
 			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
+				wrapper: NestedWrapper,
 			});
 
+			// Should inherit '6h' from parent provider
 			expect(result.current).toBe('6h');
 		});
 
 		it('should use initialTime when inheritGlobalTime is false', () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: false, initialTime: '15m' },
+			const queryClient = createTestQueryClient();
+
+			const NestedWrapper = ({
+				children,
+			}: {
+				children: React.ReactNode;
+			}): JSX.Element => (
+				<QueryClientProvider client={queryClient}>
+					<NuqsTestingAdapter>
+						<GlobalTimeProvider initialTime="6h">
+							<GlobalTimeProvider inheritGlobalTime={false} initialTime="15m">
+								{children}
+							</GlobalTimeProvider>
+						</GlobalTimeProvider>
+					</NuqsTestingAdapter>
+				</QueryClientProvider>
 			);
 
 			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
+				wrapper: NestedWrapper,
 			});
 
+			// Should use its own initialTime, not parent's
 			expect(result.current).toBe('15m');
 		});
 
 		it('should prefer URL params over inheritGlobalTime when both are present', async () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true, enableUrlParams: true },
-				{ searchParams: '?relativeTime=1h' },
+			const queryClient = createTestQueryClient();
+
+			const NestedWrapper = ({
+				children,
+			}: {
+				children: React.ReactNode;
+			}): JSX.Element => (
+				<QueryClientProvider client={queryClient}>
+					<NuqsTestingAdapter searchParams="?relativeTime=1h">
+						<GlobalTimeProvider initialTime="6h">
+							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
+								{children}
+							</GlobalTimeProvider>
+						</GlobalTimeProvider>
+					</NuqsTestingAdapter>
+				</QueryClientProvider>
 			);
 
 			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
+				wrapper: NestedWrapper,
 			});
 
+			// inheritGlobalTime sets initial value to '6h', but URL sync updates it to '1h'
 			await waitFor(() => {
 				expect(result.current).toBe('1h');
 			});
 		});
 
 		it('should use inherited time when URL params are empty', async () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true, enableUrlParams: true },
-				{ searchParams: '' },
+			const queryClient = createTestQueryClient();
+
+			const NestedWrapper = ({
+				children,
+			}: {
+				children: React.ReactNode;
+			}): JSX.Element => (
+				<QueryClientProvider client={queryClient}>
+					<NuqsTestingAdapter searchParams="">
+						<GlobalTimeProvider initialTime="6h">
+							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
+								{children}
+							</GlobalTimeProvider>
+						</GlobalTimeProvider>
+					</NuqsTestingAdapter>
+				</QueryClientProvider>
 			);
 
 			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
+				wrapper: NestedWrapper,
 			});
 
+			// No URL params, should keep inherited value
 			expect(result.current).toBe('6h');
 		});
 
 		it('should prefer custom time URL params over inheritGlobalTime', async () => {
+			const queryClient = createTestQueryClient();
 			const startTime = 1700000000000;
 			const endTime = 1700003600000;
 
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true, enableUrlParams: true },
-				{ searchParams: `?startTime=${startTime}&endTime=${endTime}` },
+			const NestedWrapper = ({
+				children,
+			}: {
+				children: React.ReactNode;
+			}): JSX.Element => (
+				<QueryClientProvider client={queryClient}>
+					<NuqsTestingAdapter
+						searchParams={`?startTime=${startTime}&endTime=${endTime}`}
+					>
+						<GlobalTimeProvider initialTime="6h">
+							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
+								{children}
+							</GlobalTimeProvider>
+						</GlobalTimeProvider>
+					</NuqsTestingAdapter>
+				</QueryClientProvider>
 			);
 
 			const { result } = renderHook(() => useGlobalTime(), {
-				wrapper,
+				wrapper: NestedWrapper,
 			});
 
 			// URL custom time params should override inherited time
@@ -655,151 +690,4 @@ describe('GlobalTimeProvider', () => {
 			expect(result.current.isRefreshEnabled).toBe(true);
 		});
 	});
-
-	describe('resetToParentTime', () => {
-		it('should return false when no parent store exists', () => {
-			const wrapper = createWrapper({ initialTime: '1h' });
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			expect(result.current.resetToParentTime()).toBe(false);
-			expect(result.current.parentStore).toBeUndefined();
-		});
-
-		it('should have parentStore when inheritGlobalTime is true', () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			expect(result.current.parentStore).toBeDefined();
-		});
-
-		it('should reset to parent time when called', () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			expect(result.current.selectedTime).toBe('6h');
-			const initialMinMax = result.current.lastComputedMinMax;
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			expect(result.current.selectedTime).toBe('15m');
-			const changedMinMax = result.current.lastComputedMinMax;
-			expect(changedMinMax.maxTime - changedMinMax.minTime).toBeLessThan(
-				initialMinMax.maxTime - initialMinMax.minTime,
-			);
-
-			act(() => {
-				const success = result.current.resetToParentTime();
-				expect(success).toBe(true);
-			});
-
-			expect(result.current.selectedTime).toBe('6h');
-			const resetMinMax = result.current.lastComputedMinMax;
-			expect(resetMinMax.maxTime - resetMinMax.minTime).toBeGreaterThan(
-				changedMinMax.maxTime - changedMinMax.minTime,
-			);
-		});
-
-		it('should set shouldClearUrlParams flag when reset', () => {
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			act(() => {
-				result.current.resetToParentTime();
-			});
-
-			expect(result.current.shouldClearUrlParams).toBe(true);
-
-			act(() => {
-				result.current.clearUrlParamsFlag();
-			});
-
-			expect(result.current.shouldClearUrlParams).toBe(false);
-		});
-
-		it('should clear URL params when resetToParentTime is called with enableUrlParams', async () => {
-			let currentQueryString = 'relativeTime=15m';
-
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true, enableUrlParams: true },
-				{
-					searchParams: currentQueryString,
-					onUrlUpdate: (event): void => {
-						currentQueryString = event.queryString;
-					},
-				},
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				expect(result.current.selectedTime).toBe('15m');
-			});
-
-			act(() => {
-				result.current.resetToParentTime();
-			});
-
-			await waitFor(() => {
-				expect(currentQueryString).not.toContain('relativeTime');
-				expect(currentQueryString).not.toContain('startTime');
-				expect(currentQueryString).not.toContain('endTime');
-			});
-
-			expect(result.current.selectedTime).toBe('6h');
-		});
-
-		it('should clear custom time URL params when resetToParentTime is called', async () => {
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-			let currentQueryString = `startTime=${startTime}&endTime=${endTime}`;
-
-			const wrapper = createNestedWrapper(
-				{ initialTime: '6h' },
-				{ inheritGlobalTime: true, enableUrlParams: true },
-				{
-					searchParams: currentQueryString,
-					onUrlUpdate: (event): void => {
-						currentQueryString = event.queryString;
-					},
-				},
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				expect(result.current.selectedTime).toContain('||_||');
-			});
-
-			act(() => {
-				result.current.resetToParentTime();
-			});
-
-			await waitFor(() => {
-				expect(currentQueryString).not.toContain('startTime');
-				expect(currentQueryString).not.toContain('endTime');
-			});
-
-			expect(result.current.selectedTime).toBe('6h');
-		});
-	});
 });

frontend/src/store/globalTime/globalTimeStore.ts

@@ -5,7 +5,6 @@ import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constan
 import {
 	GlobalTimeSelectedTime,
 	GlobalTimeState,
-	GlobalTimeStoreApiRef,
 	GlobalTimeStore,
 	ParsedTimeRange,
 } from './types';
@@ -19,10 +18,6 @@ import {
 export type GlobalTimeStoreApi = StoreApi<GlobalTimeStore>;
 export type IGlobalTimeStore = GlobalTimeStore;
 
-export interface CreateGlobalTimeStoreOptions extends Partial<GlobalTimeState> {
-	parentStore?: GlobalTimeStoreApiRef;
-}
-
 function computeIsRefreshEnabled(
 	selectedTime: GlobalTimeSelectedTime,
 	refreshInterval: number,
@@ -34,12 +29,11 @@ function computeIsRefreshEnabled(
 }
 
 export function createGlobalTimeStore(
-	options?: CreateGlobalTimeStoreOptions,
+	initialState?: Partial<GlobalTimeState>,
 ): GlobalTimeStoreApi {
-	const selectedTime = options?.selectedTime ?? DEFAULT_TIME_RANGE;
-	const refreshInterval = options?.refreshInterval ?? 0;
-	const name = options?.name;
-	const parentStore = options?.parentStore;
+	const selectedTime = initialState?.selectedTime ?? DEFAULT_TIME_RANGE;
+	const refreshInterval = initialState?.refreshInterval ?? 0;
+	const name = initialState?.name;
 
 	return createStore<GlobalTimeStore>((set, get) => ({
 		name,
@@ -48,8 +42,6 @@ export function createGlobalTimeStore(
 		isRefreshEnabled: computeIsRefreshEnabled(selectedTime, refreshInterval),
 		lastRefreshTimestamp: 0,
 		lastComputedMinMax: safeParseSelectedTime(selectedTime),
-		parentStore,
-		shouldClearUrlParams: false,
 
 		setSelectedTime: (
 			time: GlobalTimeSelectedTime,
@@ -138,29 +130,6 @@ export function createGlobalTimeStore(
 			}
 			return [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, ...queryParts, selectedTime];
 		},
-
-		resetToParentTime: (): boolean => {
-			const state = get();
-			if (!state.parentStore) {
-				return false;
-			}
-
-			const parentSelectedTime = state.parentStore.getState().selectedTime;
-			const computedMinMax = parseSelectedTime(parentSelectedTime);
-
-			set({
-				selectedTime: parentSelectedTime,
-				lastComputedMinMax: computedMinMax,
-				lastRefreshTimestamp: Date.now(),
-				shouldClearUrlParams: true,
-			});
-
-			return true;
-		},
-
-		clearUrlParamsFlag: (): void => {
-			set({ shouldClearUrlParams: false });
-		},
 	}));
 }
 

frontend/src/store/globalTime/index.ts

@@ -206,7 +206,6 @@
  * | `getMinMaxTime(time?)` | Get min/max (fresh if auto-refresh enabled, cached otherwise) |
  * | `computeAndStoreMinMax()` | Compute fresh values and cache them |
  * | `getAutoRefreshQueryKey(time, ...parts)` | Build scoped query key for this store instance |
- * | `resetToParentTime()` | Reset to parent store's time (only if `inheritGlobalTime` was used). Clears URL params. Returns `true` on success |
  *
  * ### Utilities
  *
@@ -236,7 +235,7 @@
  * | Option | Type | Description |
  * |--------|------|-------------|
  * | `name` | `string` | Scope query keys to this store (enables isolated invalidation) |
- * | `inheritGlobalTime` | `boolean` | Initialize with parent/global time value. Enables `resetToParentTime()` |
+ * | `inheritGlobalTime` | `boolean` | Initialize with parent/global time value |
  * | `initialTime` | `string` | Initial time if not inheriting |
  * | `enableUrlParams` | `boolean \| object` | Sync time to URL query params |
  * | `removeQueryParamsOnUnmount` | `boolean` | Clean URL params on unmount |
@@ -342,39 +341,7 @@
  * }
  * ```
  *
- * ### Example 3: Reset to Parent Time
- *
- * When using `inheritGlobalTime`, you can reset the child store back to the parent's time:
- *
- * ```tsx
- * function DrawerHeader({ onClose }) {
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   const resetToParentTime = useGlobalTime((s) => s.resetToParentTime);
- *   const parentStore = useGlobalTime((s) => s.parentStore);
- *
- *   const handleReset = () => {
- *     // Returns true if reset succeeded, false if no parent store
- *     const success = resetToParentTime();
- *     if (success) {
- *       // URL params are automatically cleared
- *       console.log('Reset to parent time');
- *     }
- *   };
- *
- *   return (
- *     <div>
- *       <DateTimeSelectionV3 />
- *       {parentStore && (
- *         <Button onClick={handleReset}>
- *           Reset to Global Time
- *         </Button>
- *       )}
- *     </div>
- *   );
- * }
- * ```
- *
- * ### Example 4: Nested Contexts
+ * ### Example 3: Nested Contexts
  *
  * Contexts can be nested - each level creates isolation:
  *
@@ -412,10 +379,9 @@
  * }
  * ```
  *
- * ### Example 5: URL Sync for Shareable Links
+ * ### Example 4: URL Sync for Shareable Links
  *
- * Persist time selection to URL for shareable links. When using `resetToParentTime()`,
- * URL params are automatically cleared:
+ * Persist time selection to URL for shareable links:
  *
  * ```tsx
  * function TracesExplorer() {
@@ -434,7 +400,7 @@
  * }
  * ```
  *
- * ### Example 6: localStorage Persistence
+ * ### Example 5: localStorage Persistence
  *
  * Remember user's last selected time across sessions:
  *

frontend/src/store/globalTime/types.ts

@@ -1,13 +1,9 @@
-import { StoreApi } from 'zustand';
 import { Time } from 'container/TopNav/DateTimeSelectionV2/types';
 
 export type CustomTimeRangeSeparator = '||_||';
 export type CustomTimeRange = `${number}${CustomTimeRangeSeparator}${number}`;
 export type GlobalTimeSelectedTime = Time | CustomTimeRange;
 
-// Forward declaration to avoid circular dependency
-export type GlobalTimeStoreApiRef = StoreApi<GlobalTimeStore>;
-
 export interface IGlobalTimeStoreState {
 	/**
 	 * The selected time range, can be:
@@ -92,16 +88,6 @@ export interface GlobalTimeState {
 	isRefreshEnabled: boolean;
 	lastRefreshTimestamp: number;
 	lastComputedMinMax: ParsedTimeRange;
-	/**
-	 * Reference to parent store when inheritGlobalTime was used.
-	 * Enables resetToParentTime() functionality.
-	 */
-	parentStore?: GlobalTimeStoreApiRef;
-	/**
-	 * Flag indicating URL params should be cleared (not synced).
-	 * Set by resetToParentTime(), consumed by useUrlSync.
-	 */
-	shouldClearUrlParams: boolean;
 }
 
 export interface GlobalTimeActions {
@@ -132,16 +118,6 @@ export interface GlobalTimeActions {
 		selectedTime: GlobalTimeSelectedTime,
 		...queryParts: unknown[]
 	) => unknown[];
-	/**
-	 * Reset to parent store's time. Only works if inheritGlobalTime was used.
-	 * Clears URL params and sets selectedTime to parent's value.
-	 * @returns true if reset succeeded, false if no parent store
-	 */
-	resetToParentTime: () => boolean;
-	/**
-	 * Clear the shouldClearUrlParams flag after URL sync has processed it.
-	 */
-	clearUrlParamsFlag: () => void;
 }
 
 export type GlobalTimeStore = GlobalTimeState & GlobalTimeActions;

frontend/src/store/globalTime/useUrlSync.ts

@@ -91,17 +91,6 @@ export function useUrlSync(
 		let previousSelectedTime = store.getState().selectedTime;
 
 		return store.subscribe((state) => {
-			if (state.shouldClearUrlParams) {
-				previousSelectedTime = state.selectedTime;
-				void setUrlState({
-					[keys.relativeTimeKey]: null,
-					[keys.startTimeKey]: null,
-					[keys.endTimeKey]: null,
-				});
-				store.getState().clearUrlParamsFlag();
-				return;
-			}
-
 			if (state.selectedTime === previousSelectedTime) {
 				return;
 			}

tests/fixtures/clickhouse.py

@@ -203,9 +203,9 @@ def create_clickhouse(  # pylint: disable=too-many-arguments,too-many-positional
     pytestconfig: pytest.Config,
     cache_key: str = "clickhouse",
 ) -> types.TestContainerClickhouse:
+    coordinator = next(iter(keeper.container_configs.values()))
+
     def create() -> types.TestContainerClickhouse:
-        # Lazy: the keeper fixture is empty under --teardown (never created).
-        coordinator = next(iter(keeper.container_configs.values()))
         clickhouse_version = request.config.getoption("--clickhouse-version")
 
         container = ClickHouseContainer(
@@ -381,10 +381,9 @@ def create_clickhouse_cluster(  # pylint: disable=too-many-arguments,too-many-po
     migration goes through. Per-node containers are exposed via `nodes` so
     tests can assert shard-local state.
     """
+    coordinator = next(iter(keeper.container_configs.values()))
 
     def create() -> types.TestContainerClickhouse:
-        # Lazy: the keeper fixture is empty under --teardown (never created).
-        coordinator = next(iter(keeper.container_configs.values()))
         clickhouse_version = request.config.getoption("--clickhouse-version")
 
         # Unique aliases per creation: docker allows duplicate network aliases

tests/fixtures/network.py

@@ -1,5 +1,3 @@
-import time
-
 import docker
 import docker.errors
 import pytest
@@ -25,37 +23,12 @@ def network(request: pytest.FixtureRequest, pytestconfig: pytest.Config) -> type
     def delete(nw: types.Network):
         client = docker.from_env()
         try:
-            network = client.networks.get(network_id=nw.id)
+            client.networks.get(network_id=nw.id).remove()
         except docker.errors.NotFound:
             logger.info(
                 "Skipping removal of Network, Network(%s) not found. Maybe it was manually removed?",
                 {"name": nw.name, "id": nw.id},
             )
-            return
-
-        # Docker detaches endpoints asynchronously, so the network can briefly
-        # report "has active endpoints" after its containers are gone. Retry,
-        # force-disconnecting any stragglers.
-        last_err: docker.errors.APIError | None = None
-        for _ in range(10):
-            try:
-                network.remove()
-                return
-            except docker.errors.NotFound:
-                return
-            except docker.errors.APIError as err:
-                if "has active endpoints" not in str(err):
-                    raise
-                last_err = err
-                network.reload()
-                for container_id in network.attrs.get("Containers") or {}:
-                    try:
-                        network.disconnect(container_id, force=True)
-                    except docker.errors.APIError:
-                        pass
-                time.sleep(1)
-
-        raise last_err
 
     def restore(existing: dict) -> types.Network:
         client = docker.from_env()