feat(boot-settings): move SDK config from build-time env vars to runtime boot data injection

* fix(date-time-selection-v2): out of sync query params

* chore(get-current-search-params): explain why we have that file

* fix(pr): address comments

frontend/index.html

@@ -94,12 +94,15 @@
 				}
 			})();
 		</script>
+		<script>
+			window.signozBootData = { settings: [[.BootSettings]] };
+		</script>
 		<noscript>You need to enable JavaScript to run this app.</noscript>
 		<div id="root"></div>
 
 		<script>
-			var PYLON_APP_ID = '<%- PYLON_APP_ID %>';
-			if (PYLON_APP_ID) {
+			var pylonAppId = (window.signozBootData?.settings?.pylon || {}).appId || '';
+			if (pylonAppId) {
 				(function () {
 					var e = window;
 					var t = document;
@@ -115,10 +118,7 @@
 						var e = t.createElement('script');
 						e.setAttribute('type', 'text/javascript');
 						e.setAttribute('async', 'true');
-						e.setAttribute(
-							'src',
-							'https://widget.usepylon.com/widget/' + PYLON_APP_ID,
-						);
+						e.setAttribute('src', 'https://widget.usepylon.com/widget/' + pylonAppId);
 						var n = t.getElementsByTagName('script')[0];
 						n.parentNode.insertBefore(e, n);
 					};
@@ -130,16 +130,15 @@
 				})();
 			}
 		</script>
-		<script type="text/javascript">
-			window.AppcuesSettings = { enableURLDetection: true };
-		</script>
 		<script>
-			var APPCUES_APP_ID = '<%- APPCUES_APP_ID %>';
-			if (APPCUES_APP_ID) {
+			var appcuesAppId =
+				(window.signozBootData?.settings?.appcues || {}).appId || '';
+			if (appcuesAppId) {
+				window.AppcuesSettings = { enableURLDetection: true };
 				(function (d, t) {
 					var a = d.createElement(t);
 					a.async = 1;
-					a.src = '//fast.appcues.com/' + APPCUES_APP_ID + '.js';
+					a.src = '//fast.appcues.com/' + appcuesAppId + '.js';
 					var s = d.getElementsByTagName(t)[0];
 					s.parentNode.insertBefore(a, s);
 				})(document, 'script');

frontend/src/AppRoutes/index.tsx

@@ -35,6 +35,7 @@ import { PreferenceContextProvider } from 'providers/preferences/context/Prefere
 import { QueryBuilderProvider } from 'providers/QueryBuilder';
 import { LicenseStatus } from 'types/api/licensesV3/getActive';
 import { extractDomain } from 'utils/app';
+import { bootSettings } from 'utils/bootData';
 
 import { Home } from './pageComponents';
 import PrivateRoute from './Private';
@@ -293,7 +294,7 @@ function App(): JSX.Element {
 				(isCloudUser || isEnterpriseSelfHostedUser)
 			) {
 				const email = user.email || '';
-				const secret = process.env.PYLON_IDENTITY_SECRET || '';
+				const secret = bootSettings.pylon.identSecret ?? '';
 				let emailHash = '';
 
 				if (email && secret) {
@@ -302,7 +303,7 @@ function App(): JSX.Element {
 
 				window.pylon = {
 					chat_settings: {
-						app_id: process.env.PYLON_APP_ID,
+						app_id: bootSettings.pylon.appId,
 						email: user.email,
 						name: user.displayName || user.email,
 						email_hash: emailHash,
@@ -332,8 +333,8 @@ function App(): JSX.Element {
 
 	useEffect(() => {
 		if (isCloudUser || isEnterpriseSelfHostedUser) {
-			if (process.env.POSTHOG_KEY) {
-				posthog.init(process.env.POSTHOG_KEY, {
+			if (bootSettings.posthog.key) {
+				posthog.init(bootSettings.posthog.key, {
 					api_host: 'https://us.i.posthog.com',
 					person_profiles: 'identified_only', // or 'always' to create profiles for anonymous users as well
 				});
@@ -341,8 +342,8 @@ function App(): JSX.Element {
 
 			if (!isSentryInitialized) {
 				Sentry.init({
-					dsn: process.env.SENTRY_DSN,
-					tunnel: process.env.TUNNEL_URL,
+					dsn: bootSettings.sentry.dsn,
+					tunnel: bootSettings.sentry.tunnelUrl,
 					environment: 'production',
 					integrations: [
 						Sentry.browserTracingIntegration(),

frontend/src/container/DashboardContainer/DashboardSettings/index.tsx

@@ -1,5 +1,4 @@
-import { Button, Tooltip } from 'antd';
-import { Tabs } from '@signozhq/ui/tabs';
+import { Button, Tabs, Tooltip } from 'antd';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Braces, Globe, Table } from '@signozhq/icons';
 import { useAppContext } from 'providers/App/App';
@@ -74,7 +73,7 @@ function DashboardSettings({
 		...(enablePublicDashboard ? [publicDashboardItem] : []),
 	];
 
-	return <Tabs items={items} className="settings-tabs" />;
+	return <Tabs items={items} animated className="settings-tabs" />;
 }
 
 export default DashboardSettings;

frontend/src/container/Integrations/IntegrationDetailPage/IntegrationDetailContent.tsx

@@ -1,5 +1,4 @@
-import { Button } from 'antd';
-import { Tabs, TabItemProps } from '@signozhq/ui/tabs';
+import { Button, Tabs, TabsProps } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import ConfigureIcon from 'assets/Integrations/ConfigureIcon';
 import { CableCar, Group } from '@signozhq/icons';
@@ -23,7 +22,7 @@ function IntegrationDetailContent(
 ): JSX.Element {
 	const { activeDetailTab, integrationData, integrationId, setActiveDetailTab } =
 		props;
-	const items: TabItemProps[] = [
+	const items: TabsProps['items'] = [
 		{
 			key: 'overview',
 			label: (
@@ -82,7 +81,11 @@ function IntegrationDetailContent(
 	];
 	return (
 		<div className="integration-detail-container">
-			<Tabs value={activeDetailTab} items={items} onChange={setActiveDetailTab} />
+			<Tabs
+				activeKey={activeDetailTab}
+				items={items}
+				onChange={setActiveDetailTab}
+			/>
 		</div>
 	);
 }

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/AuthDomain.test.tsx

@@ -58,6 +58,26 @@ describe('AuthDomain', () => {
 			});
 		});
 
+		it('reflects ssoEnabled state from nested config in each row toggle', async () => {
+			server.use(
+				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
+					res(ctx.status(200), ctx.json(mockDomainsListResponse)),
+				),
+			);
+
+			render(<AuthDomain />);
+
+			// mockDomainsListResponse rows:
+			//   [0] signoz.io   → config.ssoEnabled: true
+			//   [1] example.com → config.ssoEnabled: false
+			//   [2] corp.io     → config.ssoEnabled: true
+			const switches = await screen.findAllByRole('switch');
+			expect(switches).toHaveLength(3);
+			expect(switches[0]).toBeChecked();
+			expect(switches[1]).not.toBeChecked();
+			expect(switches[2]).toBeChecked();
+		});
+
 		it('renders empty state when no domains exist', async () => {
 			server.use(
 				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>

frontend/src/container/OrganizationSettings/AuthDomain/index.tsx

@@ -121,14 +121,14 @@ function AuthDomain(): JSX.Element {
 			},
 			{
 				title: 'Enforce SSO',
-				dataIndex: 'ssoEnabled',
+				dataIndex: ['config', 'ssoEnabled'],
 				key: 'ssoEnabled',
 				width: 80,
 				render: (
 					value: boolean,
 					record: AuthtypesGettableAuthDomainDTO,
 				): JSX.Element => (
-					<SSOEnforcementToggle isDefaultChecked={value} record={record} />
+					<SSOEnforcementToggle isDefaultChecked={!!value} record={record} />
 				),
 			},
 			{

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/DateTimeSelectionV2.edge-cases.test.tsx

@@ -0,0 +1,258 @@
+import {
+	act,
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+} from '@testing-library/react';
+
+import DateTimeSelection from '../index';
+import {
+	__resetSearchParamsGetter,
+	__setSearchParamsGetterForTest,
+} from '../utils/getUnstableCurrentSearchParams';
+import { queryClient, TestWrapper } from './testUtils';
+
+const mockSafeNavigate = jest.fn();
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
+		safeNavigate: mockSafeNavigate,
+	}),
+}));
+
+jest.mock('container/NewExplorerCTA', () => ({
+	__esModule: true,
+	default: (): null => null,
+}));
+
+jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
+	__esModule: true,
+	default: ({
+		onSelect,
+	}: {
+		onSelect: (value: string) => void;
+	}): JSX.Element => (
+		<div data-testid="custom-time-picker">
+			<button
+				type="button"
+				data-testid="select-15m"
+				onClick={(): void => onSelect('15m')}
+			>
+				15m
+			</button>
+			<button
+				type="button"
+				data-testid="select-1h"
+				onClick={(): void => onSelect('1h')}
+			>
+				1h
+			</button>
+			<button
+				type="button"
+				data-testid="select-6h"
+				onClick={(): void => onSelect('6h')}
+			>
+				6h
+			</button>
+			<button
+				type="button"
+				data-testid="select-custom"
+				onClick={(): void => onSelect('custom')}
+			>
+				Custom
+			</button>
+		</div>
+	),
+}));
+
+describe('DateTimeSelectionV2 - Edge Cases', () => {
+	let currentSearchParams: URLSearchParams;
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockSafeNavigate.mockClear();
+		queryClient.clear();
+	});
+
+	afterEach(() => {
+		__resetSearchParamsGetter();
+	});
+
+	describe('Fresh Params at Navigation Time (Core Fix)', () => {
+		it('should read params at navigation time, not render time', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=30m');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams="relativeTime=30m"
+					onUrlUpdate={(event): void => {
+						currentSearchParams = event.searchParams;
+					}}
+				>
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			currentSearchParams = new URLSearchParams(
+				'relativeTime=30m&externalParam=addedLater',
+			);
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-1h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=1h');
+			expect(navigatedUrl).toContain('externalParam=addedLater');
+		});
+
+		it('should preserve multiple externally added params', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=30m');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			currentSearchParams = new URLSearchParams(
+				'relativeTime=30m&yAxisUnit=bytes&groupBy=host&view=table',
+			);
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-6h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=6h');
+			expect(navigatedUrl).toContain('yAxisUnit=bytes');
+			expect(navigatedUrl).toContain('groupBy=host');
+			expect(navigatedUrl).toContain('view=table');
+		});
+	});
+
+	describe('Empty and Special Values', () => {
+		it('should handle empty URL params gracefully', async () => {
+			currentSearchParams = new URLSearchParams('');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-15m'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=15m');
+		});
+
+		it('should handle special characters in preserved params', async () => {
+			currentSearchParams = new URLSearchParams(
+				'relativeTime=30m&filter=name%3D%22test%22',
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m&filter=name%3D%22test%22">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-1h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=1h');
+			expect(navigatedUrl).toContain('filter=');
+		});
+
+		it('should not navigate when selecting custom (opens picker instead)', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=30m');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-custom'));
+			});
+
+			await new Promise((resolve) => setTimeout(resolve, 100));
+
+			const customNavigationCalls = mockSafeNavigate.mock.calls.filter((call) => {
+				const url = call[0] as string;
+				return url.includes('startTime=') || url.includes('endTime=');
+			});
+
+			expect(customNavigationCalls).toHaveLength(0);
+		});
+	});
+});

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/DateTimeSelectionV2.modal-mode.test.tsx

@@ -0,0 +1,180 @@
+import {
+	act,
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+} from '@testing-library/react';
+
+import DateTimeSelection from '../index';
+import {
+	__resetSearchParamsGetter,
+	__setSearchParamsGetterForTest,
+} from '../utils/getUnstableCurrentSearchParams';
+import { queryClient, TestWrapper } from './testUtils';
+
+const mockSafeNavigate = jest.fn();
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
+		safeNavigate: mockSafeNavigate,
+	}),
+}));
+
+jest.mock('container/NewExplorerCTA', () => ({
+	__esModule: true,
+	default: (): null => null,
+}));
+
+let mockOnCustomDateHandler: ((range: [unknown, unknown]) => void) | null =
+	null;
+let mockOnValidCustomDateChange: ((data: { timeStr: string }) => void) | null =
+	null;
+
+jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
+	__esModule: true,
+	default: ({
+		onSelect,
+		onCustomDateHandler,
+		onValidCustomDateChange,
+	}: {
+		onSelect: (value: string) => void;
+		onCustomDateHandler?: (range: [unknown, unknown]) => void;
+		onValidCustomDateChange?: (data: { timeStr: string }) => void;
+	}): JSX.Element => {
+		mockOnCustomDateHandler = onCustomDateHandler || null;
+		mockOnValidCustomDateChange = onValidCustomDateChange || null;
+
+		return (
+			<div data-testid="custom-time-picker">
+				<button
+					type="button"
+					data-testid="select-1h"
+					onClick={(): void => onSelect('1h')}
+				>
+					1h
+				</button>
+			</div>
+		);
+	},
+}));
+
+describe('DateTimeSelectionV2 - Modal Mode', () => {
+	let currentSearchParams: URLSearchParams;
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockSafeNavigate.mockClear();
+		queryClient.clear();
+		mockOnCustomDateHandler = null;
+		mockOnValidCustomDateChange = null;
+	});
+
+	afterEach(() => {
+		__resetSearchParamsGetter();
+	});
+
+	it('should call onTimeChange instead of navigating for relative time', async () => {
+		currentSearchParams = new URLSearchParams('relativeTime=30m');
+		__setSearchParamsGetterForTest(() => currentSearchParams);
+
+		const mockOnTimeChange = jest.fn();
+
+		render(
+			<TestWrapper initialSearchParams="relativeTime=30m">
+				<DateTimeSelection
+					showAutoRefresh
+					isModalTimeSelection
+					onTimeChange={mockOnTimeChange}
+				/>
+			</TestWrapper>,
+		);
+
+		await waitFor(() => {
+			expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+		});
+
+		mockSafeNavigate.mockClear();
+
+		act(() => {
+			fireEvent.click(screen.getByTestId('select-1h'));
+		});
+
+		await waitFor(() => {
+			expect(mockOnTimeChange).toHaveBeenCalledWith('1h');
+		});
+
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('should call onTimeChange with custom and timestamps for custom date', async () => {
+		currentSearchParams = new URLSearchParams('relativeTime=30m');
+		__setSearchParamsGetterForTest(() => currentSearchParams);
+
+		const mockOnTimeChange = jest.fn();
+
+		render(
+			<TestWrapper initialSearchParams="relativeTime=30m">
+				<DateTimeSelection
+					showAutoRefresh
+					isModalTimeSelection
+					onTimeChange={mockOnTimeChange}
+				/>
+			</TestWrapper>,
+		);
+
+		await waitFor(() => {
+			expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+		});
+
+		const startMoment = { toDate: (): Date => new Date(1700000000000) };
+		const endMoment = { toDate: (): Date => new Date(1700003600000) };
+
+		mockSafeNavigate.mockClear();
+
+		act(() => {
+			mockOnCustomDateHandler?.([startMoment, endMoment]);
+		});
+
+		await waitFor(() => {
+			expect(mockOnTimeChange).toHaveBeenCalledWith(
+				'custom',
+				[1700000000000, 1700003600000],
+			);
+		});
+
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('should call onTimeChange for valid custom date string in modal', async () => {
+		currentSearchParams = new URLSearchParams('relativeTime=30m');
+		__setSearchParamsGetterForTest(() => currentSearchParams);
+
+		const mockOnTimeChange = jest.fn();
+
+		render(
+			<TestWrapper initialSearchParams="relativeTime=30m">
+				<DateTimeSelection
+					showAutoRefresh
+					isModalTimeSelection
+					onTimeChange={mockOnTimeChange}
+				/>
+			</TestWrapper>,
+		);
+
+		await waitFor(() => {
+			expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+		});
+
+		mockSafeNavigate.mockClear();
+
+		act(() => {
+			mockOnValidCustomDateChange?.({ timeStr: '4h' });
+		});
+
+		await waitFor(() => {
+			expect(mockOnTimeChange).toHaveBeenCalledWith('4h');
+		});
+
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+});

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/DateTimeSelectionV2.regression.test.tsx

@@ -0,0 +1,207 @@
+// eslint-disable-next-line no-restricted-imports
+import { Provider } from 'react-redux';
+import { MemoryRouter, Route } from 'react-router-dom';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { QueryClient, QueryClientProvider } from 'react-query';
+import {
+	act,
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+} from '@testing-library/react';
+import { parseAsString, useQueryState } from 'nuqs';
+import { AppContext } from 'providers/App/App';
+import TimezoneProvider from 'providers/Timezone';
+import { QueryBuilderProvider } from 'providers/QueryBuilder';
+import configureStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import store from 'store';
+import { getAppContextMock } from 'tests/test-utils';
+import { CompatRouter } from 'react-router-dom-v5-compat';
+
+import DateTimeSelection from '../index';
+import {
+	__resetSearchParamsGetter,
+	__setSearchParamsGetterForTest,
+} from '../utils/getUnstableCurrentSearchParams';
+
+const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: { refetchOnWindowFocus: false, retry: false },
+		mutations: { retry: false },
+	},
+});
+
+const mockStore = configureStore([thunk]);
+
+const mockSafeNavigate = jest.fn();
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
+		safeNavigate: mockSafeNavigate,
+	}),
+}));
+
+jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
+	__esModule: true,
+	default: ({
+		onSelect,
+	}: {
+		onSelect: (value: string) => void;
+	}): JSX.Element => (
+		<div data-testid="custom-time-picker">
+			<button
+				type="button"
+				data-testid="select-1h"
+				onClick={(): void => onSelect('1h')}
+			>
+				1h
+			</button>
+		</div>
+	),
+}));
+
+jest.mock('container/NewExplorerCTA', () => ({
+	__esModule: true,
+	default: (): null => null,
+}));
+
+function NuqsParamSetter({ paramValue }: { paramValue: string }): JSX.Element {
+	const [, setYAxisUnit] = useQueryState(
+		'yAxisUnit',
+		parseAsString.withDefault(''),
+	);
+
+	return (
+		<button
+			type="button"
+			data-testid="set-nuqs-param"
+			onClick={(): void => {
+				setYAxisUnit(paramValue);
+			}}
+		>
+			Set yAxisUnit
+		</button>
+	);
+}
+
+interface WrapperProps {
+	children: React.ReactNode;
+	initialSearchParams?: string;
+	initialPath?: string;
+	onUrlUpdate?: (event: { searchParams: URLSearchParams }) => void;
+}
+
+function TestWrapper({
+	children,
+	initialSearchParams = '',
+	initialPath = '/services',
+	onUrlUpdate,
+}: WrapperProps): JSX.Element {
+	const initialEntry = initialSearchParams
+		? `${initialPath}?${initialSearchParams}`
+		: initialPath;
+
+	const mockedStore = mockStore({
+		...store.getState(),
+		app: {
+			...store.getState().app,
+			role: 'ADMIN',
+			user: {
+				userId: 'test-user-id',
+				email: 'test@signoz.io',
+				name: 'TestUser',
+				profilePictureURL: '',
+				accessJwt: '',
+				refreshJwt: '',
+			},
+			isLoggedIn: true,
+		},
+	});
+
+	return (
+		<MemoryRouter initialEntries={[initialEntry]}>
+			<CompatRouter>
+				<NuqsTestingAdapter
+					searchParams={initialSearchParams}
+					onUrlUpdate={onUrlUpdate}
+				>
+					<QueryClientProvider client={queryClient}>
+						<Provider store={mockedStore}>
+							<AppContext.Provider value={getAppContextMock('ADMIN')}>
+								<TimezoneProvider>
+									<QueryBuilderProvider>
+										<Route path="*">{children}</Route>
+									</QueryBuilderProvider>
+								</TimezoneProvider>
+							</AppContext.Provider>
+						</Provider>
+					</QueryClientProvider>
+				</NuqsTestingAdapter>
+			</CompatRouter>
+		</MemoryRouter>
+	);
+}
+
+describe('REGRESSION: DateTimeSelectionV2 preserves nuqs query params on time change', () => {
+	let currentSearchParams: URLSearchParams;
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockSafeNavigate.mockClear();
+		queryClient.clear();
+
+		// Initialize with test's initial search params
+		currentSearchParams = new URLSearchParams('relativeTime=30m');
+		__setSearchParamsGetterForTest(() => currentSearchParams);
+	});
+
+	afterEach(() => {
+		__resetSearchParamsGetter();
+	});
+
+	it('should preserve yAxisUnit param set via nuqs when changing time selection', async () => {
+		render(
+			<TestWrapper
+				initialSearchParams="relativeTime=30m"
+				onUrlUpdate={(event): void => {
+					// Sync nuqs URL updates to our mock getter
+					// This simulates how window.location.search would be updated in real browser
+					currentSearchParams = event.searchParams;
+				}}
+			>
+				<NuqsParamSetter paramValue="bytes" />
+				<DateTimeSelection showAutoRefresh />
+			</TestWrapper>,
+		);
+
+		await waitFor(() => {
+			expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+		});
+
+		act(() => {
+			fireEvent.click(screen.getByTestId('set-nuqs-param'));
+		});
+
+		await waitFor(() => {
+			expect(currentSearchParams.get('yAxisUnit')).toBe('bytes');
+		});
+
+		mockSafeNavigate.mockClear();
+
+		act(() => {
+			fireEvent.click(screen.getByTestId('select-1h'));
+		});
+
+		await waitFor(() => {
+			expect(mockSafeNavigate).toHaveBeenCalled();
+		});
+
+		const navigatedUrl = mockSafeNavigate.mock.calls[
+			mockSafeNavigate.mock.calls.length - 1
+		][0] as string;
+
+		expect(navigatedUrl).toContain('relativeTime=1h');
+		expect(navigatedUrl).toContain('yAxisUnit=bytes');
+	});
+});

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/DateTimeSelectionV2.routes.test.tsx

@@ -0,0 +1,133 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import ROUTES from 'constants/routes';
+
+import DateTimeSelection from '../index';
+import {
+	__resetSearchParamsGetter,
+	__setSearchParamsGetterForTest,
+} from '../utils/getUnstableCurrentSearchParams';
+import { queryClient, TestWrapper } from './testUtils';
+
+const mockSafeNavigate = jest.fn();
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
+		safeNavigate: mockSafeNavigate,
+	}),
+}));
+
+jest.mock('container/NewExplorerCTA', () => ({
+	__esModule: true,
+	default: (): null => null,
+}));
+
+jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
+	__esModule: true,
+	default: (): JSX.Element => <div data-testid="custom-time-picker" />,
+}));
+
+describe('DateTimeSelectionV2 - Route-Specific Behavior', () => {
+	let currentSearchParams: URLSearchParams;
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockSafeNavigate.mockClear();
+		queryClient.clear();
+	});
+
+	afterEach(() => {
+		__resetSearchParamsGetter();
+	});
+
+	describe('Alert Pages', () => {
+		it('should set default time for alert overview when no time params', async () => {
+			currentSearchParams = new URLSearchParams('otherParam=value');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams="otherParam=value"
+					initialPath={ROUTES.ALERT_OVERVIEW}
+				>
+					<DateTimeSelection showAutoRefresh defaultRelativeTime="6h" />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[0][0] as string;
+			expect(navigatedUrl).toContain('relativeTime=6h');
+			expect(navigatedUrl).toContain('otherParam=value');
+		});
+
+		it('should set default time for alert history when no time params', async () => {
+			currentSearchParams = new URLSearchParams('filter=active');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams="filter=active"
+					initialPath={ROUTES.ALERT_HISTORY}
+				>
+					<DateTimeSelection showAutoRefresh defaultRelativeTime="6h" />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[0][0] as string;
+			expect(navigatedUrl).toContain('relativeTime=6h');
+		});
+
+		it('should NOT override existing time params on alert pages', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=1h&filter=active');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams="relativeTime=1h&filter=active"
+					initialPath={ROUTES.ALERT_OVERVIEW}
+				>
+					<DateTimeSelection showAutoRefresh defaultRelativeTime="6h" />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			const calls = mockSafeNavigate.mock.calls;
+			if (calls.length > 0) {
+				const lastUrl = calls[calls.length - 1][0] as string;
+				expect(lastUrl).toContain('relativeTime=1h');
+			}
+		});
+	});
+
+	describe('disableUrlSync Behavior', () => {
+		it('should not sync URL on mount when disableUrlSync is true', async () => {
+			currentSearchParams = new URLSearchParams('');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="" initialPath="/services">
+					<DateTimeSelection showAutoRefresh disableUrlSync />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			const syncCalls = mockSafeNavigate.mock.calls.filter((call) => {
+				const url = call[0] as string;
+				return url.includes('relativeTime=') && !url.includes('services?');
+			});
+
+			expect(syncCalls).toHaveLength(0);
+		});
+	});
+});

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/DateTimeSelectionV2.time-selection.test.tsx

@@ -0,0 +1,353 @@
+import {
+	act,
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+} from '@testing-library/react';
+
+import DateTimeSelection from '../index';
+import {
+	__resetSearchParamsGetter,
+	__setSearchParamsGetterForTest,
+} from '../utils/getUnstableCurrentSearchParams';
+import { queryClient, TestWrapper, createMockMoment } from './testUtils';
+
+const mockSafeNavigate = jest.fn();
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
+		safeNavigate: mockSafeNavigate,
+	}),
+}));
+
+jest.mock('container/NewExplorerCTA', () => ({
+	__esModule: true,
+	default: (): null => null,
+}));
+
+let mockOnCustomDateHandler: ((range: [unknown, unknown]) => void) | null =
+	null;
+let mockOnValidCustomDateChange: ((data: { timeStr: string }) => void) | null =
+	null;
+
+jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
+	__esModule: true,
+	default: ({
+		onSelect,
+		onCustomDateHandler,
+		onValidCustomDateChange,
+	}: {
+		onSelect: (value: string) => void;
+		onCustomDateHandler?: (range: [unknown, unknown]) => void;
+		onValidCustomDateChange?: (data: { timeStr: string }) => void;
+	}): JSX.Element => {
+		mockOnCustomDateHandler = onCustomDateHandler || null;
+		mockOnValidCustomDateChange = onValidCustomDateChange || null;
+
+		return (
+			<div data-testid="custom-time-picker">
+				<button
+					type="button"
+					data-testid="select-15m"
+					onClick={(): void => onSelect('15m')}
+				>
+					15m
+				</button>
+				<button
+					type="button"
+					data-testid="select-1h"
+					onClick={(): void => onSelect('1h')}
+				>
+					1h
+				</button>
+				<button
+					type="button"
+					data-testid="select-6h"
+					onClick={(): void => onSelect('6h')}
+				>
+					6h
+				</button>
+			</div>
+		);
+	},
+}));
+
+describe('DateTimeSelectionV2 - Time Selection', () => {
+	let currentSearchParams: URLSearchParams;
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockSafeNavigate.mockClear();
+		queryClient.clear();
+		mockOnCustomDateHandler = null;
+		mockOnValidCustomDateChange = null;
+	});
+
+	afterEach(() => {
+		__resetSearchParamsGetter();
+	});
+
+	describe('Relative Time', () => {
+		it('should update relativeTime and remove startTime/endTime', async () => {
+			currentSearchParams = new URLSearchParams(
+				'startTime=1000&endTime=2000&otherParam=keep',
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="startTime=1000&endTime=2000&otherParam=keep">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-15m'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=15m');
+			expect(navigatedUrl).not.toContain('startTime=');
+			expect(navigatedUrl).not.toContain('endTime=');
+			expect(navigatedUrl).toContain('otherParam=keep');
+		});
+
+		it('should remove activeLogId param on time change', async () => {
+			currentSearchParams = new URLSearchParams(
+				'relativeTime=30m&activeLogId=log123',
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m&activeLogId=log123">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-1h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=1h');
+			expect(navigatedUrl).not.toContain('activeLogId');
+		});
+
+		it('should update compositeQuery with new ID when present', async () => {
+			const compositeQuery = encodeURIComponent(
+				JSON.stringify({ id: 'old-id', builder: { queryData: [] } }),
+			);
+			currentSearchParams = new URLSearchParams(
+				`relativeTime=30m&compositeQuery=${compositeQuery}`,
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams={`relativeTime=30m&compositeQuery=${compositeQuery}`}
+				>
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-6h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('compositeQuery=');
+			expect(navigatedUrl).not.toContain('old-id');
+		});
+
+		it('should preserve all non-time URL params', async () => {
+			currentSearchParams = new URLSearchParams(
+				'relativeTime=30m&param1=a&param2=b&param3=c',
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m&param1=a&param2=b&param3=c">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				fireEvent.click(screen.getByTestId('select-1h'));
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=1h');
+			expect(navigatedUrl).toContain('param1=a');
+			expect(navigatedUrl).toContain('param2=b');
+			expect(navigatedUrl).toContain('param3=c');
+		});
+	});
+
+	describe('Custom Date Range', () => {
+		it('should set startTime/endTime and remove relativeTime', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=30m&keepThis=yes');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m&keepThis=yes">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			const startMoment = createMockMoment(1700000000000);
+			const endMoment = createMockMoment(1700003600000);
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				mockOnCustomDateHandler?.([startMoment, endMoment]);
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('startTime=1700000000000');
+			expect(navigatedUrl).toContain('endTime=1700003600000');
+			expect(navigatedUrl).not.toContain('relativeTime=');
+			expect(navigatedUrl).toContain('keepThis=yes');
+		});
+
+		it('should update compositeQuery when present for custom date', async () => {
+			const compositeQuery = encodeURIComponent(
+				JSON.stringify({ id: 'old-id', builder: { queryData: [] } }),
+			);
+			currentSearchParams = new URLSearchParams(
+				`relativeTime=30m&compositeQuery=${compositeQuery}`,
+			);
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper
+					initialSearchParams={`relativeTime=30m&compositeQuery=${compositeQuery}`}
+				>
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			const startMoment = createMockMoment(1700000000000);
+			const endMoment = createMockMoment(1700003600000);
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				mockOnCustomDateHandler?.([startMoment, endMoment]);
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('compositeQuery=');
+			expect(navigatedUrl).not.toContain('old-id');
+		});
+	});
+
+	describe('Valid Custom Date String', () => {
+		it('should handle shorthand date format and preserve params', async () => {
+			currentSearchParams = new URLSearchParams('relativeTime=30m&filter=active');
+			__setSearchParamsGetterForTest(() => currentSearchParams);
+
+			render(
+				<TestWrapper initialSearchParams="relativeTime=30m&filter=active">
+					<DateTimeSelection showAutoRefresh />
+				</TestWrapper>,
+			);
+
+			await waitFor(() => {
+				expect(screen.getByTestId('custom-time-picker')).toBeInTheDocument();
+			});
+
+			mockSafeNavigate.mockClear();
+
+			act(() => {
+				mockOnValidCustomDateChange?.({ timeStr: '2h' });
+			});
+
+			await waitFor(() => {
+				expect(mockSafeNavigate).toHaveBeenCalled();
+			});
+
+			const navigatedUrl = mockSafeNavigate.mock.calls[
+				mockSafeNavigate.mock.calls.length - 1
+			][0] as string;
+
+			expect(navigatedUrl).toContain('relativeTime=2h');
+			expect(navigatedUrl).toContain('filter=active');
+			expect(navigatedUrl).not.toContain('startTime=');
+			expect(navigatedUrl).not.toContain('endTime=');
+		});
+	});
+});

frontend/src/container/TopNav/DateTimeSelectionV2/__tests__/testUtils.tsx

@@ -0,0 +1,95 @@
+// eslint-disable-next-line no-restricted-imports
+import { Provider } from 'react-redux';
+import { MemoryRouter, Route } from 'react-router-dom';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { QueryClient, QueryClientProvider } from 'react-query';
+import { AppContext } from 'providers/App/App';
+import TimezoneProvider from 'providers/Timezone';
+import { QueryBuilderProvider } from 'providers/QueryBuilder';
+import configureStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import store from 'store';
+import { getAppContextMock } from 'tests/test-utils';
+import { CompatRouter } from 'react-router-dom-v5-compat';
+
+export const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: { refetchOnWindowFocus: false, retry: false },
+		mutations: { retry: false },
+	},
+});
+
+export const mockStore = configureStore([thunk]);
+
+interface WrapperProps {
+	children: React.ReactNode;
+	initialSearchParams?: string;
+	initialPath?: string;
+	onUrlUpdate?: (event: { searchParams: URLSearchParams }) => void;
+}
+
+export function TestWrapper({
+	children,
+	initialSearchParams = '',
+	initialPath = '/services',
+	onUrlUpdate,
+}: WrapperProps): JSX.Element {
+	const initialEntry = initialSearchParams
+		? `${initialPath}?${initialSearchParams}`
+		: initialPath;
+
+	const mockedStore = mockStore({
+		...store.getState(),
+		app: {
+			...store.getState().app,
+			role: 'ADMIN',
+			user: {
+				userId: 'test-user-id',
+				email: 'test@signoz.io',
+				name: 'TestUser',
+				profilePictureURL: '',
+				accessJwt: '',
+				refreshJwt: '',
+			},
+			isLoggedIn: true,
+		},
+	});
+
+	return (
+		<MemoryRouter initialEntries={[initialEntry]}>
+			<CompatRouter>
+				<NuqsTestingAdapter
+					searchParams={initialSearchParams}
+					onUrlUpdate={onUrlUpdate}
+				>
+					<QueryClientProvider client={queryClient}>
+						<Provider store={mockedStore}>
+							<AppContext.Provider value={getAppContextMock('ADMIN')}>
+								<TimezoneProvider>
+									<QueryBuilderProvider>
+										<Route path="*">{children}</Route>
+									</QueryBuilderProvider>
+								</TimezoneProvider>
+							</AppContext.Provider>
+						</Provider>
+					</QueryClientProvider>
+				</NuqsTestingAdapter>
+			</CompatRouter>
+		</MemoryRouter>
+	);
+}
+
+export function createMockMoment(timestamp: number): {
+	toDate: () => Date;
+	toISOString: () => string;
+	format: () => string;
+	toString: () => string;
+} {
+	const date = new Date(timestamp);
+	return {
+		toDate: (): Date => date,
+		toISOString: (): string => date.toISOString(),
+		format: (): string => date.toISOString(),
+		toString: (): string => date.toString(),
+	};
+}

frontend/src/container/TopNav/DateTimeSelectionV2/index.tsx

@@ -2,7 +2,7 @@ import { useCallback, useEffect, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { connect, useDispatch, useSelector } from 'react-redux';
 import { RouteComponentProps, withRouter } from 'react-router-dom';
-import { useNavigationType, useSearchParams } from 'react-router-dom-v5-compat';
+import { useNavigationType } from 'react-router-dom-v5-compat';
 import { RefreshCw, Undo } from '@signozhq/icons';
 import { Button } from 'antd';
 import getLocalStorageKey from 'api/browser/localstorage/get';
@@ -20,7 +20,6 @@ import {
 } from 'store/globalTime';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import useUrlQuery from 'hooks/useUrlQuery';
 import { isValidShortHandDateTimeFormat } from 'lib/getMinMax';
 import getTimeString from 'lib/getTimeString';
 import { cloneDeep, isObject } from 'lodash-es';
@@ -54,6 +53,7 @@ import {
 	Time,
 	TimeRange,
 } from './types';
+import { getUnstableCurrentSearchParams } from './utils/getUnstableCurrentSearchParams';
 
 import './DateTimeSelectionV2.styles.scss';
 
@@ -90,10 +90,12 @@ function DateTimeSelection({
 	const [hasSelectedTimeError, setHasSelectedTimeError] = useState(false);
 	const [isOpen, setIsOpen] = useState<boolean>(false);
 
-	const urlQuery = useUrlQuery();
-	const searchStartTime = urlQuery.get('startTime');
-	const searchEndTime = urlQuery.get('endTime');
-	const relativeTimeFromUrl = urlQuery.get(QueryParams.relativeTime);
+	const currentSearchParams = getUnstableCurrentSearchParams();
+	const searchStartTime = currentSearchParams.get(QueryParams.startTime);
+	const searchEndTime = currentSearchParams.get(QueryParams.endTime);
+	const relativeTimeFromUrl = currentSearchParams.get(QueryParams.relativeTime);
+	const hasTimeParamsInUrl =
+		(searchStartTime && searchEndTime) || relativeTimeFromUrl;
 
 	// Prioritize props for initial modal time, fallback to URL params
 	let initialModalStartTime = 0;
@@ -115,8 +117,6 @@ function DateTimeSelection({
 	);
 	const [modalEndTime, setModalEndTime] = useState<number>(initialModalEndTime);
 
-	const [searchParams] = useSearchParams();
-
 	// Effect to update modal time state when props change
 	useEffect(() => {
 		if (modalInitialStartTime !== undefined) {
@@ -323,14 +323,15 @@ function DateTimeSelection({
 				return;
 			}
 
-			urlQuery.delete('startTime');
-			urlQuery.delete('endTime');
+			const urlQuery = getUnstableCurrentSearchParams();
+			urlQuery.delete(QueryParams.startTime);
+			urlQuery.delete(QueryParams.endTime);
 
 			urlQuery.set(QueryParams.relativeTime, value);
 			// Remove Hidden Filters from URL query parameters on time change
 			urlQuery.delete(QueryParams.activeLogId);
 
-			if (searchParams.has(QueryParams.compositeQuery)) {
+			if (urlQuery.has(QueryParams.compositeQuery)) {
 				const updatedCompositeQuery = getUpdatedCompositeQuery();
 				urlQuery.set(QueryParams.compositeQuery, updatedCompositeQuery);
 			}
@@ -349,8 +350,6 @@ function DateTimeSelection({
 			getUpdatedCompositeQuery,
 			updateLocalStorageForRoutes,
 			updateTimeInterval,
-			urlQuery,
-			searchParams,
 		],
 	);
 
@@ -414,6 +413,7 @@ function DateTimeSelection({
 
 				updateLocalStorageForRoutes(JSON.stringify({ startTime, endTime }));
 
+				const urlQuery = getUnstableCurrentSearchParams();
 				urlQuery.set(
 					QueryParams.startTime,
 					startTime?.toDate().getTime().toString(),
@@ -421,7 +421,7 @@ function DateTimeSelection({
 				urlQuery.set(QueryParams.endTime, endTime?.toDate().getTime().toString());
 				urlQuery.delete(QueryParams.relativeTime);
 
-				if (searchParams.has(QueryParams.compositeQuery)) {
+				if (urlQuery.has(QueryParams.compositeQuery)) {
 					const updatedCompositeQuery = getUpdatedCompositeQuery();
 					urlQuery.set(QueryParams.compositeQuery, updatedCompositeQuery);
 				}
@@ -441,8 +441,9 @@ function DateTimeSelection({
 		updateTimeInterval(dateTimeStr);
 		updateLocalStorageForRoutes(dateTimeStr);
 
-		urlQuery.delete('startTime');
-		urlQuery.delete('endTime');
+		const urlQuery = getUnstableCurrentSearchParams();
+		urlQuery.delete(QueryParams.startTime);
+		urlQuery.delete(QueryParams.endTime);
 
 		urlQuery.set(QueryParams.relativeTime, dateTimeStr);
 
@@ -595,13 +596,12 @@ function DateTimeSelection({
 
 		// set the default relative time for alert history and overview pages if relative time is not specified
 		if (
-			(!urlQuery.has(QueryParams.startTime) ||
-				!urlQuery.has(QueryParams.endTime)) &&
-			!urlQuery.has(QueryParams.relativeTime) &&
+			!hasTimeParamsInUrl &&
 			(currentRoute === ROUTES.ALERT_OVERVIEW ||
 				currentRoute === ROUTES.ALERT_HISTORY)
 		) {
 			updateTimeInterval(defaultRelativeTime);
+			const urlQuery = getUnstableCurrentSearchParams();
 			urlQuery.set(QueryParams.relativeTime, defaultRelativeTime);
 			const generatedUrl = `${location.pathname}?${urlQuery.toString()}`;
 			safeNavigate(generatedUrl);
@@ -625,9 +625,10 @@ function DateTimeSelection({
 			updateTimeInterval(updatedTime, [preStartTime, preEndTime]);
 		}
 
+		const urlQuery = getUnstableCurrentSearchParams();
 		if (updatedTime !== 'custom') {
-			urlQuery.delete('startTime');
-			urlQuery.delete('endTime');
+			urlQuery.delete(QueryParams.startTime);
+			urlQuery.delete(QueryParams.endTime);
 			urlQuery.set(QueryParams.relativeTime, updatedTime);
 		} else {
 			const startTime = preStartTime.toString();

frontend/src/container/TopNav/DateTimeSelectionV2/utils/getUnstableCurrentSearchParams.ts

@@ -0,0 +1,34 @@
+/**
+ * This was introduced to fix a sync bug between Nuqs and react-router-dom
+ *
+ * We are using the wrong adapter for nuqs because the correct one only supports v6/v7,
+ * and we are at version v5. This causes the nuqs/react-router-dom to be out of sync.
+ *
+ * We can revert this commit once we migrate react-router-dom to v6, or once we migrate
+ * to DateTimeSelectionV3
+ */
+
+/**
+ * This was created to help testing the regression introduced between nuqs/react-router-dom
+ */
+type SearchParamsGetter = () => URLSearchParams;
+let getter: SearchParamsGetter = (): URLSearchParams =>
+	new URLSearchParams(window.location.search);
+
+/**
+ * This function will return a fresh instance of URLSearchParams every time it's called.
+ *
+ * DO NOT USE IT FOR useEffect/useCallback dependencies, use Nuqs instead.
+ */
+export function getUnstableCurrentSearchParams(): URLSearchParams {
+	return getter();
+}
+
+// Testing helpers
+export function __setSearchParamsGetterForTest(fn: SearchParamsGetter): void {
+	getter = fn;
+}
+
+export function __resetSearchParamsGetter(): void {
+	getter = (): URLSearchParams => new URLSearchParams(window.location.search);
+}

frontend/src/pages/MetricsApplication/MetricsApplication.tsx

@@ -1,5 +1,5 @@
 import { useParams } from 'react-router-dom';
-import { Tabs, TabItemProps } from '@signozhq/ui/tabs';
+import { Tabs, TabsProps } from 'antd';
 import { QueryParams } from 'constants/query';
 import DBCall from 'container/MetricsApplication/Tabs/DBCall';
 import External from 'container/MetricsApplication/Tabs/External';
@@ -24,7 +24,7 @@ function MetricsApplication(): JSX.Element {
 	const urlQuery = useUrlQuery();
 	const { safeNavigate } = useSafeNavigate();
 
-	const items: TabItemProps[] = [
+	const items: TabsProps['items'] = [
 		{
 			label: TAB_KEY_VS_LABEL[MetricsApplicationTab.OVER_METRICS],
 			key: MetricsApplicationTab.OVER_METRICS,
@@ -53,8 +53,9 @@ function MetricsApplication(): JSX.Element {
 			<ApDexApplication />
 			<Tabs
 				items={items}
-				value={activeKey}
+				activeKey={activeKey}
 				className="service-route-tab"
+				destroyInactiveTabPane
 				onChange={onTabChange}
 			/>
 		</div>

frontend/src/pages/Pipelines/index.tsx

@@ -2,7 +2,8 @@ import { useEffect, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useQuery } from 'react-query';
 import * as Sentry from '@sentry/react';
-import { Tabs, TabItemProps } from '@signozhq/ui/tabs';
+import type { TabsProps } from 'antd';
+import { Tabs } from 'antd';
 import getPipeline from 'api/pipeline/get';
 import Spinner from 'components/Spinner';
 import ChangeHistory from 'container/PipelinePage/Layouts/ChangeHistory';
@@ -45,7 +46,7 @@ function Pipelines(): JSX.Element {
 		refetchInterval: pipelineRefetchInterval,
 	});
 
-	const tabItems: TabItemProps[] = useMemo(
+	const tabItems: TabsProps['items'] = useMemo(
 		() => [
 			{
 				key: 'pipelines',
@@ -82,7 +83,11 @@ function Pipelines(): JSX.Element {
 
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
-			<Tabs className="pipeline-tabs" defaultValue="pipelines" items={tabItems} />
+			<Tabs
+				className="pipeline-tabs"
+				defaultActiveKey="pipelines"
+				items={tabItems}
+			/>
 		</Sentry.ErrorBoundary>
 	);
 }

frontend/src/pages/TraceDetailV2/TraceDetailV2.tsx

@@ -5,8 +5,7 @@ import {
 	ResizablePanel,
 	ResizablePanelGroup,
 } from '@signozhq/resizable';
-import { Button } from 'antd';
-import { Tabs } from '@signozhq/ui/tabs';
+import { Button, Tabs } from 'antd';
 import FlamegraphImg from 'assets/TraceDetail/Flamegraph';
 import cx from 'classnames';
 import TraceFlamegraph from 'container/PaginatedTraceFlamegraph/PaginatedTraceFlamegraph';
@@ -147,7 +146,7 @@ function TraceDetailsV2(): JSX.Element {
 					notFound={noData}
 				/>
 				{!noData ? (
-					<Tabs items={items} className="trace-visualisation-tabs" />
+					<Tabs items={items} animated className="trace-visualisation-tabs" />
 				) : (
 					<NoData />
 				)}

frontend/src/pages/WorkspaceLocked/WorkspaceLocked.tsx

@@ -2,7 +2,7 @@
 import React, { useCallback, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMutation } from 'react-query';
-import type { TabItemProps } from '@signozhq/ui/tabs';
+import type { TabsProps } from 'antd';
 import {
 	Alert,
 	Button,
@@ -14,8 +14,8 @@ import {
 	Row,
 	Skeleton,
 	Space,
+	Tabs,
 } from 'antd';
-import { Tabs } from '@signozhq/ui/tabs';
 import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import updateCreditCardApi from 'api/v1/checkout/create';
@@ -154,7 +154,7 @@ export default function WorkspaceBlocked(): JSX.Element {
 				/>
 			));
 
-	const tabItems: TabItemProps[] = [
+	const tabItems: TabsProps['items'] = [
 		{
 			key: 'whyChooseSignoz',
 			label: t('whyChooseSignoz'),
@@ -398,8 +398,8 @@ export default function WorkspaceBlocked(): JSX.Element {
 							<div className="workspace-locked__tabs">
 								<Tabs
 									items={tabItems}
-									defaultValue="youAreInGoodCompany"
-									onChange={handleTabClick}
+									defaultActiveKey="youAreInGoodCompany"
+									onTabClick={handleTabClick}
 								/>
 							</div>
 						</>

frontend/src/typings/window.ts

@@ -1,5 +1,6 @@
 // eslint-disable-next-line no-restricted-imports
 import { compose, Store } from 'redux';
+import type { SignozBootSettings } from 'utils/bootData';
 
 declare global {
 	interface Window {
@@ -7,6 +8,7 @@ declare global {
 		pylon: any;
 		Appcues: Record<string, any>;
 		__REDUX_DEVTOOLS_EXTENSION_COMPOSE__: typeof compose;
+		signozBootData?: { settings?: Partial<SignozBootSettings> };
 	}
 }
 

frontend/src/utils/__tests__/bootData.test.ts

@@ -0,0 +1,99 @@
+export {};
+
+type BootData = typeof import('../bootData');
+
+function loadModule(settings?: object): BootData {
+	(window as any).signozBootData =
+		settings !== undefined ? { settings } : undefined;
+	let mod!: BootData;
+	jest.isolateModules(() => {
+		// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+		mod = require('../bootData');
+	});
+	return mod;
+}
+
+afterEach(() => {
+	delete (window as any).signozBootData;
+});
+
+describe('when window.signozBootData is absent', () => {
+	it('all sub-objects are defined and empty', () => {
+		const { bootSettings } = loadModule();
+		expect(bootSettings.sentry).toStrictEqual({});
+		expect(bootSettings.posthog).toStrictEqual({});
+		expect(bootSettings.pylon).toStrictEqual({});
+		expect(bootSettings.appcues).toStrictEqual({});
+		expect(bootSettings.roles).toStrictEqual({});
+	});
+
+	it('optional fields are undefined', () => {
+		const { bootSettings } = loadModule();
+		expect(bootSettings.sentry.dsn).toBeUndefined();
+		expect(bootSettings.sentry.tunnelUrl).toBeUndefined();
+		expect(bootSettings.posthog.key).toBeUndefined();
+		expect(bootSettings.pylon.appId).toBeUndefined();
+		expect(bootSettings.pylon.identSecret).toBeUndefined();
+		expect(bootSettings.appcues.appId).toBeUndefined();
+		expect(bootSettings.roles.isRolesDetailEnabled).toBeUndefined();
+	});
+});
+
+describe('when window.signozBootData.settings is populated', () => {
+	it('reads sentry config', () => {
+		const { bootSettings } = loadModule({
+			sentry: { dsn: 'https://abc@sentry.io/1', tunnelUrl: '/tunnel' },
+		});
+		expect(bootSettings.sentry.dsn).toBe('https://abc@sentry.io/1');
+		expect(bootSettings.sentry.tunnelUrl).toBe('/tunnel');
+	});
+
+	it('reads posthog config', () => {
+		const { bootSettings } = loadModule({ posthog: { key: 'phk_xxx' } });
+		expect(bootSettings.posthog.key).toBe('phk_xxx');
+	});
+
+	it('reads pylon config', () => {
+		const { bootSettings } = loadModule({
+			pylon: { appId: 'pylon-abc', identSecret: 'secret-xyz' },
+		});
+		expect(bootSettings.pylon.appId).toBe('pylon-abc');
+		expect(bootSettings.pylon.identSecret).toBe('secret-xyz');
+	});
+
+	it('reads appcues config', () => {
+		const { bootSettings } = loadModule({ appcues: { appId: 'appcues-123' } });
+		expect(bootSettings.appcues.appId).toBe('appcues-123');
+	});
+
+	it('reads roles config', () => {
+		const { bootSettings } = loadModule({
+			roles: { isRolesDetailEnabled: true },
+		});
+		expect(bootSettings.roles.isRolesDetailEnabled).toBe(true);
+	});
+
+	it('missing sub-namespaces fall back to empty objects', () => {
+		const { bootSettings } = loadModule({
+			sentry: { dsn: 'https://abc@sentry.io/1' },
+		});
+		expect(bootSettings.posthog).toStrictEqual({});
+		expect(bootSettings.posthog.key).toBeUndefined();
+		expect(bootSettings.pylon).toStrictEqual({});
+		expect(bootSettings.appcues).toStrictEqual({});
+		expect(bootSettings.roles).toStrictEqual({});
+	});
+});
+
+describe('when window.signozBootData exists but settings is undefined', () => {
+	it('all sub-objects are empty', () => {
+		(window as any).signozBootData = {};
+		let mod!: BootData;
+		jest.isolateModules(() => {
+			// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+			mod = require('../bootData');
+		});
+		expect(mod.bootSettings.sentry).toStrictEqual({});
+		expect(mod.bootSettings.posthog).toStrictEqual({});
+	});
+});

frontend/src/utils/bootData.ts

@@ -0,0 +1,35 @@
+export interface SentryConfig {
+	dsn?: string;
+	tunnelUrl?: string;
+}
+export interface PosthogConfig {
+	key?: string;
+}
+export interface PylonConfig {
+	appId?: string;
+	identSecret?: string;
+}
+export interface AppcuesConfig {
+	appId?: string;
+}
+export interface RolesConfig {
+	isRolesDetailEnabled?: boolean;
+}
+
+export interface SignozBootSettings {
+	sentry: SentryConfig;
+	posthog: PosthogConfig;
+	pylon: PylonConfig;
+	appcues: AppcuesConfig;
+	roles: RolesConfig;
+}
+
+const raw = window.signozBootData?.settings;
+
+export const bootSettings: Readonly<SignozBootSettings> = {
+	sentry: raw?.sentry ?? {},
+	posthog: raw?.posthog ?? {},
+	pylon: raw?.pylon ?? {},
+	appcues: raw?.appcues ?? {},
+	roles: raw?.roles ?? {},
+};

frontend/src/vite-env.d.ts

@@ -13,16 +13,9 @@ declare module '*.md?raw' {
 interface ImportMetaEnv {
 	readonly VITE_FRONTEND_API_ENDPOINT: string;
 	readonly VITE_WEBSOCKET_API_ENDPOINT: string;
-	readonly VITE_PYLON_APP_ID: string;
-	readonly VITE_PYLON_IDENTITY_SECRET: string;
-	readonly VITE_APPCUES_APP_ID: string;
-	readonly VITE_POSTHOG_KEY: string;
 	readonly VITE_SENTRY_AUTH_TOKEN: string;
 	readonly VITE_SENTRY_ORG: string;
 	readonly VITE_SENTRY_PROJECT_ID: string;
-	readonly VITE_SENTRY_DSN: string;
-	readonly VITE_TUNNEL_URL: string;
-	readonly VITE_TUNNEL_DOMAIN: string;
 	readonly VITE_DOCS_BASE_URL: string;
 }
 

frontend/vite.config.ts

@@ -6,7 +6,6 @@ import type { Plugin, TransformResult, UserConfig } from 'vite';
 import { defineConfig, loadEnv } from 'vite';
 import vitePluginChecker from 'vite-plugin-checker';
 import viteCompression from 'vite-plugin-compression';
-import { createHtmlPlugin } from 'vite-plugin-html';
 import { ViteImageOptimizer } from 'vite-plugin-image-optimizer';
 import tsconfigPaths from 'vite-tsconfig-paths';
 
@@ -23,6 +22,29 @@ function devBasePathPlugin(basePath: string): Plugin {
 	};
 }
 
+function devBootDataPlugin(env: Record<string, string>): Plugin {
+	return {
+		name: 'dev-boot-data',
+		apply: 'serve',
+		transformIndexHtml(html): string {
+			const bootSettings = {
+				sentry: {
+					dsn: env.VITE_SENTRY_DSN || undefined,
+					tunnelUrl: env.VITE_TUNNEL_URL || undefined,
+				},
+				posthog: { key: env.VITE_POSTHOG_KEY || undefined },
+				pylon: {
+					appId: env.VITE_PYLON_APP_ID || undefined,
+					identSecret: env.VITE_PYLON_IDENTITY_SECRET || undefined,
+				},
+				appcues: { appId: env.VITE_APPCUES_APP_ID || undefined },
+				roles: {},
+			};
+			return html.replaceAll('[[.BootSettings]]', JSON.stringify(bootSettings));
+		},
+	};
+}
+
 function rawMarkdownPlugin(): Plugin {
 	return {
 		name: 'raw-markdown',
@@ -47,15 +69,8 @@ export default defineConfig(({ mode }): UserConfig => {
 		tsconfigPaths(),
 		rawMarkdownPlugin(),
 		devBasePathPlugin(basePath),
+		devBootDataPlugin(env),
 		react(),
-		createHtmlPlugin({
-			inject: {
-				data: {
-					PYLON_APP_ID: env.VITE_PYLON_APP_ID || '',
-					APPCUES_APP_ID: env.VITE_APPCUES_APP_ID || '',
-				},
-			},
-		}),
 		vitePluginChecker({
 			typescript: true,
 			// this doubles the build tim
@@ -126,17 +141,8 @@ export default defineConfig(({ mode }): UserConfig => {
 			'process.env.WEBSOCKET_API_ENDPOINT': JSON.stringify(
 				env.VITE_WEBSOCKET_API_ENDPOINT,
 			),
-			'process.env.PYLON_APP_ID': JSON.stringify(env.VITE_PYLON_APP_ID),
-			'process.env.PYLON_IDENTITY_SECRET': JSON.stringify(
-				env.VITE_PYLON_IDENTITY_SECRET,
-			),
-			'process.env.APPCUES_APP_ID': JSON.stringify(env.VITE_APPCUES_APP_ID),
-			'process.env.POSTHOG_KEY': JSON.stringify(env.VITE_POSTHOG_KEY),
 			'process.env.SENTRY_ORG': JSON.stringify(env.VITE_SENTRY_ORG),
 			'process.env.SENTRY_PROJECT_ID': JSON.stringify(env.VITE_SENTRY_PROJECT_ID),
-			'process.env.SENTRY_DSN': JSON.stringify(env.VITE_SENTRY_DSN),
-			'process.env.TUNNEL_URL': JSON.stringify(env.VITE_TUNNEL_URL),
-			'process.env.TUNNEL_DOMAIN': JSON.stringify(env.VITE_TUNNEL_DOMAIN),
 			'process.env.DOCS_BASE_URL': JSON.stringify(env.VITE_DOCS_BASE_URL),
 		},
 		// In production, use relative paths so assets work with any base path injected by the backend.

pkg/query-service/app/integrations/builtin.go

@@ -7,8 +7,6 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/SigNoz/signoz/pkg/query-service/constants"
-
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -178,27 +176,6 @@ func HydrateFileUris(spec interface{}, fs embed.FS, basedir string) (interface{}
 	if specMap, ok := spec.(map[string]interface{}); ok {
 		result := map[string]interface{}{}
 		for k, v := range specMap {
-			// Check if this is a dashboards slice and if dot metrics are enabled
-			if k == "dashboards" && constants.IsDotMetricsEnabled {
-				if dashboards, ok := v.([]interface{}); ok {
-					for i, dashboard := range dashboards {
-						if dashboardUri, ok := dashboard.(string); ok {
-							if strings.HasPrefix(dashboardUri, "file://") {
-								dashboards[i] = strings.Replace(dashboardUri, ".json", "_dot.json", 1)
-							}
-						} else if dashBoardMap, ok := dashboard.(map[string]interface{}); ok {
-							if dashboardUri, ok := dashBoardMap["definition"].(string); ok {
-								if strings.HasPrefix(dashboardUri, "file://") {
-									dashboardUri = strings.Replace(dashboardUri, ".json", "_dot.json", 1)
-								}
-								dashBoardMap["definition"] = dashboardUri
-							}
-							dashboards[i] = dashBoardMap
-						}
-					}
-					v = dashboards
-				}
-			}
 			hydrated, err := HydrateFileUris(v, fs, basedir)
 			if err != nil {
 				return nil, err

pkg/query-service/app/integrations/builtin_integrations/aws_rds_mysql/assets/dashboards/db_metrics.json

@@ -367,9 +367,9 @@
             "id": "31d3f13b-27d5-4291-9fb3-d5d5708a72f3",
             "modificationUUID": "e4a9edf1-acd0-48b7-8a35-1b4bb668408d",
             "multiSelect": false,
-            "name": "mysql_instance_endpoint",
+            "name": "mysql.instance.endpoint",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'mysql_instance_endpoint') as mysql_instance_endpoint\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'mysql_uptime'\nGROUP BY mysql_instance_endpoint",
+            "queryValue": "SELECT JSONExtractString(labels, 'mysql.instance.endpoint') as `mysql.instance.endpoint`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'mysql.uptime'\nGROUP BY `mysql.instance.endpoint`",
             "selectedValue": "",
             "showALLOption": false,
             "sort": "ASC",
@@ -393,7 +393,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_buffer_pool_usage",
+                                    "metricName": "mysql.buffer_pool.pages",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -404,7 +404,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -529,7 +529,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_buffer_pool_pages",
+                                    "metricName": "mysql.buffer_pool.pages",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -540,7 +540,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -658,7 +658,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_buffer_pool_data_pages",
+                                    "metricName": "mysql.buffer_pool.data_pages",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -669,7 +669,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -788,7 +788,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_buffer_pool_page_flushes",
+                                    "metricName": "mysql.buffer_pool.page_flushes",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -799,7 +799,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [],
@@ -915,7 +915,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_table_io_wait_count",
+                                    "metricName": "mysql.table.io.wait.count",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -926,7 +926,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1045,7 +1045,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_table_io_wait_count",
+                                    "metricName": "mysql.table.io.wait.count",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1056,7 +1056,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1175,7 +1175,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_table_io_wait_count",
+                                    "metricName": "mysql.table.io.wait.count",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1186,7 +1186,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1305,7 +1305,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_handlers",
+                                    "metricName": "mysql.handlers",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1316,7 +1316,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1329,7 +1329,7 @@
                                 }
                             ],
                             "having": {
-                                "expression": "sum(mysql_handlers) \u003e 0"
+                                "expression": "sum(mysql.handlers) \u003e 0"
                             },
                             "legend": "{{kind}}",
                             "limit": null,
@@ -1434,7 +1434,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_locks",
+                                    "metricName": "mysql.locks",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1445,7 +1445,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1563,7 +1563,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_log_operations",
+                                    "metricName": "mysql.log_operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1574,7 +1574,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1693,7 +1693,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_connection_count",
+                                    "metricName": "mysql.connection.count",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1704,7 +1704,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [],
@@ -1720,7 +1720,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_connection_errors",
+                                    "metricName": "mysql.connection.errors",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1731,7 +1731,7 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1745,7 +1745,7 @@
                                 }
                             ],
                             "having": {
-                                "expression": "sum(mysql_connection_errors) \u003e 0"
+                                "expression": "sum(mysql.connection.errors) \u003e 0"
                             },
                             "legend": "Error count: {{error}}",
                             "limit": null,
@@ -1850,7 +1850,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_opened_resources",
+                                    "metricName": "mysql.opened_resources",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1861,7 +1861,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -1874,7 +1874,7 @@
                                 }
                             ],
                             "having": {
-                                "expression": "sum(mysql_opened_resources) \u003e 0"
+                                "expression": "sum(mysql.opened_resources) \u003e 0"
                             },
                             "legend": "{{kind}}",
                             "limit": null,
@@ -1979,7 +1979,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_operations",
+                                    "metricName": "mysql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1990,7 +1990,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -2109,7 +2109,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_row_locks",
+                                    "metricName": "mysql.row_locks",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -2120,7 +2120,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -2238,7 +2238,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_threads",
+                                    "metricName": "mysql.threads",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -2249,7 +2249,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -2367,7 +2367,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_row_operations",
+                                    "metricName": "mysql.row_operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -2378,7 +2378,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [
@@ -2497,7 +2497,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mysql_prepared_statements",
+                                    "metricName": "mysql.prepared_statements",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -2508,7 +2508,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "mysql_instance_endpoint = $mysql_instance_endpoint"
+                                "expression": "mysql.instance.endpoint = $mysql.instance.endpoint"
                             },
                             "functions": [],
                             "groupBy": [

pkg/query-service/app/integrations/builtin_integrations/aws_rds_postgres/assets/dashboards/db_metrics_overview.json

@@ -287,7 +287,7 @@
             "multiSelect": true,
             "name": "table_name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'postgresql_table_name') AS table_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql_operations' AND JSONExtractString(labels, 'postgresql_database_name') IN {{.db_name}}\nGROUP BY table_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'postgresql.table.name') AS table_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql.operations' AND JSONExtractString(labels, 'postgresql.database.name') IN {{.db_name}}\nGROUP BY table_name",
             "selectedValue": [
                 "public.pgbench_accounts",
                 "public.pgbench_branches",
@@ -309,7 +309,7 @@
             "multiSelect": true,
             "name": "db_name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'postgresql_database_name') AS db_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql_operations'\nGROUP BY db_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'postgresql.database.name') AS db_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql.operations'\nGROUP BY db_name",
             "selectedValue": [
                 "pgtestdb"
             ],
@@ -335,7 +335,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -346,22 +346,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'ins' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'ins' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -410,7 +410,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -421,22 +421,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'upd' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'upd' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -485,7 +485,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -496,22 +496,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'del' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'del' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -560,7 +560,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -571,22 +571,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'hot_upd' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'hot_upd' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -635,7 +635,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -646,15 +646,15 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'ins' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'ins' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -670,7 +670,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -681,15 +681,15 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "(operation = 'upd' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'upd' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -705,7 +705,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -716,15 +716,15 @@
                             "disabled": false,
                             "expression": "C",
                             "filter": {
-                                "expression": "(operation = 'del' AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'del' AND postgresql.database.name IN $db_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -780,7 +780,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_database_locks",
+                                    "metricName": "postgresql.database.locks",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -852,7 +852,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_deadlocks",
+                                    "metricName": "postgresql.deadlocks",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -863,22 +863,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "postgresql_database_name IN $db_name"
+                                "expression": "postgresql.database.name IN $db_name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -927,7 +927,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_backends",
+                                    "metricName": "postgresql.backends",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -938,22 +938,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "postgresql_database_name IN $db_name"
+                                "expression": "postgresql.database.name IN $db_name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -1002,7 +1002,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1013,7 +1013,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(state = 'dead' AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'dead' AND postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "groupBy": [],
                             "having": {
@@ -1068,7 +1068,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_index_scans",
+                                    "metricName": "postgresql.index.scans",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1079,22 +1079,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_index_name--string--tag--false",
+                                    "id": "postgresql.index.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_index_name",
+                                    "key": "postgresql.index.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_index_name}}",
+                            "legend": "{{postgresql.index.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -1143,7 +1143,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1154,16 +1154,16 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(state = 'dead' AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'dead' AND postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "functions": [],
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1179,7 +1179,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1190,16 +1190,16 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "(state = 'live' AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'live' AND postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "functions": [],
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1215,7 +1215,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_index_scans",
+                                    "metricName": "postgresql.index.scans",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1226,16 +1226,16 @@
                             "disabled": false,
                             "expression": "C",
                             "filter": {
-                                "expression": "(postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "functions": [],
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1251,7 +1251,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_table_size",
+                                    "metricName": "postgresql.table.size",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1262,16 +1262,16 @@
                             "disabled": true,
                             "expression": "D",
                             "filter": {
-                                "expression": "(postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(postgresql.database.name IN $db_name AND postgresql.table.name IN $table_name)"
                             },
                             "functions": [],
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],

pkg/query-service/app/integrations/builtin_integrations/mongo/assets/dashboards/overview.json

@@ -80,9 +80,9 @@
             "id": "a2c21714-a814-4d31-9b56-7367c3208801",
             "modificationUUID": "448e675a-4531-45b1-b434-a9ee809470d6",
             "multiSelect": true,
-            "name": "host_name",
+            "name": "host.name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'host_name') AS host_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'mongodb_memory_usage'\nGROUP BY host_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'host.name') AS `host.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'mongodb_memory_usage'\nGROUP BY `host.name`",
             "selectedValue": [
                 "Srikanths-MacBook-Pro.local"
             ],
@@ -108,7 +108,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_operation_count",
+                                    "metricName": "mongodb.operation.count",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -119,7 +119,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
@@ -183,7 +183,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_operation_time",
+                                    "metricName": "mongodb.operation.time",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -194,7 +194,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
@@ -258,7 +258,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_cache_operations",
+                                    "metricName": "mongodb.cache.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -269,7 +269,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
@@ -333,7 +333,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_operation_latency_time",
+                                    "metricName": "mongodb.operation.latency.time",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "max",
                                     "temporality": null,
@@ -344,7 +344,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'read' AND host_name IN $host_name)"
+                                "expression": "(operation = 'read' AND host.name IN $host.name)"
                             },
                             "groupBy": [],
                             "having": {
@@ -399,7 +399,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_operation_latency_time",
+                                    "metricName": "mongodb.operation.latency.time",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "max",
                                     "temporality": null,
@@ -410,7 +410,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND operation = 'write')"
+                                "expression": "(host.name IN $host.name AND operation = 'write')"
                             },
                             "groupBy": [],
                             "having": {
@@ -465,7 +465,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_operation_latency_time",
+                                    "metricName": "mongodb.operation.latency.time",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "max",
                                     "temporality": null,
@@ -476,7 +476,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND operation = 'command')"
+                                "expression": "(host.name IN $host.name AND operation = 'command')"
                             },
                             "groupBy": [],
                             "having": {
@@ -531,7 +531,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_network_io_receive",
+                                    "metricName": "mongodb.network.io.receive",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -542,22 +542,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Bytes received :: {{host_name}}",
+                            "legend": "Bytes received :: {{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -566,7 +566,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "mongodb_network_io_transmit",
+                                    "metricName": "mongodb.network.io.transmit",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -577,22 +577,22 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Bytes transmitted :: {{host_name}}",
+                            "legend": "Bytes transmitted :: {{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "B",

pkg/query-service/app/integrations/builtin_integrations/mongo/assets/dashboards/overview_dot.json

@@ -1,631 +0,0 @@
-{
-    "description": "This dashboard provides a high-level overview of your MongoDB. It includes read/write performance, most-used replicas, collection metrics etc...",
-    "id": "mongo-overview",
-    "layout": [
-        {
-            "h": 3,
-            "i": "0c3d2b15-89be-4d62-a821-b26d93332ed3",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 3
-        },
-        {
-            "h": 3,
-            "i": "14504a3c-4a05-4d22-bab3-e22e94f51380",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 6
-        },
-        {
-            "h": 3,
-            "i": "dcfb3829-c3f2-44bb-907d-8dc8a6dc4aab",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 3
-        },
-        {
-            "h": 3,
-            "i": "bfc9e80b-02bf-4122-b3da-3dd943d35012",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 0
-        },
-        {
-            "h": 3,
-            "i": "4c07a7d2-893a-46c2-bcdb-a19b6efeac3a",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 0
-        },
-        {
-            "h": 3,
-            "i": "a5a64eec-1034-4aa6-8cb1-05673c4426c6",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 6
-        },
-        {
-            "h": 3,
-            "i": "503af589-ef4d-4fe3-8934-c8f7eb480d9a",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 9
-        }
-    ],
-    "name": "",
-    "tags": [
-        "mongo",
-        "database"
-    ],
-    "title": "Mongo overview",
-    "variables": {
-        "a2c21714-a814-4d31-9b56-7367c3208801": {
-            "allSelected": true,
-            "customValue": "",
-            "description": "List of hosts sending mongo metrics",
-            "id": "a2c21714-a814-4d31-9b56-7367c3208801",
-            "modificationUUID": "448e675a-4531-45b1-b434-a9ee809470d6",
-            "multiSelect": true,
-            "name": "host.name",
-            "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'host.name') AS `host.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'mongodb_memory_usage'\nGROUP BY `host.name`",
-            "selectedValue": [
-                "Srikanths-MacBook-Pro.local"
-            ],
-            "showALLOption": true,
-            "sort": "ASC",
-            "textboxValue": "",
-            "type": "QUERY"
-        }
-    },
-    "version": "v5",
-    "widgets": [
-        {
-            "description": "Total number of operations",
-            "fillSpans": false,
-            "id": "4c07a7d2-893a-46c2-bcdb-a19b6efeac3a",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.operation.count",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "rate"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "operation--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "operation",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "{{operation}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "7da5d899-8b06-4139-9a89-47baf9551ff8",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Operations count",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "The total time spent performing operations.",
-            "fillSpans": false,
-            "id": "bfc9e80b-02bf-4122-b3da-3dd943d35012",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.operation.time",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "rate"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "operation--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "operation",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "{{operation}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "2ca35957-894a-46ae-a2a6-95d7e400d8e1",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Total operations time",
-            "yAxisUnit": "ms"
-        },
-        {
-            "description": "The number of cache operations",
-            "fillSpans": false,
-            "id": "dcfb3829-c3f2-44bb-907d-8dc8a6dc4aab",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.cache.operations",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "rate"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "type--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "type",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "{{type}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "bb439198-dcf5-4767-b0d0-ab5785159b8d",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Cache operations",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "14504a3c-4a05-4d22-bab3-e22e94f51380",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.operation.latency.time",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "max",
-                                    "temporality": null,
-                                    "timeAggregation": "max"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "(operation = 'read' AND host.name IN $host.name)"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Latency",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "4a9cafe8-778b-476c-b825-c04e165bf285",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Read latency",
-            "yAxisUnit": "µs"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "a5a64eec-1034-4aa6-8cb1-05673c4426c6",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.operation.latency.time",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "max",
-                                    "temporality": null,
-                                    "timeAggregation": "max"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "(host.name IN $host.name AND operation = 'write')"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Latency",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "446827eb-a4f2-4ff3-966b-fb65288c983b",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Write latency",
-            "yAxisUnit": "µs"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "503af589-ef4d-4fe3-8934-c8f7eb480d9a",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.operation.latency.time",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "max",
-                                    "temporality": null,
-                                    "timeAggregation": "max"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "(host.name IN $host.name AND operation = 'command')"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Latency",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "7b7b977d-0921-4552-8cfe-d82dfde63ef4",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Command latency",
-            "yAxisUnit": "µs"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "0c3d2b15-89be-4d62-a821-b26d93332ed3",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.network.io.receive",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "avg",
-                                    "temporality": null,
-                                    "timeAggregation": "avg"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Bytes received :: {{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        },
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "mongodb.network.io.transmit",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "avg",
-                                    "temporality": null,
-                                    "timeAggregation": "avg"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "B",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Bytes transmitted :: {{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "B",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "41eea5bc-f9cf-45c2-92fb-ef226d6b540b",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Network IO",
-            "yAxisUnit": "bytes"
-        }
-    ]
-}

pkg/query-service/app/integrations/builtin_integrations/postgres/assets/dashboards/overview.json

@@ -117,9 +117,9 @@
             "key": "4250ef7b-8f42-4a24-902a-a764d070b92d",
             "modificationUUID": "4427b655-c8d2-40ce-84ed-7cb058bd3041",
             "multiSelect": true,
-            "name": "host_name",
+            "name": "host.name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'host_name') AS host_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql_operations'\nGROUP BY host_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'host.name') AS `host.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql.operations'\nGROUP BY `host.name`",
             "selectedValue": [
                 "Srikanths-MacBook-Pro.local"
             ],
@@ -135,9 +135,9 @@
             "id": "8ecaee70-640f-46fd-83d9-a4fd18bc66e6",
             "modificationUUID": "a51321cd-47a2-470a-8df4-372e5bb36f2c",
             "multiSelect": true,
-            "name": "table_name",
+            "name": "table.name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'postgresql_table_name') AS table_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql_operations' AND JSONExtractString(labels, 'postgresql_database_name') IN {{.db_name}}\nGROUP BY table_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'postgresql.table.name') AS `table.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql.operations' AND JSONExtractString(labels, 'postgresql.database.name') IN {{.db.name}}\nGROUP BY `table.name`",
             "selectedValue": [
                 "public.activations",
                 "public.licenses",
@@ -160,9 +160,9 @@
             "key": "c66d1581-e5e1-440d-8ff6-ebcf078ab6dd",
             "modificationUUID": "564a3f43-98f8-4189-b5e4-dcb518d73852",
             "multiSelect": true,
-            "name": "db_name",
+            "name": "db.name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'postgresql_database_name') AS db_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql_operations'\nGROUP BY db_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'postgresql.database.name') AS `db.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'postgresql.operations'\nGROUP BY `db.name`",
             "selectedValue": [
                 "postgres"
             ],
@@ -188,7 +188,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -199,22 +199,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'ins' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'ins' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -263,7 +263,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -274,22 +274,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'upd' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'upd' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -338,7 +338,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -349,22 +349,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'del' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'del' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -413,7 +413,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -424,22 +424,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'hot_upd' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'hot_upd' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -488,7 +488,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -499,15 +499,15 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(operation = 'ins' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'ins' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -523,7 +523,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -534,15 +534,15 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "(operation = 'upd' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'upd' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -558,7 +558,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_operations",
+                                    "metricName": "postgresql.operations",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -569,15 +569,15 @@
                             "disabled": false,
                             "expression": "C",
                             "filter": {
-                                "expression": "(operation = 'del' AND host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(operation = 'del' AND host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
@@ -633,7 +633,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_database_locks",
+                                    "metricName": "postgresql.database.locks",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -644,7 +644,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
@@ -708,7 +708,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_deadlocks",
+                                    "metricName": "postgresql.deadlocks",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -719,22 +719,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -783,7 +783,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_backends",
+                                    "metricName": "postgresql.backends",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -794,22 +794,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND postgresql_database_name IN $db_name)"
+                                "expression": "(host.name IN $host.name AND postgresql.database.name IN $db.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_database_name--string--tag--false",
+                                    "id": "postgresql.database.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_database_name",
+                                    "key": "postgresql.database.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_database_name}}",
+                            "legend": "{{postgresql.database.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -858,7 +858,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -869,7 +869,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(state = 'dead' AND host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'dead' AND host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [],
                             "having": {
@@ -924,7 +924,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_index_scans",
+                                    "metricName": "postgresql.index.scans",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -935,22 +935,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_index_name--string--tag--false",
+                                    "id": "postgresql.index.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_index_name",
+                                    "key": "postgresql.index.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "{{postgresql_index_name}}",
+                            "legend": "{{postgresql.index.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -999,7 +999,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1010,15 +1010,15 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "(state = 'dead' AND host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'dead' AND host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1034,7 +1034,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_rows",
+                                    "metricName": "postgresql.rows",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1045,15 +1045,15 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "(state = 'live' AND host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(state = 'live' AND host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1069,7 +1069,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_index_scans",
+                                    "metricName": "postgresql.index.scans",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -1080,15 +1080,15 @@
                             "disabled": false,
                             "expression": "C",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],
@@ -1104,7 +1104,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "postgresql_table_size",
+                                    "metricName": "postgresql.table.size",
                                     "reduceTo": "avg",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -1115,15 +1115,15 @@
                             "disabled": false,
                             "expression": "D",
                             "filter": {
-                                "expression": "(host_name IN $host_name AND postgresql_database_name IN $db_name AND postgresql_table_name IN $table_name)"
+                                "expression": "(host.name IN $host.name AND postgresql.database.name IN $db.name AND postgresql.table.name IN $table.name)"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "postgresql_table_name--string--tag--false",
+                                    "id": "postgresql.table.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "postgresql_table_name",
+                                    "key": "postgresql.table.name",
                                     "type": "tag"
                                 }
                             ],

pkg/query-service/app/integrations/builtin_integrations/redis/assets/dashboards/overview.json

@@ -99,9 +99,9 @@
             "key": "94f19b3c-ad9f-4b47-a9b2-f312c09fa965",
             "modificationUUID": "4c5b0c03-9cbc-425b-8d8e-7152e5c39ba8",
             "multiSelect": true,
-            "name": "host_name",
+            "name": "host.name",
             "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'host_name') AS host_name\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'redis_cpu_time'\nGROUP BY host_name",
+            "queryValue": "SELECT JSONExtractString(labels, 'host.name') AS  `host.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'redis.cpu.time'\nGROUP BY `host.name`",
             "selectedValue": [
                 "Srikanths-MacBook-Pro.local"
             ],
@@ -127,7 +127,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_keyspace_hits",
+                                    "metricName": "redis.keyspace.hits",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -138,7 +138,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [],
                             "having": {
@@ -193,7 +193,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_clients_blocked",
+                                    "metricName": "redis.clients.blocked",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -204,7 +204,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [],
                             "having": {
@@ -259,7 +259,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_db_keys",
+                                    "metricName": "redis.db.keys",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -322,7 +322,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_rdb_changes_since_last_save",
+                                    "metricName": "redis.rdb.changes_since_last_save",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -333,7 +333,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [],
                             "having": {
@@ -388,7 +388,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_commands",
+                                    "metricName": "redis.commands",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -399,7 +399,7 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [],
                             "having": {
@@ -454,7 +454,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_memory_used",
+                                    "metricName": "redis.memory.used",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -465,22 +465,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Used::{{host_name}}",
+                            "legend": "Used::{{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -489,7 +489,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_maxmemory",
+                                    "metricName": "redis.maxmemory",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "max",
                                     "temporality": null,
@@ -500,22 +500,22 @@
                             "disabled": false,
                             "expression": "B",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Max::{{host_name}}",
+                            "legend": "Max::{{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "B",
@@ -564,7 +564,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_memory_rss",
+                                    "metricName": "redis.memory.rss",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -575,22 +575,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Rss::{{host_name}}",
+                            "legend": "Rss::{{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -639,7 +639,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_memory_fragmentation_ratio",
+                                    "metricName": "redis.memory.fragmentation_ratio",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "avg",
                                     "temporality": null,
@@ -650,22 +650,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Rss::{{host_name}}",
+                            "legend": "Rss::{{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",
@@ -714,7 +714,7 @@
                         {
                             "aggregations": [
                                 {
-                                    "metricName": "redis_keys_evicted",
+                                    "metricName": "redis.keys.evicted",
                                     "reduceTo": "sum",
                                     "spaceAggregation": "sum",
                                     "temporality": null,
@@ -725,22 +725,22 @@
                             "disabled": false,
                             "expression": "A",
                             "filter": {
-                                "expression": "host_name IN $host_name"
+                                "expression": "host.name IN $host.name"
                             },
                             "groupBy": [
                                 {
                                     "dataType": "string",
-                                    "id": "host_name--string--tag--false",
+                                    "id": "host.name--string--tag--false",
                                     "isColumn": false,
                                     "isJSON": false,
-                                    "key": "host_name",
+                                    "key": "host.name",
                                     "type": "tag"
                                 }
                             ],
                             "having": {
                                 "expression": ""
                             },
-                            "legend": "Rss::{{host_name}}",
+                            "legend": "Rss::{{host.name}}",
                             "limit": null,
                             "orderBy": [],
                             "queryName": "A",

pkg/query-service/app/integrations/builtin_integrations/redis/assets/dashboards/overview_dot.json

@@ -1,779 +0,0 @@
-{
-    "description": "This dashboard shows the Redis instance overview. It includes latency, hit/miss rate, connections, and memory information.\n",
-    "id": "redis-overview",
-    "layout": [
-        {
-            "h": 3,
-            "i": "d4c164bc-8fc2-4dbc-aadd-8d17479ca649",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 9
-        },
-        {
-            "h": 3,
-            "i": "2fbaef0d-3cdb-4ce3-aa3c-9bbbb41786d9",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 3,
-            "y": 6
-        },
-        {
-            "h": 3,
-            "i": "f5ee1511-0d2b-4404-9ce0-e991837decc2",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 3
-        },
-        {
-            "h": 3,
-            "i": "b19c7058-b806-4ea2-974a-ca555b168991",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 3
-        },
-        {
-            "h": 3,
-            "i": "bf0deeeb-e926-4234-944c-82bacd96af47",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 0
-        },
-        {
-            "h": 3,
-            "i": "a77227c7-16f5-4353-952e-b183c715a61c",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 0
-        },
-        {
-            "h": 3,
-            "i": "9698cee2-b1f3-4c0b-8c9f-3da4f0e05f17",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 9
-        },
-        {
-            "h": 3,
-            "i": "64a5f303-d7db-44ff-9a0e-948e5c653320",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 0,
-            "y": 12
-        },
-        {
-            "h": 3,
-            "i": "3e80a918-69af-4c9a-bc57-a94e1d41b05c",
-            "moved": false,
-            "static": false,
-            "w": 6,
-            "x": 6,
-            "y": 12
-        }
-    ],
-    "name": "",
-    "tags": [
-        "redis",
-        "database"
-    ],
-    "title": "Redis overview",
-    "variables": {
-        "94f19b3c-ad9f-4b47-a9b2-f312c09fa965": {
-            "allSelected": true,
-            "customValue": "",
-            "description": "List of hosts sending Redis metrics",
-            "id": "94f19b3c-ad9f-4b47-a9b2-f312c09fa965",
-            "key": "94f19b3c-ad9f-4b47-a9b2-f312c09fa965",
-            "modificationUUID": "4c5b0c03-9cbc-425b-8d8e-7152e5c39ba8",
-            "multiSelect": true,
-            "name": "host.name",
-            "order": 0,
-            "queryValue": "SELECT JSONExtractString(labels, 'host.name') AS  `host.name`\nFROM signoz_metrics.distributed_time_series_v4_1day\nWHERE metric_name = 'redis.cpu.time'\nGROUP BY `host.name`",
-            "selectedValue": [
-                "Srikanths-MacBook-Pro.local"
-            ],
-            "showALLOption": true,
-            "sort": "ASC",
-            "textboxValue": "",
-            "type": "QUERY"
-        }
-    },
-    "version": "v5",
-    "widgets": [
-        {
-            "description": "Rate successful lookup of keys in the main dictionary",
-            "fillSpans": false,
-            "id": "a77227c7-16f5-4353-952e-b183c715a61c",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.keyspace.hits",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "rate"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Hit/s across all hosts",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "42c9c117-bfaf-49f7-b528-aad099392295",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Hits/s",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "Number of clients pending on a blocking call",
-            "fillSpans": false,
-            "id": "bf0deeeb-e926-4234-944c-82bacd96af47",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.clients.blocked",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Blocked clients across all hosts",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "b77a9e11-fb98-4a95-88a8-c3ad25c14369",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Clients blocked",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "b19c7058-b806-4ea2-974a-ca555b168991",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.db.keys",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "b77a9e11-fb98-4a95-88a8-c3ad25c14369",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Keyspace Keys",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "Number of changes since the last dump",
-            "fillSpans": false,
-            "id": "f5ee1511-0d2b-4404-9ce0-e991837decc2",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.rdb.changes_since_last_save",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Number of unsaved changes",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "32cedddf-606d-4de1-8c1d-4b7049e6430c",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Unsaved changes",
-            "yAxisUnit": "none"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "2fbaef0d-3cdb-4ce3-aa3c-9bbbb41786d9",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.commands",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "ops/s",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "c70de4dd-a68a-42df-a249-6610c296709c",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Command/s",
-            "yAxisUnit": "ops"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "d4c164bc-8fc2-4dbc-aadd-8d17479ca649",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.memory.used",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Used::{{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        },
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.maxmemory",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "max",
-                                    "temporality": null,
-                                    "timeAggregation": "max"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "B",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Max::{{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "B",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "2f47df76-f09e-4152-8623-971f0fe66bfe",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Memory usage",
-            "yAxisUnit": "bytes"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "9698cee2-b1f3-4c0b-8c9f-3da4f0e05f17",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.memory.rss",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "sum"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Rss::{{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "fddd043c-1385-481c-9f4c-381f261e1dd9",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "RSS Memory",
-            "yAxisUnit": "bytes"
-        },
-        {
-            "description": "",
-            "fillSpans": false,
-            "id": "64a5f303-d7db-44ff-9a0e-948e5c653320",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.memory.fragmentation_ratio",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "avg",
-                                    "temporality": null,
-                                    "timeAggregation": "avg"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Rss::{{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "3e802b07-0249-4d79-a5c7-6580ab535ad0",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Fragmentation ratio",
-            "yAxisUnit": "short"
-        },
-        {
-            "description": "Number of evicted keys due to maxmemory limit",
-            "fillSpans": false,
-            "id": "3e80a918-69af-4c9a-bc57-a94e1d41b05c",
-            "isStacked": false,
-            "nullZeroValues": "zero",
-            "opacity": "1",
-            "panelTypes": "graph",
-            "query": {
-                "builder": {
-                    "queryData": [
-                        {
-                            "aggregations": [
-                                {
-                                    "metricName": "redis.keys.evicted",
-                                    "reduceTo": "sum",
-                                    "spaceAggregation": "sum",
-                                    "temporality": null,
-                                    "timeAggregation": "rate"
-                                }
-                            ],
-                            "dataSource": "metrics",
-                            "disabled": false,
-                            "expression": "A",
-                            "filter": {
-                                "expression": "host.name IN $host.name"
-                            },
-                            "groupBy": [
-                                {
-                                    "dataType": "string",
-                                    "id": "host.name--string--tag--false",
-                                    "isColumn": false,
-                                    "isJSON": false,
-                                    "key": "host.name",
-                                    "type": "tag"
-                                }
-                            ],
-                            "having": {
-                                "expression": ""
-                            },
-                            "legend": "Rss::{{host.name}}",
-                            "limit": null,
-                            "orderBy": [],
-                            "queryName": "A",
-                            "stepInterval": 60
-                        }
-                    ],
-                    "queryFormulas": []
-                },
-                "clickhouse_sql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "id": "15d1d9d7-eb10-464b-aa7b-33ff211996f7",
-                "promql": [
-                    {
-                        "disabled": false,
-                        "legend": "",
-                        "name": "A",
-                        "query": ""
-                    }
-                ],
-                "queryType": "builder"
-            },
-            "softMax": null,
-            "softMin": null,
-            "thresholds": [],
-            "timePreferance": "GLOBAL_TIME",
-            "title": "Eviction rate",
-            "yAxisUnit": "short"
-        }
-    ]
-}