feat(dashboard-v2): panel management — add, delete, move

* test(alerts): add tests for triggered and list alerts page

* test(alerts): add tests for list alerts and triggered alerts

* test(fireEvent): replace by userEvent

frontend/__mocks__/useSafeNavigate.ts

@@ -1,28 +0,0 @@
-// Mock for useSafeNavigate hook to avoid React Router version conflicts in tests
-interface SafeNavigateOptions {
-	replace?: boolean;
-	state?: unknown;
-	newTab?: boolean;
-}
-
-interface SafeNavigateTo {
-	pathname?: string;
-	search?: string;
-	hash?: string;
-}
-
-type SafeNavigateToType = string | SafeNavigateTo;
-
-interface UseSafeNavigateReturn {
-	safeNavigate: jest.MockedFunction<
-		(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
-	>;
-}
-
-export const useSafeNavigate = (): UseSafeNavigateReturn => ({
-	safeNavigate: jest.fn(
-		(_to: SafeNavigateToType, _options?: SafeNavigateOptions) => {},
-	) as jest.MockedFunction<
-		(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
-	>,
-});

frontend/jest.config.ts

@@ -1,6 +1,8 @@
 import type { Config } from '@jest/types';
 
-const USE_SAFE_NAVIGATE_MOCK_PATH = '<rootDir>/__mocks__/useSafeNavigate.ts';
+const USE_SAFE_NAVIGATE_MOCK_PATH =
+	'<rootDir>/src/__tests__/safeNavigateMock.ts';
+const LOG_EVENT_MOCK_PATH = '<rootDir>/src/__tests__/logEventMock.ts';
 
 const config: Config.InitialOptions = {
 	silent: true,
@@ -22,6 +24,8 @@ const config: Config.InitialOptions = {
 		'^hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^src/hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^.*/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
+		'^api/common/logEvent$': LOG_EVENT_MOCK_PATH,
+		'^src/api/common/logEvent$': LOG_EVENT_MOCK_PATH,
 		'^constants/env$': '<rootDir>/__mocks__/env.ts',
 		'^src/constants/env$': '<rootDir>/__mocks__/env.ts',
 		'^@signozhq/icons$': '<rootDir>/__mocks__/signozhqIconsMock.tsx',

frontend/src/__tests__/logEventMock.ts

@@ -0,0 +1,11 @@
+// Shared mock for `api/common/logEvent`.
+// Wired into jest.config.ts moduleNameMapper, so any import of
+// `api/common/logEvent` in test code resolves to this file.
+// Tests can import `logEventMock` to assert analytics calls — Jest's
+// `clearMocks: true` resets call history between tests.
+
+export const logEventMock: jest.MockedFunction<
+	(eventName: string, attributes?: Record<string, unknown>) => void
+> = jest.fn();
+
+export default logEventMock;

frontend/src/__tests__/safeNavigateMock.ts

@@ -0,0 +1,29 @@
+// Shared mock for `hooks/useSafeNavigate`.
+// Wired into jest.config.ts moduleNameMapper, so any import of
+// `hooks/useSafeNavigate` in test code resolves to this file.
+// Tests can import `safeNavigateMock` to assert navigation calls — Jest's
+// `clearMocks: true` resets call history between tests.
+
+interface SafeNavigateOptions {
+	replace?: boolean;
+	state?: unknown;
+	newTab?: boolean;
+}
+
+interface SafeNavigateTo {
+	pathname?: string;
+	search?: string;
+	hash?: string;
+}
+
+type SafeNavigateToType = string | SafeNavigateTo;
+
+export const safeNavigateMock: jest.MockedFunction<
+	(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
+> = jest.fn();
+
+export const useSafeNavigate = (): {
+	safeNavigate: typeof safeNavigateMock;
+} => ({
+	safeNavigate: safeNavigateMock,
+});

frontend/src/components/HeaderRightSection/__tests__/FeedbackModal.test.tsx

@@ -3,17 +3,12 @@ import { useLocation } from 'react-router-dom';
 import { toast } from '@signozhq/ui/sonner';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import logEvent from 'api/common/logEvent';
+import { logEventMock } from '__tests__/logEventMock';
 import { handleContactSupport } from 'container/Integrations/utils';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 
 import FeedbackModal from '../FeedbackModal';
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(() => Promise.resolve()),
-}));
-
 jest.mock('react-router-dom', () => ({
 	...jest.requireActual('react-router-dom'),
 	useLocation: jest.fn(),
@@ -35,7 +30,6 @@ jest.mock('container/Integrations/utils', () => ({
 	handleContactSupport: jest.fn(),
 }));
 
-const mockLogEvent = logEvent as jest.MockedFunction<typeof logEvent>;
 const mockUseLocation = useLocation as jest.Mock;
 const mockUseGetTenantLicense = useGetTenantLicense as jest.Mock;
 const mockHandleContactSupport = handleContactSupport as jest.Mock;
@@ -50,6 +44,7 @@ const mockLocation = {
 describe('FeedbackModal', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
+		logEventMock.mockReturnValue(Promise.resolve() as never);
 		mockUseLocation.mockReturnValue(mockLocation);
 		mockUseGetTenantLicense.mockReturnValue({
 			isCloudUser: false,
@@ -116,7 +111,7 @@ describe('FeedbackModal', () => {
 		await user.type(textarea, testFeedback);
 		await user.click(submitButton);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Feedback: Submitted', {
+		expect(logEventMock).toHaveBeenCalledWith('Feedback: Submitted', {
 			data: testFeedback,
 			type: 'feedback',
 			page: mockLocation.pathname,
@@ -149,7 +144,7 @@ describe('FeedbackModal', () => {
 		await user.type(textarea, testFeedback);
 		await user.click(submitButton);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Feedback: Submitted', {
+		expect(logEventMock).toHaveBeenCalledWith('Feedback: Submitted', {
 			data: testFeedback,
 			type: 'reportBug',
 			page: mockLocation.pathname,
@@ -182,7 +177,7 @@ describe('FeedbackModal', () => {
 		await user.type(textarea, testFeedback);
 		await user.click(submitButton);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Feedback: Submitted', {
+		expect(logEventMock).toHaveBeenCalledWith('Feedback: Submitted', {
 			data: testFeedback,
 			type: 'featureRequest',
 			page: mockLocation.pathname,

frontend/src/components/HeaderRightSection/__tests__/HeaderRightSection.test.tsx

@@ -2,16 +2,11 @@
 import { useLocation } from 'react-router-dom';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import logEvent from 'api/common/logEvent';
+import { logEventMock } from '__tests__/logEventMock';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 
 import HeaderRightSection from '../HeaderRightSection';
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('react-router-dom', () => ({
 	...jest.requireActual('react-router-dom'),
 	useLocation: jest.fn(),
@@ -50,7 +45,6 @@ jest.mock('hooks/useIsAIAssistantEnabled', () => ({
 	useIsAIAssistantEnabled: (): boolean => false,
 }));
 
-const mockLogEvent = logEvent as jest.Mock;
 const mockUseLocation = useLocation as jest.Mock;
 const mockUseGetTenantLicense = useGetTenantLicense as jest.Mock;
 
@@ -120,7 +114,7 @@ describe('HeaderRightSection', () => {
 
 		await user.click(feedbackButton!);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Feedback: Clicked', {
+		expect(logEventMock).toHaveBeenCalledWith('Feedback: Clicked', {
 			page: mockLocation.pathname,
 		});
 		expect(screen.getByTestId('feedback-modal')).toBeInTheDocument();
@@ -133,7 +127,7 @@ describe('HeaderRightSection', () => {
 		const shareButton = screen.getByRole('button', { name: /share/i });
 		await user.click(shareButton);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Share: Clicked', {
+		expect(logEventMock).toHaveBeenCalledWith('Share: Clicked', {
 			page: mockLocation.pathname,
 		});
 		expect(screen.getByTestId('share-modal')).toBeInTheDocument();
@@ -150,7 +144,7 @@ describe('HeaderRightSection', () => {
 
 		await user.click(announcementsButton!);
 
-		expect(mockLogEvent).toHaveBeenCalledWith('Announcements: Clicked', {
+		expect(logEventMock).toHaveBeenCalledWith('Announcements: Clicked', {
 			page: mockLocation.pathname,
 		});
 	});

frontend/src/components/HeaderRightSection/__tests__/ShareURLModal.test.tsx

@@ -5,18 +5,13 @@ import { matchPath, useLocation } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import logEvent from 'api/common/logEvent';
+import { logEventMock } from '__tests__/logEventMock';
 import ROUTES from 'constants/routes';
 import useUrlQuery from 'hooks/useUrlQuery';
 import GetMinMax from 'lib/getMinMax';
 
 import ShareURLModal from '../ShareURLModal';
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('react-router-dom', () => ({
 	...jest.requireActual('react-router-dom'),
 	useLocation: jest.fn(),
@@ -53,7 +48,6 @@ Object.defineProperty(window, 'location', {
 	writable: true,
 });
 
-const mockLogEvent = logEvent as jest.Mock;
 const mockUseLocation = useLocation as jest.Mock;
 const mockUseUrlQuery = useUrlQuery as jest.Mock;
 const mockUseSelector = useSelector as jest.Mock;
@@ -125,7 +119,7 @@ describe('ShareURLModal', () => {
 		await user.click(copyButton);
 
 		expect(mockHandleCopyToClipboard).toHaveBeenCalled();
-		expect(mockLogEvent).toHaveBeenCalledWith('Share: Copy link clicked', {
+		expect(logEventMock).toHaveBeenCalledWith('Share: Copy link clicked', {
 			page: TEST_PATH,
 			URL: expect.any(String),
 		});

frontend/src/components/cmdKPalette/__test__/cmdkPalette.test.tsx

@@ -139,7 +139,6 @@ jest.mock('react-query', (): unknown => {
 });
 
 // mock other side-effecty modules
-jest.mock('api/common/logEvent', () => jest.fn());
 jest.mock('api/browser/localstorage/set', () => jest.fn());
 jest.mock('utils/error', () => ({ showErrorNotification: jest.fn() }));
 

frontend/src/container/AppLayout/__tests__/sidebar-toggle-shortcut.test.tsx

@@ -1,7 +1,7 @@
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import logEvent from 'api/common/logEvent';
+import { logEventMock } from '__tests__/logEventMock';
 import { GlobalShortcuts } from 'constants/shortcuts/globalShortcuts';
 import { USER_PREFERENCES } from 'constants/userPreferences';
 import {
@@ -24,8 +24,6 @@ jest.mock('providers/cmdKProvider', () => ({
 	}),
 }));
 
-jest.mock('api/common/logEvent', () => jest.fn());
-
 // Mock the AppContext
 const mockUpdateUserPreferenceInContext = jest.fn();
 
@@ -139,7 +137,7 @@ describe('Sidebar Toggle Shortcut', () => {
 		it('should log the toggle event with correct parameters', async () => {
 			const user = userEvent.setup();
 			const mockHandleShortcut = jest.fn(() => {
-				logEvent('Global Shortcut: Sidebar Toggle', {
+				logEventMock('Global Shortcut: Sidebar Toggle', {
 					previousState: false,
 					newState: true,
 				});
@@ -155,10 +153,13 @@ describe('Sidebar Toggle Shortcut', () => {
 
 			await user.keyboard(SHIFT_B_KEYBOARD_SHORTCUT);
 
-			expect(logEvent).toHaveBeenCalledWith('Global Shortcut: Sidebar Toggle', {
-				previousState: false,
-				newState: true,
-			});
+			expect(logEventMock).toHaveBeenCalledWith(
+				'Global Shortcut: Sidebar Toggle',
+				{
+					previousState: false,
+					newState: true,
+				},
+			);
 		});
 
 		it('should update user preference in context', async () => {

frontend/src/container/DashboardContainer/visualization/panels/components/__tests__/TooltipFooter.test.tsx

@@ -1,16 +1,10 @@
+import { logEventMock } from '__tests__/logEventMock';
 import { Events } from 'constants/events';
 import { DEFAULT_PIN_TOOLTIP_KEY } from 'lib/uPlotV2/plugins/TooltipPlugin/types';
 import { render, screen, userEvent } from 'tests/test-utils';
 
 import TooltipFooter from '../TooltipFooter';
 
-const mockLogEvent = jest.fn();
-
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: (...args: unknown[]): unknown => mockLogEvent(...args),
-}));
-
 describe('TooltipFooter', () => {
 	const defaultProps = {
 		id: 'panel-123',
@@ -84,7 +78,7 @@ describe('TooltipFooter', () => {
 
 			await user.click(screen.getByTestId('uplot-tooltip-unpin'));
 
-			expect(mockLogEvent).toHaveBeenCalledWith(Events.TOOLTIP_UNPINNED, {
+			expect(logEventMock).toHaveBeenCalledWith(Events.TOOLTIP_UNPINNED, {
 				id: 'panel-123',
 			});
 			expect(dismiss).toHaveBeenCalledTimes(1);

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

@@ -1,7 +1,6 @@
 import { memo, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useDispatch, useSelector } from 'react-redux';
-import * as Sentry from '@sentry/react';
 import logEvent from 'api/common/logEvent';
 import { DEFAULT_ENTITY_VERSION, ENTITY_VERSION_V5 } from 'constants/app';
 import { QueryParams } from 'constants/query';
@@ -67,20 +66,6 @@ function GridCardGraph({
 	const [errorMessage, setErrorMessage] = useState<string>();
 	const [isInternalServerError, setIsInternalServerError] =
 		useState<boolean>(false);
-	const queryRangeCalledRef = useRef(false);
-
-	useEffect(() => {
-		const timeoutId = setTimeout(() => {
-			if (!queryRangeCalledRef.current) {
-				Sentry.captureEvent({
-					message: `Dashboard query range not called within expected timeframe for widget ${widget?.id}`,
-					level: 'warning',
-				});
-			}
-		}, 120000);
-		return (): void => clearTimeout(timeoutId);
-	}, [widget?.id]);
-
 	const {
 		minTime,
 		maxTime,
@@ -271,14 +256,12 @@ function GridCardGraph({
 						});
 					}
 				}
-				queryRangeCalledRef.current = true;
 			},
 			onSettled: (data) => {
 				dataAvailable?.(
 					isDataAvailableByPanelType(data?.payload?.data, widget?.panelTypes),
 				);
 				getGraphData?.(data?.payload?.data);
-				queryRangeCalledRef.current = true;
 			},
 		},
 	);

frontend/src/container/ListAlertRules/AlertsEmptyState/AlertsEmptyState.tsx

@@ -89,7 +89,7 @@ export function AlertsEmptyState({
 									onClick={onClickNewAlertHandler}
 									disabled={!addNewAlert}
 									loading={loading}
-									data-testid="add-alert"
+									testId="add-alert"
 								>
 									<span className={styles.buttonContent}>
 										<Plus size="md" />
@@ -97,7 +97,12 @@ export function AlertsEmptyState({
 									</span>
 								</Button>
 								{onRefresh && (
-									<Button onClick={onRefresh} prefix={<RefreshCw />} color="secondary">
+									<Button
+										onClick={onRefresh}
+										prefix={<RefreshCw />}
+										color="secondary"
+										testId="list-alerts-empty-refresh-button"
+									>
 										Refresh
 									</Button>
 								)}

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.actions.test.tsx

@@ -0,0 +1,215 @@
+import userEvent from '@testing-library/user-event';
+import { logEventMock } from '__tests__/logEventMock';
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { findAlertRow, renderListAlertRules } from './_helpers';
+
+async function openActionsMenu(row: HTMLElement): Promise<void> {
+	const trigger = row.querySelector(
+		'[data-testid="alert-actions"]',
+	) as HTMLElement | null;
+	expect(trigger).not.toBeNull();
+	const user = userEvent.setup({ delay: null });
+	await user.click(trigger as HTMLElement);
+	// Radix renders the menu items in a portal once the trigger is activated.
+	await screen.findByRole('menu');
+}
+
+async function clickMenuItem(label: string): Promise<void> {
+	const user = userEvent.setup({ delay: null });
+	const item = await screen.findByRole('menuitem', { name: label });
+	await user.click(item);
+}
+
+describe('ListAlertRules — actions menu', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('renders Enable/Disable/Edit/Edit in New Tab/Clone/Delete items after opening the menu', async () => {
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+
+		expect(screen.queryByRole('menu')).not.toBeInTheDocument();
+
+		await openActionsMenu(row);
+
+		const items = screen.getAllByRole('menuitem');
+		const labels = items.map((it) => it.textContent);
+		expect(labels).toStrictEqual(
+			expect.arrayContaining([
+				'Edit',
+				'Edit in New Tab',
+				'Clone',
+				'Delete',
+				'Disable',
+			]),
+		);
+	});
+
+	it('disabled rule (rule-4) shows "Enable" instead of "Disable"', async () => {
+		renderListAlertRules();
+		const row = await findAlertRow('Disabled Alert');
+		await openActionsMenu(row);
+
+		const items = screen.getAllByRole('menuitem');
+		const labels = items.map((it) => it.textContent);
+		expect(labels).toContain('Enable');
+		expect(labels).not.toContain('Disable');
+	});
+
+	it('toggle action: clicking Disable sends PATCH with disabled:true', async () => {
+		let capturedBody: unknown = null;
+		let capturedPath: string | null = null;
+		server.use(
+			rest.patch('http://localhost/api/v2/rules/:id', async (req, res, ctx) => {
+				capturedBody = await req.json();
+				capturedPath = req.params.id as string;
+				return res(ctx.status(200), ctx.json({ status: 'success' }));
+			}),
+		);
+
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Disable');
+
+		await waitFor(() => {
+			expect(capturedBody).toStrictEqual(
+				expect.objectContaining({ disabled: true }),
+			);
+		});
+		expect(capturedPath).toBe('rule-1');
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Enable/Disable', ruleId: 'rule-1' }),
+		);
+	});
+
+	it('edit action: clicking Edit navigates via safeNavigate and logs event', async () => {
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Edit');
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+		expect(safeNavigateMock.mock.calls[0][0]).toContain('ruleId=rule-1');
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Edit', ruleId: 'rule-1' }),
+		);
+	});
+
+	it('edit in new tab action: clicking opens with newTab:true', async () => {
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Edit in New Tab');
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+		const [url, options] = safeNavigateMock.mock.calls[0];
+		expect(url).toContain('ruleId=rule-1');
+		expect(options).toStrictEqual(expect.objectContaining({ newTab: true }));
+	});
+
+	it('clone action: sends POST with " - Copy" suffix and opens the cloned rule returned by the API', async () => {
+		let capturedPostBody: unknown = null;
+		server.use(
+			rest.post('http://localhost/api/v2/rules', async (req, res, ctx) => {
+				capturedPostBody = await req.json();
+				return res(
+					ctx.status(201),
+					ctx.json({
+						data: {
+							...(capturedPostBody as Record<string, unknown>),
+							id: 'cloned-from-server',
+						},
+						status: 'success',
+					}),
+				);
+			}),
+		);
+
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Clone');
+
+		await waitFor(() => {
+			expect(capturedPostBody).toStrictEqual(
+				expect.objectContaining({ alert: 'High CPU Alert - Copy' }),
+			);
+		});
+
+		// The id from the server response round-trips into the navigate URL — this
+		// protects against a regression where the code hardcodes the id.
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+		expect(safeNavigateMock.mock.calls[0][0]).toContain(
+			'ruleId=cloned-from-server',
+		);
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Clone', ruleId: 'rule-1' }),
+		);
+	});
+
+	it('delete action: sends DELETE for the rule id', async () => {
+		let deletedId: string | null = null;
+		server.use(
+			rest.delete('http://localhost/api/v2/rules/:id', (req, res, ctx) => {
+				deletedId = req.params.id as string;
+				return res(ctx.status(200), ctx.json({ status: 'success' }));
+			}),
+		);
+
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Delete');
+
+		await waitFor(() => {
+			expect(deletedId).toBe('rule-1');
+		});
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Delete', ruleId: 'rule-1' }),
+		);
+	});
+
+	it('error path: PATCH is still attempted when server returns 500', async () => {
+		let patchAttempted = false;
+		server.use(
+			rest.patch('http://localhost/api/v2/rules/:id', (_, res, ctx) => {
+				patchAttempted = true;
+				return res(ctx.status(500), ctx.json({ status: 'error' }));
+			}),
+		);
+
+		renderListAlertRules();
+		const row = await findAlertRow('High CPU Alert');
+		await openActionsMenu(row);
+		await clickMenuItem('Disable');
+
+		await waitFor(() => {
+			expect(patchAttempted).toBe(true);
+		});
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Enable/Disable', ruleId: 'rule-1' }),
+		);
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.columns.test.tsx

@@ -0,0 +1,79 @@
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderListAlertRules } from './_helpers';
+
+const COLUMN_STORAGE_KEY = '@signoz/table-columns/alert-rules-columns';
+
+describe('ListAlertRules — columns selector', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+		localStorage.clear();
+	});
+
+	afterEach(() => {
+		localStorage.clear();
+	});
+
+	it('opens columns popover and lists toggleable columns', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.click(screen.getByTestId('alert-columns-button'));
+
+		// Popover should reveal "Toggle Columns" heading + per-column labels.
+		await screen.findByText('Toggle Columns');
+		expect(screen.getByText('Created At')).toBeInTheDocument();
+		expect(screen.getByText('Created By')).toBeInTheDocument();
+		expect(screen.getByText('Updated At')).toBeInTheDocument();
+		expect(screen.getByText('Updated By')).toBeInTheDocument();
+	});
+
+	it('default-hidden columns (Created At/By, Updated At/By) are not in the table header', async () => {
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		const headers = document.querySelectorAll('th');
+		const headerTexts = Array.from(headers).map((h) => h.textContent || '');
+		expect(headerTexts.some((t) => t.includes('Created At'))).toBe(false);
+		expect(headerTexts.some((t) => t.includes('Created By'))).toBe(false);
+		expect(headerTexts.some((t) => t.includes('Updated At'))).toBe(false);
+		expect(headerTexts.some((t) => t.includes('Updated By'))).toBe(false);
+	});
+
+	it('toggling Created At on writes to localStorage and adds the header', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		const headersBefore = Array.from(document.querySelectorAll('th')).map(
+			(h) => h.textContent ?? '',
+		);
+		expect(headersBefore.some((t) => t.includes('Created At'))).toBe(false);
+
+		await user.click(screen.getByTestId('alert-columns-button'));
+		await screen.findByText('Toggle Columns');
+
+		const checkbox = document.getElementById('col-createdAt');
+		expect(checkbox).not.toBeNull();
+		await user.click(checkbox as HTMLElement);
+
+		await waitFor(() => {
+			const stored = window.localStorage.getItem(COLUMN_STORAGE_KEY);
+			expect(stored).not.toBeNull();
+			const parsed = JSON.parse(stored as string);
+			expect(parsed.hiddenColumnIds).not.toContain('createdAt');
+		});
+
+		await waitFor(() => {
+			const headersAfter = Array.from(document.querySelectorAll('th')).map(
+				(h) => h.textContent ?? '',
+			);
+			expect(headersAfter.some((t) => t.includes('Created At'))).toBe(true);
+		});
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.empty.test.tsx

@@ -0,0 +1,91 @@
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import userEvent from '@testing-library/user-event';
+import ROUTES from 'constants/routes';
+import { alertRulesFixture } from 'mocks-server/__mockdata__/alert_rules';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen } from 'tests/test-utils';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — empty states', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('renders AlertsEmptyState when API returns no rules', async () => {
+		const user = userEvent.setup({ delay: null });
+
+		server.use(
+			rest.get('http://localhost/api/v2/rules', (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [], status: 'success' })),
+			),
+		);
+
+		renderListAlertRules();
+
+		await screen.findByText('No Alert rules yet.');
+		expect(
+			screen.getByText('Create an Alert Rule to get started'),
+		).toBeInTheDocument();
+
+		// New Alert Rule button is visible and triggers safeNavigate to ALERTS_NEW.
+		await user.click(screen.getByTestId('add-alert'));
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			ROUTES.ALERTS_NEW,
+			expect.objectContaining({ newTab: false }),
+		);
+	});
+
+	it('renders ErrorEmptyState when API returns 500; refresh triggers a refetch', async () => {
+		const user = userEvent.setup({ delay: null });
+
+		let callCount = 0;
+		server.use(
+			rest.get('http://localhost/api/v2/rules', (_, res, ctx) => {
+				callCount += 1;
+				if (callCount === 1) {
+					return res(ctx.status(500), ctx.json({ status: 'error' }));
+				}
+				return res(
+					ctx.status(200),
+					ctx.json({ data: alertRulesFixture, status: 'success' }),
+				);
+			}),
+		);
+
+		renderListAlertRules();
+
+		await screen.findByTestId('error-empty-state');
+
+		await user.click(screen.getByTestId('error-refresh-button'));
+
+		const rule = await screen.findByText('High CPU Alert');
+		expect(rule).toBeInTheDocument();
+	});
+
+	it('renders NoResultsEmptyState when search yields no match; Clear Search resets', async () => {
+		const user = userEvent.setup({ delay: null });
+
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		const searchInput = screen.getByTestId('list-alerts-search-input');
+		await user.clear(searchInput);
+		await user.type(searchInput, 'totally-not-found');
+
+		await screen.findByTestId('no-results-empty-state');
+		expect(screen.getByTestId('no-results-title')).toHaveTextContent(
+			'No matching alert rules',
+		);
+		expect(screen.getByTestId('no-results-subtitle')).toHaveTextContent(
+			'No alert rules match your search. Try adjusting your search criteria.',
+		);
+
+		await user.click(screen.getByTestId('no-results-clear-button'));
+
+		const rule = await screen.findByText('High CPU Alert');
+		expect(rule).toBeInTheDocument();
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.list.test.tsx

@@ -0,0 +1,123 @@
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — list rendering', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('renders alert rules from API', async () => {
+		renderListAlertRules();
+
+		await expect(
+			screen.findByTestId('alert-row-rule-1-name'),
+		).resolves.toHaveTextContent('High CPU Alert');
+		expect(screen.getByTestId('alert-row-rule-2-name')).toHaveTextContent(
+			'Memory Pending Alert',
+		);
+		expect(screen.getByTestId('alert-row-rule-3-name')).toHaveTextContent(
+			'Healthy Alert',
+		);
+		expect(screen.getByTestId('alert-row-rule-4-name')).toHaveTextContent(
+			'Disabled Alert',
+		);
+	});
+
+	it('renders state badges via STATE_CONFIG mapping', async () => {
+		renderListAlertRules();
+
+		await waitFor(() =>
+			expect(screen.getByTestId('alert-row-rule-1-state')).toBeInTheDocument(),
+		);
+
+		expect(screen.getByTestId('alert-row-rule-1-state')).toHaveTextContent(
+			'Firing',
+		);
+		expect(screen.getByTestId('alert-row-rule-2-state')).toHaveTextContent(
+			'Pending',
+		);
+		expect(screen.getByTestId('alert-row-rule-3-state')).toHaveTextContent('OK');
+		expect(screen.getByTestId('alert-row-rule-4-state')).toHaveTextContent(
+			'Disabled',
+		);
+		expect(screen.getByTestId('alert-row-rule-5-state')).toHaveTextContent('OK');
+	});
+
+	it('renders state badges with semantic colors', async () => {
+		renderListAlertRules();
+
+		await waitFor(() =>
+			expect(screen.getByTestId('alert-row-rule-1-state')).toBeInTheDocument(),
+		);
+
+		expect(screen.getByTestId('alert-row-rule-1-state')).toHaveAttribute(
+			'data-color',
+			'cherry',
+		);
+		expect(screen.getByTestId('alert-row-rule-2-state')).toHaveAttribute(
+			'data-color',
+			'amber',
+		);
+		expect(screen.getByTestId('alert-row-rule-3-state')).toHaveAttribute(
+			'data-color',
+			'forest',
+		);
+		expect(screen.getByTestId('alert-row-rule-4-state')).toHaveAttribute(
+			'data-color',
+			'vanilla',
+		);
+	});
+
+	it('renders severity badges for rules with severity', async () => {
+		renderListAlertRules();
+
+		await waitFor(() =>
+			expect(screen.getByTestId('alert-row-rule-1-severity')).toBeInTheDocument(),
+		);
+
+		expect(screen.getByTestId('alert-row-rule-1-severity')).toHaveTextContent(
+			'critical',
+		);
+		expect(screen.getByTestId('alert-row-rule-2-severity')).toHaveTextContent(
+			'warning',
+		);
+		expect(screen.getByTestId('alert-row-rule-3-severity')).toHaveTextContent(
+			'info',
+		);
+		expect(screen.getByTestId('alert-row-rule-4-severity')).toHaveTextContent(
+			'critical',
+		);
+		expect(screen.getByTestId('alert-row-rule-5-severity')).toHaveTextContent(
+			'-',
+		);
+		expect(screen.getByTestId('alert-row-rule-1-severity')).toHaveAttribute(
+			'data-color',
+			'cherry',
+		);
+		expect(screen.getByTestId('alert-row-rule-2-severity')).toHaveAttribute(
+			'data-color',
+			'amber',
+		);
+	});
+
+	it('renders header controls (search, columns, new alert)', async () => {
+		renderListAlertRules();
+
+		await waitFor(() =>
+			expect(screen.getByTestId('alert-row-rule-1-name')).toBeInTheDocument(),
+		);
+
+		expect(screen.getByTestId('list-alerts-search-input')).toBeInTheDocument();
+		expect(
+			screen.getByPlaceholderText('Search by Alert Name, Severity and Labels'),
+		).toBeInTheDocument();
+		expect(screen.getByTestId('alert-columns-button')).toBeInTheDocument();
+		expect(
+			screen.getByTestId('list-alerts-new-alert-button'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByRole('button', { name: /new alert/i }),
+		).toBeInTheDocument();
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.newAlert.test.tsx

@@ -0,0 +1,65 @@
+import { logEventMock } from '__tests__/logEventMock';
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import userEvent from '@testing-library/user-event';
+import ROUTES from 'constants/routes';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — new alert button', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('plain click navigates to ALERTS_NEW with newTab:false', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.click(screen.getByRole('button', { name: /new alert/i }));
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			ROUTES.ALERTS_NEW,
+			expect.objectContaining({ newTab: false }),
+		);
+	});
+
+	it('logs Alert: New alert button clicked', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.click(screen.getByRole('button', { name: /new alert/i }));
+
+		await waitFor(() => {
+			expect(logEventMock).toHaveBeenCalledWith(
+				'Alert: New alert button clicked',
+				expect.objectContaining({ layout: 'new' }),
+			);
+		});
+	});
+
+	it('ctrl+click on New Alert opens in a new tab (newTab:true)', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.keyboard('{Control>}');
+		await user.click(screen.getByRole('button', { name: /new alert/i }));
+		await user.keyboard('{/Control}');
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			ROUTES.ALERTS_NEW,
+			expect.objectContaining({ newTab: true }),
+		);
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.pagination.test.tsx

@@ -0,0 +1,64 @@
+import userEvent from '@testing-library/user-event';
+import { alertRulesPaginationFixture } from 'mocks-server/__mockdata__/alert_rules';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, waitFor } from 'tests/test-utils';
+import { getCurrentNuqsQueryString } from 'tests/nuqs-helpers';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — pagination', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+		server.use(
+			rest.get('http://localhost/api/v2/rules', (_, res, ctx) =>
+				res(
+					ctx.status(200),
+					ctx.json({ data: alertRulesPaginationFixture, status: 'success' }),
+				),
+			),
+		);
+	});
+
+	it('shows first 10 rows on page 1 (default limit)', async () => {
+		renderListAlertRules();
+
+		await screen.findByText('Pag Rule 0');
+
+		for (let i = 0; i < 10; i += 1) {
+			expect(screen.getByText(`Pag Rule ${i}`)).toBeInTheDocument();
+		}
+		expect(screen.queryByText('Pag Rule 10')).not.toBeInTheDocument();
+		expect(screen.queryByText('Pag Rule 14')).not.toBeInTheDocument();
+	});
+
+	it('shows total count when showTotalCount is enabled', async () => {
+		renderListAlertRules();
+
+		await screen.findByText('Pag Rule 0');
+
+		const totalCount = await screen.findByTestId('pagination-total-count');
+		expect(totalCount.textContent).toContain('Showing');
+		expect(totalCount.textContent).toContain('of 15');
+	});
+
+	it('navigates to page 2 and shows remaining rows', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('Pag Rule 0');
+
+		const nextBtn = screen.getByLabelText('Go to next page');
+		await user.click(nextBtn);
+
+		await waitFor(() => {
+			expect(screen.getByText('Pag Rule 10')).toBeInTheDocument();
+			expect(screen.getByText('Pag Rule 14')).toBeInTheDocument();
+			expect(screen.queryByText('Pag Rule 0')).not.toBeInTheDocument();
+		});
+
+		await waitFor(() => {
+			expect(getCurrentNuqsQueryString()).toContain('page=2');
+		});
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.permissions.test.tsx

@@ -0,0 +1,71 @@
+import { screen, waitFor } from 'tests/test-utils';
+import { USER_ROLES } from 'types/roles';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — permissions', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('VIEWER role hides "New Alert" button and "Actions" column', async () => {
+		renderListAlertRules({ role: USER_ROLES.VIEWER });
+
+		await screen.findByText('High CPU Alert');
+
+		expect(
+			screen.queryByTestId('list-alerts-new-alert-button'),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /new alert/i }),
+		).not.toBeInTheDocument();
+
+		const headers = Array.from(document.querySelectorAll('th')).map(
+			(h) => h.textContent ?? '',
+		);
+		expect(headers.some((t) => t.includes('Actions'))).toBe(false);
+		expect(screen.queryByTestId('alert-actions')).not.toBeInTheDocument();
+	});
+
+	it('ADMIN role shows "New Alert" button and "Actions" column', async () => {
+		renderListAlertRules({ role: USER_ROLES.ADMIN });
+
+		await screen.findByText('High CPU Alert');
+
+		expect(
+			screen.getByTestId('list-alerts-new-alert-button'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByRole('button', { name: /new alert/i }),
+		).toBeInTheDocument();
+
+		await waitFor(() => {
+			const headers = Array.from(document.querySelectorAll('th')).map(
+				(h) => h.textContent ?? '',
+			);
+			expect(headers.some((t) => t.includes('Actions'))).toBe(true);
+		});
+		expect(screen.getAllByTestId('alert-actions').length).toBeGreaterThan(0);
+	});
+
+	it('EDITOR role behaves like ADMIN (New Alert + Actions visible)', async () => {
+		renderListAlertRules({ role: USER_ROLES.EDITOR });
+
+		await screen.findByText('High CPU Alert');
+
+		expect(
+			screen.getByTestId('list-alerts-new-alert-button'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByRole('button', { name: /new alert/i }),
+		).toBeInTheDocument();
+
+		await waitFor(() => {
+			const headers = Array.from(document.querySelectorAll('th')).map(
+				(h) => h.textContent ?? '',
+			);
+			expect(headers.some((t) => t.includes('Actions'))).toBe(true);
+		});
+		expect(screen.getAllByTestId('alert-actions').length).toBeGreaterThan(0);
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.rowClick.test.tsx

@@ -0,0 +1,52 @@
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderListAlertRules } from './_helpers';
+
+describe('ListAlertRules — row click navigation', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('clicking a row calls safeNavigate to alerts/overview with composite query + ruleId', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		const ruleCell = await screen.findByText('High CPU Alert');
+
+		const td = ruleCell.closest('td');
+		expect(td).not.toBeNull();
+		await user.click(td as HTMLElement);
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+
+		const [url] = safeNavigateMock.mock.calls[0];
+		expect(url).toContain('/alerts/overview?');
+		expect(url).toContain('ruleId=rule-1');
+		expect(url).toContain('panelTypes=graph');
+		expect(url).toContain('compositeQuery=');
+	});
+
+	it('ctrl+click on a row navigates with newTab option', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		const ruleCell = await screen.findByText('High CPU Alert');
+
+		const td = ruleCell.closest('td');
+		await user.keyboard('{Control>}');
+		await user.click(td as HTMLElement);
+		await user.keyboard('{/Control}');
+
+		await waitFor(() => {
+			expect(safeNavigateMock).toHaveBeenCalled();
+		});
+
+		const [url, options] = safeNavigateMock.mock.calls[0];
+		expect(url).toContain('ruleId=rule-1');
+		expect(options).toStrictEqual(expect.objectContaining({ newTab: true }));
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.search.test.tsx

@@ -0,0 +1,99 @@
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+import { getCurrentNuqsQueryString } from 'tests/nuqs-helpers';
+
+import { renderListAlertRules } from './_helpers';
+
+function getSearchInput(): HTMLInputElement {
+	return screen.getByTestId('list-alerts-search-input') as HTMLInputElement;
+}
+
+describe('ListAlertRules — search', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('filters rows by alert name with debounce', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.clear(getSearchInput());
+		await user.type(getSearchInput(), 'CPU');
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Alert')).toBeInTheDocument();
+			expect(screen.queryByText('Memory Pending Alert')).not.toBeInTheDocument();
+		});
+	});
+
+	it('filters rows by label values (severity)', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.clear(getSearchInput());
+		await user.type(getSearchInput(), 'warning');
+
+		await waitFor(() => {
+			expect(screen.getByText('Memory Pending Alert')).toBeInTheDocument();
+			expect(screen.queryByText('High CPU Alert')).not.toBeInTheDocument();
+		});
+	});
+
+	it('restores all rows when search is cleared', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.clear(getSearchInput());
+		await user.type(getSearchInput(), 'CPU');
+
+		await waitFor(() => {
+			expect(screen.queryByText('Memory Pending Alert')).not.toBeInTheDocument();
+		});
+
+		await user.clear(getSearchInput());
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Alert')).toBeInTheDocument();
+			expect(screen.getByText('Memory Pending Alert')).toBeInTheDocument();
+			expect(screen.getByText('Healthy Alert')).toBeInTheDocument();
+		});
+	});
+
+	it('shows no-results state when no match', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules();
+
+		await screen.findByText('High CPU Alert');
+
+		await user.clear(getSearchInput());
+		await user.type(getSearchInput(), 'zzzzzz-no-match');
+
+		await waitFor(() => {
+			expect(screen.getByTestId('no-results-empty-state')).toBeInTheDocument();
+			expect(screen.getByTestId('no-results-title')).toHaveTextContent(
+				'No matching alert rules',
+			);
+		});
+	});
+
+	it('resets page to 1 when search debounce fires', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderListAlertRules({ initialRoute: '/?page=2' });
+
+		// Page 2 of the 4-rule fixture has no rows; we only need the search input
+		// to be mounted, which happens before data is fetched.
+		const input = await screen.findByTestId('list-alerts-search-input');
+		await user.clear(input);
+		await user.type(input, 'CPU');
+
+		await waitFor(() => {
+			expect(getCurrentNuqsQueryString()).not.toContain('page=2');
+		});
+	});
+});

frontend/src/container/ListAlertRules/__tests__/ListAlertRules.utils.test.ts

@@ -0,0 +1,232 @@
+import { logEventMock } from '__tests__/logEventMock';
+import { RuletypesAlertStateDTO } from 'api/generated/services/sigNoz.schemas';
+import type { SortState } from 'components/TanStackTableView/types';
+
+import type { AlertRule } from '../types';
+import {
+	ALERT_ACTIONS,
+	alertActionLogEvent,
+	filterRulesByFilters,
+	getAlertSortValue,
+	sortRules,
+} from '../utils';
+
+const baseRule = {
+	id: 'r1',
+	alert: 'Rule 1',
+	alertType: 'METRIC_BASED_ALERT',
+	state: 'inactive',
+	labels: { severity: 'info' },
+	condition: {},
+	createdAt: '2023-10-15T10:00:00Z',
+	updatedAt: '2023-10-19T10:00:00Z',
+} as unknown as AlertRule;
+
+const makeRule = (overrides: Partial<AlertRule>): AlertRule => ({
+	...baseRule,
+	...overrides,
+});
+
+describe('getAlertSortValue', () => {
+	it('returns state for "state"', () => {
+		expect(
+			getAlertSortValue(
+				makeRule({ state: RuletypesAlertStateDTO.firing }),
+				'state',
+			),
+		).toBe('firing');
+	});
+
+	it('returns alert name for "name"', () => {
+		expect(getAlertSortValue(makeRule({ alert: 'My Rule' }), 'name')).toBe(
+			'My Rule',
+		);
+	});
+
+	it('returns severity label for "severity"', () => {
+		expect(
+			getAlertSortValue(
+				makeRule({ labels: { severity: 'critical' } }),
+				'severity',
+			),
+		).toBe('critical');
+	});
+
+	it('returns createdAt as ms', () => {
+		const rule = makeRule({ createdAt: '2023-10-15T10:00:00Z' });
+		const result = getAlertSortValue(rule, 'createdAt');
+		expect(result).toBe(new Date('2023-10-15T10:00:00Z').getTime());
+	});
+
+	it('returns updatedAt as ms', () => {
+		const rule = makeRule({ updatedAt: '2023-10-19T10:00:00Z' });
+		const result = getAlertSortValue(rule, 'updatedAt');
+		expect(result).toBe(new Date('2023-10-19T10:00:00Z').getTime());
+	});
+
+	it('returns 0 when createdAt missing', () => {
+		expect(
+			getAlertSortValue(makeRule({ createdAt: undefined }), 'createdAt'),
+		).toBe(0);
+	});
+
+	it('returns empty for unknown column', () => {
+		expect(getAlertSortValue(baseRule, 'xxx')).toBe('');
+	});
+
+	it('returns empty for missing fields', () => {
+		expect(
+			getAlertSortValue(
+				makeRule({ state: undefined, labels: undefined }),
+				'state',
+			),
+		).toBe('');
+		expect(
+			getAlertSortValue(
+				makeRule({ state: undefined, labels: undefined }),
+				'severity',
+			),
+		).toBe('');
+	});
+});
+
+describe('sortRules', () => {
+	const r1 = makeRule({ id: '1', alert: 'A' });
+	const r2 = makeRule({ id: '2', alert: 'B' });
+	const r3 = makeRule({ id: '3', alert: 'C' });
+
+	it('sorts ascending by name', () => {
+		const order: SortState = { columnName: 'name', order: 'asc' };
+		const result = sortRules([r3, r1, r2], order);
+		expect(result.map((r) => r.alert)).toStrictEqual(['A', 'B', 'C']);
+	});
+
+	it('sorts descending by name', () => {
+		const order: SortState = { columnName: 'name', order: 'desc' };
+		const result = sortRules([r1, r2, r3], order);
+		expect(result.map((r) => r.alert)).toStrictEqual(['C', 'B', 'A']);
+	});
+
+	it('returns unsorted when orderBy is null', () => {
+		const result = sortRules([r3, r1, r2], null);
+		expect(result.map((r) => r.alert)).toStrictEqual(['C', 'A', 'B']);
+	});
+});
+
+describe('filterRulesByFilters', () => {
+	const r1 = makeRule({
+		id: '1',
+		alert: 'R1',
+		state: RuletypesAlertStateDTO.firing,
+		labels: { severity: 'critical' },
+	});
+	const r2 = makeRule({
+		id: '2',
+		alert: 'R2',
+		state: RuletypesAlertStateDTO.inactive,
+		labels: { severity: 'warning' },
+	});
+	const r3 = makeRule({
+		id: '3',
+		alert: 'R3',
+		state: RuletypesAlertStateDTO.firing,
+		labels: { severity: 'warning' },
+	});
+	const rules = [r1, r2, r3];
+
+	it('returns input when filters empty', () => {
+		expect(filterRulesByFilters(rules, [])).toStrictEqual(rules);
+	});
+
+	it('filters by state', () => {
+		const result = filterRulesByFilters(rules, ['state:firing']);
+		expect(result.map((r) => r.id)).toStrictEqual(['1', '3']);
+	});
+
+	it('filters by severity', () => {
+		const result = filterRulesByFilters(rules, ['severity:warning']);
+		expect(result.map((r) => r.id)).toStrictEqual(['2', '3']);
+	});
+
+	it('combines state AND severity', () => {
+		const result = filterRulesByFilters(rules, [
+			'state:firing',
+			'severity:warning',
+		]);
+		expect(result.map((r) => r.id)).toStrictEqual(['3']);
+	});
+
+	it('OR within same key (state)', () => {
+		const result = filterRulesByFilters(rules, [
+			'state:firing',
+			'state:inactive',
+		]);
+		expect(result.map((r) => r.id)).toStrictEqual(['1', '2', '3']);
+	});
+
+	it('matches values case-insensitively', () => {
+		const result = filterRulesByFilters(rules, ['state:FIRING']);
+		expect(result.map((r) => r.id)).toStrictEqual(['1', '3']);
+	});
+
+	it('ignores prefixes with wrong case (state: is required lowercase)', () => {
+		const result = filterRulesByFilters(rules, ['STATE:FIRING']);
+		expect(result).toStrictEqual(rules);
+	});
+
+	it('returns empty when no rule matches', () => {
+		expect(filterRulesByFilters(rules, ['state:nonexistent'])).toStrictEqual([]);
+	});
+
+	it('ignores unknown prefix', () => {
+		expect(filterRulesByFilters(rules, ['foo:bar'])).toStrictEqual(rules);
+	});
+});
+
+describe('alertActionLogEvent', () => {
+	it('logs with mapped action label', () => {
+		const rule = makeRule({
+			id: 'rule-1',
+			alert: 'My Rule',
+			alertType: 'METRIC_BASED_ALERT' as AlertRule['alertType'],
+		});
+		alertActionLogEvent(ALERT_ACTIONS.EDIT, rule);
+		expect(logEventMock).toHaveBeenCalledWith('Alert: Action', {
+			ruleId: 'rule-1',
+			dataSource: expect.any(String),
+			name: 'My Rule',
+			action: 'Edit',
+		});
+	});
+
+	it('falls back to raw action when unmapped', () => {
+		alertActionLogEvent('custom', baseRule);
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'custom' }),
+		);
+	});
+
+	it('maps TOGGLE action', () => {
+		alertActionLogEvent(ALERT_ACTIONS.TOGGLE, baseRule);
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Action',
+			expect.objectContaining({ action: 'Enable/Disable' }),
+		);
+	});
+
+	it('maps DELETE and CLONE', () => {
+		alertActionLogEvent(ALERT_ACTIONS.DELETE, baseRule);
+		alertActionLogEvent(ALERT_ACTIONS.CLONE, baseRule);
+		expect(logEventMock).toHaveBeenNthCalledWith(
+			1,
+			'Alert: Action',
+			expect.objectContaining({ action: 'Delete' }),
+		);
+		expect(logEventMock).toHaveBeenNthCalledWith(
+			2,
+			'Alert: Action',
+			expect.objectContaining({ action: 'Clone' }),
+		);
+	});
+});

frontend/src/container/ListAlertRules/__tests__/_helpers.tsx

@@ -0,0 +1,65 @@
+import { QueryClient, QueryClientProvider } from 'react-query';
+import { MemoryRouter } from 'react-router-dom';
+import { VirtuosoMockContext } from 'react-virtuoso';
+import { render, RenderResult, screen } from '@testing-library/react';
+import ListAlertRules from 'container/ListAlertRules';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { AppContext } from 'providers/App/App';
+import TimezoneProvider from 'providers/Timezone';
+import { onNuqsUrlUpdate, resetNuqsState } from 'tests/nuqs-helpers';
+import { getAppContextMock } from 'tests/test-utils';
+
+interface RenderOptions {
+	role?: string;
+	initialRoute?: string;
+}
+
+export function renderListAlertRules(
+	options: RenderOptions = {},
+): RenderResult {
+	const { role = 'ADMIN', initialRoute = '/' } = options;
+
+	const initialSearch = initialRoute.includes('?')
+		? initialRoute.slice(initialRoute.indexOf('?'))
+		: '';
+	resetNuqsState(initialSearch);
+
+	const queryClient = new QueryClient({
+		defaultOptions: {
+			queries: { refetchOnWindowFocus: false, retry: false },
+			mutations: { retry: false },
+		},
+	});
+
+	return render(
+		<MemoryRouter initialEntries={[initialRoute]}>
+			<NuqsTestingAdapter
+				searchParams={initialSearch}
+				onUrlUpdate={onNuqsUrlUpdate}
+				rateLimitFactor={0}
+				hasMemory
+			>
+				<QueryClientProvider client={queryClient}>
+					<AppContext.Provider value={getAppContextMock(role)}>
+						<TimezoneProvider>
+							<VirtuosoMockContext.Provider
+								value={{ viewportHeight: 800, itemHeight: 46 }}
+							>
+								<ListAlertRules />
+							</VirtuosoMockContext.Provider>
+						</TimezoneProvider>
+					</AppContext.Provider>
+				</QueryClientProvider>
+			</NuqsTestingAdapter>
+		</MemoryRouter>,
+	);
+}
+
+export async function findAlertRow(alertName: string): Promise<HTMLElement> {
+	const cell = await screen.findByText(alertName, {}, { timeout: 5000 });
+	const row = cell.closest('tr');
+	if (!row) {
+		throw new Error(`Row not found for alert "${alertName}"`);
+	}
+	return row as HTMLElement;
+}

frontend/src/container/ListAlertRules/components/ColumnSelector.tsx

@@ -47,6 +47,7 @@ function ColumnSelector<TData>({
 					size="sm"
 					color="secondary"
 					prefix={<Columns3 size={14} />}
+					data-testid="alert-columns-button"
 				>
 					Columns
 				</Button>

frontend/src/container/ListAlertRules/index.tsx

@@ -136,6 +136,7 @@ function ListAlertRules(): JSX.Element {
 								prefix={<Plus size={14} />}
 								onClick={handleNewAlert}
 								color="primary"
+								testId="list-alerts-new-alert-button"
 							>
 								New Alert
 							</Button>
@@ -157,6 +158,7 @@ function ListAlertRules(): JSX.Element {
 						value={searchText}
 						onChange={handleSearchChange}
 						suffix={<Search size={14} className={styles.searchIcon} />}
+						testId="list-alerts-search-input"
 					/>
 				</div>
 			)}

frontend/src/container/ListAlertRules/table.config.tsx

@@ -26,14 +26,18 @@ export function getAlertRuleColumns(
 			enableSort: true,
 			enableRemove: false,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => {
+			cell: ({ row, value }): JSX.Element => {
 				const state = String(value ?? '').toLowerCase();
 				const config = STATE_CONFIG[state] ?? {
 					color: 'secondary' as BadgeColor,
 					label: 'Unknown',
 				};
 				return (
-					<Badge color={config.color} variant="outline">
+					<Badge
+						color={config.color}
+						variant="outline"
+						testId={`alert-row-${row.id ?? ''}-state`}
+					>
 						{config.label}
 					</Badge>
 				);
@@ -47,8 +51,11 @@ export function getAlertRuleColumns(
 			enableSort: true,
 			enableRemove: false,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => (
-				<TanStackTable.Text title={value}>
+			cell: ({ row, value }): JSX.Element => (
+				<TanStackTable.Text
+					title={value}
+					data-testid={`alert-row-${row.id ?? ''}-name`}
+				>
 					{String(value ?? '-')}
 				</TanStackTable.Text>
 			),
@@ -60,15 +67,20 @@ export function getAlertRuleColumns(
 			width: { fixed: '120px' },
 			enableSort: true,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => {
+			cell: ({ row, value }): JSX.Element => {
 				const severity = String(value ?? '').toLowerCase();
 				if (!severity) {
-					return <TanStackTable.Text>-</TanStackTable.Text>;
+					return (
+						<TanStackTable.Text data-testid={`alert-row-${row.id ?? ''}-severity`}>
+							-
+						</TanStackTable.Text>
+					);
 				}
 				return (
 					<Badge
 						color={SEVERITY_BADGE_COLORS[severity] ?? 'secondary'}
 						variant="outline"
+						testId={`alert-row-${row.id ?? ''}-severity`}
 					>
 						{severity}
 					</Badge>

frontend/src/container/MCPServerSettings/MCPServerSettings.test.tsx

@@ -1,8 +1,8 @@
+import { logEventMock } from '__tests__/logEventMock';
 import { render, screen, userEvent } from 'tests/test-utils';
 
 import MCPServerSettings from './MCPServerSettings';
 
-const mockLogEvent = jest.fn();
 const mockCopyToClipboard = jest.fn();
 const mockHistoryPush = jest.fn();
 const mockUseGetGlobalConfig = jest.fn();
@@ -11,11 +11,6 @@ const mockUseGetTenantLicense = jest.fn();
 const mockToastSuccess = jest.fn();
 const mockToastWarning = jest.fn();
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: (...args: unknown[]): unknown => mockLogEvent(...args),
-}));
-
 jest.mock('api/generated/services/global', () => ({
 	useGetGlobalConfig: (...args: unknown[]): unknown =>
 		mockUseGetGlobalConfig(...args),
@@ -148,7 +143,7 @@ describe('MCPServerSettings', () => {
 
 		render(<MCPServerSettings />, undefined, { role: 'ADMIN' });
 
-		expect(mockLogEvent).toHaveBeenCalledWith('MCP Settings: Page viewed', {
+		expect(logEventMock).toHaveBeenCalledWith('MCP Settings: Page viewed', {
 			role: 'ADMIN',
 		});
 	});

frontend/src/container/MySettings/__tests__/MySettings.test.tsx

@@ -1,5 +1,6 @@
 import userEvent from '@testing-library/user-event';
 import MySettingsContainer from 'container/MySettings';
+import { logEventMock } from '__tests__/logEventMock';
 import {
 	act,
 	fireEvent,
@@ -12,7 +13,6 @@ import APIError from 'types/api/error';
 import { toast } from '@signozhq/ui/sonner';
 
 const toggleThemeFunction = jest.fn();
-const logEventFunction = jest.fn();
 const copyToClipboardFn = jest.fn();
 const editUserFn = jest.fn();
 const updateMyPasswordFn = jest.fn();
@@ -62,11 +62,6 @@ jest.mock('hooks/useDarkMode', () => ({
 	})),
 }));
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn((eventName, data) => logEventFunction(eventName, data)),
-}));
-
 const errorNotification = jest.fn();
 const successNotification = jest.fn();
 jest.mock('hooks/useNotifications', () => ({
@@ -135,7 +130,7 @@ describe('MySettings Flows', () => {
 
 			await waitFor(() => {
 				expect(toggleThemeFunction).toHaveBeenCalled();
-				expect(logEventFunction).toHaveBeenCalledWith(
+				expect(logEventMock).toHaveBeenCalledWith(
 					'Account Settings: Theme Changed',
 					{
 						theme: 'light',

frontend/src/container/OnboardingQuestionaire/InviteTeamMembers/__tests__/InviteTeamMembers.test.tsx

@@ -9,11 +9,6 @@ import {
 
 import InviteTeamMembers from '../InviteTeamMembers';
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 const mockNotificationSuccess = jest.fn() as jest.MockedFunction<
 	(args: { message: string }) => void
 >;

frontend/src/container/OnboardingQuestionaire/__tests__/OnboardingQuestionaire.test.tsx

@@ -4,11 +4,6 @@ import { render, screen, userEvent, waitFor } from 'tests/test-utils';
 import OnboardingQuestionaire from '../index';
 
 // Mock dependencies
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('lib/history', () => ({
 	__esModule: true,
 	default: {

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

@@ -4,15 +4,13 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { render } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import logEvent from 'api/common/logEvent';
+import { logEventMock } from '__tests__/logEventMock';
 import i18n from 'ReactI18';
 import store from 'store';
 
 import CreatePipelineButton from '../Layouts/Pipeline/CreatePipelineButton';
 import { pipelineApiResponseMockData } from '../mocks/pipeline';
 
-jest.mock('api/common/logEvent');
-
 describe('PipelinePage container test', () => {
 	it('should render CreatePipelineButton section', async () => {
 		const { asFragment } = render(
@@ -53,9 +51,12 @@ describe('PipelinePage container test', () => {
 		expect(editButton).toBeInTheDocument();
 		await userEvent.click(editButton);
 
-		expect(logEvent).toHaveBeenCalledWith('Logs: Pipelines: Entered Edit Mode', {
-			source: 'signoz-ui',
-		});
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Logs: Pipelines: Entered Edit Mode',
+			{
+				source: 'signoz-ui',
+			},
+		);
 	});
 
 	it('CreatePipelineButton - add new mode & tracking', async () => {
@@ -78,7 +79,7 @@ describe('PipelinePage container test', () => {
 		expect(editButton).toBeInTheDocument();
 		await userEvent.click(editButton);
 
-		expect(logEvent).toHaveBeenCalledWith(
+		expect(logEventMock).toHaveBeenCalledWith(
 			'Logs: Pipelines: Clicked Add New Pipeline',
 			{
 				source: 'signoz-ui',

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.empty.test.tsx

@@ -0,0 +1,118 @@
+import userEvent from '@testing-library/user-event';
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import ROUTES from 'constants/routes';
+import { triggeredAlertsFixture } from 'mocks-server/__mockdata__/triggered_alerts';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — empty / error states', () => {
+	it('shows the "No alerts firing" empty state when the API returns []', async () => {
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [], status: 'success' })),
+			),
+		);
+
+		renderTriggeredAlerts();
+
+		await screen.findByText('No alerts firing');
+		expect(
+			screen.getByTestId('triggered-alerts-empty-create-button'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('triggered-alerts-empty-refresh-button'),
+		).toBeInTheDocument();
+	});
+
+	it('navigates to ROUTES.ALERTS_NEW when "Create Alert Rule" is clicked', async () => {
+		const user = userEvent.setup({ delay: null });
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [], status: 'success' })),
+			),
+		);
+
+		renderTriggeredAlerts();
+
+		await screen.findByText('No alerts firing');
+
+		await user.click(screen.getByTestId('triggered-alerts-empty-create-button'));
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			ROUTES.ALERTS_NEW,
+			expect.objectContaining({ newTab: false }),
+		);
+	});
+
+	it('shows ErrorEmptyState when the API returns 500', async () => {
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+				res(ctx.status(500)),
+			),
+		);
+
+		renderTriggeredAlerts();
+
+		await screen.findByTestId('error-empty-state');
+		expect(screen.getByTestId('error-refresh-button')).toBeInTheDocument();
+	});
+
+	it('refetches on refresh button click after an initial error', async () => {
+		let callCount = 0;
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) => {
+				callCount += 1;
+				if (callCount === 1) {
+					return res(ctx.status(500));
+				}
+				return res(
+					ctx.status(200),
+					ctx.json({ data: triggeredAlertsFixture, status: 'success' }),
+				);
+			}),
+		);
+
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await screen.findByTestId('error-refresh-button');
+
+		await user.click(screen.getByTestId('error-refresh-button'));
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+	});
+
+	it('shows NoResultsEmptyState when filters yield zero matches', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'this-matches-nothing-xyz');
+
+		await screen.findByTestId('no-results-empty-state');
+		expect(screen.getByTestId('no-results-title')).toHaveTextContent(
+			'No matching alerts',
+		);
+		expect(screen.getByTestId('no-results-subtitle')).toHaveTextContent(
+			'No alerts match your current filters. Try adjusting your search criteria.',
+		);
+
+		await user.click(screen.getByTestId('no-results-clear-button'));
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+		expect(
+			(screen.getByTestId('triggered-alerts-search-input') as HTMLInputElement)
+				.value,
+		).toBe('');
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.filter.test.tsx

@@ -0,0 +1,87 @@
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — severity filter', () => {
+	it('filters to only critical-severity rows when "Critical" is selected', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		await user.click(screen.getByTestId('triggered-alerts-filter-combobox'));
+
+		const criticalOption = await screen.findByText(
+			'Critical (severity:critical)',
+		);
+		await user.click(criticalOption);
+
+		await user.keyboard('{Escape}');
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument();
+			expect(screen.queryByText('Memory Warning')).not.toBeInTheDocument();
+			expect(screen.queryByText('Disk Slow')).not.toBeInTheDocument();
+			expect(screen.queryByText('Network Hiccup')).not.toBeInTheDocument();
+		});
+	});
+
+	it('shows union when multiple severities are selected', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		await user.click(screen.getByTestId('triggered-alerts-filter-combobox'));
+		const critical = await screen.findByText('Critical (severity:critical)');
+		await user.click(critical);
+
+		const warning = await screen.findByText('Warning (severity:warning)');
+		await user.click(warning);
+
+		await user.keyboard('{Escape}');
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument();
+			expect(screen.getByText('Memory Warning')).toBeInTheDocument();
+			expect(screen.queryByText('Disk Slow')).not.toBeInTheDocument();
+			expect(screen.queryByText('Network Hiccup')).not.toBeInTheDocument();
+		});
+	});
+
+	it('clearing the filter shows all rows again', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		await user.click(screen.getByTestId('triggered-alerts-filter-combobox'));
+		const critical = await screen.findByText('Critical (severity:critical)');
+		await user.click(critical);
+		await user.keyboard('{Escape}');
+
+		await waitFor(() =>
+			expect(screen.queryByText('Memory Warning')).not.toBeInTheDocument(),
+		);
+
+		// Reopen the filter combobox and deselect Critical (clicking again toggles).
+		await user.click(screen.getByTestId('triggered-alerts-filter-combobox'));
+		const criticalAgain = await screen.findByText('Critical (severity:critical)');
+		await user.click(criticalAgain);
+		await user.keyboard('{Escape}');
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument();
+			expect(screen.getByText('Memory Warning')).toBeInTheDocument();
+			expect(screen.getByText('Disk Slow')).toBeInTheDocument();
+			expect(screen.getByText('Network Hiccup')).toBeInTheDocument();
+		});
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.grouping.test.tsx

@@ -0,0 +1,85 @@
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — group by', () => {
+	it('renders a flat table when no group-by is selected', async () => {
+		renderTriggeredAlerts();
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+		// No "Group" column header in flat mode.
+		expect(screen.queryByText('Group')).not.toBeInTheDocument();
+	});
+
+	it('groups by service when "service" is selected', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		await user.click(screen.getByTestId('triggered-alerts-groupby-combobox'));
+
+		const serviceOption = await screen.findByText('service');
+		await user.click(serviceOption);
+		await user.keyboard('{Escape}');
+
+		await waitFor(() => expect(screen.getByText('Group')).toBeInTheDocument());
+
+		await waitFor(() => {
+			expect(screen.getByText('service:frontend')).toBeInTheDocument();
+			expect(screen.getByText('service:backend')).toBeInTheDocument();
+			expect(screen.getByText('service:misc')).toBeInTheDocument();
+		});
+	});
+
+	it('expands and collapses a group row to reveal nested alerts', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		await user.click(screen.getByTestId('triggered-alerts-groupby-combobox'));
+		const serviceOption = await screen.findByText('service');
+		await user.click(serviceOption);
+		await user.keyboard('{Escape}');
+
+		await waitFor(() =>
+			expect(screen.getByText('service:frontend')).toBeInTheDocument(),
+		);
+
+		// Nested rows aren't shown yet.
+		expect(screen.queryByText('High CPU Usage')).not.toBeInTheDocument();
+
+		// The "frontend" group sits first in the table; its expand toggle is the
+		// first `group-expand-toggle` in DOM order. Targeting by testid is safe
+		// against design changes that add other buttons to the row.
+		const expandToggles = screen.getAllByTestId('group-expand-toggle');
+		expect(expandToggles.length).toBeGreaterThan(0);
+		const frontendGroupBadge = screen.getByText('service:frontend');
+		const frontendRow = frontendGroupBadge.closest('tr');
+		expect(frontendRow).not.toBeNull();
+		const frontendToggle = (frontendRow as HTMLElement).querySelector(
+			'[data-testid="group-expand-toggle"]',
+		) as HTMLElement | null;
+		expect(frontendToggle).not.toBeNull();
+
+		await user.click(frontendToggle as HTMLElement);
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+		expect(screen.getByText('Disk Slow')).toBeInTheDocument();
+
+		await user.click(frontendToggle as HTMLElement);
+
+		await waitFor(() =>
+			expect(screen.queryByText('High CPU Usage')).not.toBeInTheDocument(),
+		);
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.list.test.tsx

@@ -0,0 +1,115 @@
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — list rendering', () => {
+	beforeEach(() => {
+		jest.setSystemTime(new Date('2023-10-20T12:00:00Z'));
+	});
+
+	it('renders alerts from the API', async () => {
+		renderTriggeredAlerts();
+
+		await expect(
+			screen.findByTestId('alert-row-fp-critical-1-name'),
+		).resolves.toHaveTextContent('High CPU Usage');
+		expect(screen.getByTestId('alert-row-fp-warning-1-name')).toHaveTextContent(
+			'Memory Warning',
+		);
+		expect(screen.getByTestId('alert-row-fp-info-1-name')).toHaveTextContent(
+			'Disk Slow',
+		);
+	});
+
+	it('renders severity badges for alerts that have severity', async () => {
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId('alert-row-fp-critical-1-name'),
+			).toBeInTheDocument(),
+		);
+
+		expect(
+			screen.getByTestId('alert-row-fp-critical-1-severity'),
+		).toHaveTextContent('critical');
+		expect(
+			screen.getByTestId('alert-row-fp-warning-1-severity'),
+		).toHaveTextContent('warning');
+		expect(screen.getByTestId('alert-row-fp-info-1-severity')).toHaveTextContent(
+			'info',
+		);
+		expect(
+			screen.getByTestId('alert-row-fp-noseverity-severity'),
+		).toHaveTextContent('-');
+	});
+
+	it('renders status tags reflecting the alert state', async () => {
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId('alert-row-fp-critical-1-name'),
+			).toBeInTheDocument(),
+		);
+
+		expect(
+			screen.getByTestId('alert-row-fp-critical-1-status'),
+		).toHaveTextContent('Firing');
+		expect(screen.getByTestId('alert-row-fp-info-1-status')).toHaveTextContent(
+			'Unprocessed',
+		);
+		expect(
+			screen.getByTestId('alert-row-fp-suppressed-1-status'),
+		).toHaveTextContent('Suppressed');
+	});
+
+	it('renders status badges with semantic colors', async () => {
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId('alert-row-fp-critical-1-status'),
+			).toBeInTheDocument(),
+		);
+
+		expect(screen.getByTestId('alert-row-fp-critical-1-status')).toHaveAttribute(
+			'data-color',
+			'cherry',
+		);
+		expect(screen.getByTestId('alert-row-fp-info-1-status')).toHaveAttribute(
+			'data-color',
+			'forest',
+		);
+		expect(
+			screen.getByTestId('alert-row-fp-critical-1-severity'),
+		).toHaveAttribute('data-color', 'cherry');
+		expect(screen.getByTestId('alert-row-fp-warning-1-severity')).toHaveAttribute(
+			'data-color',
+			'amber',
+		);
+	});
+
+	it('renders the search input and filter comboboxes', async () => {
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId('alert-row-fp-critical-1-name'),
+			).toBeInTheDocument(),
+		);
+
+		expect(
+			screen.getByTestId('triggered-alerts-search-input'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByPlaceholderText('Search alerts by name'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('triggered-alerts-filter-combobox'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('triggered-alerts-groupby-combobox'),
+		).toBeInTheDocument();
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.pagination.test.tsx

@@ -0,0 +1,76 @@
+import userEvent from '@testing-library/user-event';
+import { triggeredAlertsPaginationFixture } from 'mocks-server/__mockdata__/triggered_alerts';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, waitFor } from 'tests/test-utils';
+import { getCurrentNuqsQueryString } from 'tests/nuqs-helpers';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+function usePaginationHandler(): void {
+	server.use(
+		rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+			res(
+				ctx.status(200),
+				ctx.json({
+					data: triggeredAlertsPaginationFixture,
+					status: 'success',
+				}),
+			),
+		),
+	);
+}
+
+describe('TriggeredAlerts — pagination', () => {
+	// Default sort is duration ascending = newest startsAt first. Fixture indices
+	// 0..14 use startsAt 2023-10-01..15, so index 14 (newest) appears first and
+	// index 0 (oldest) appears last. Page 1 (limit 10) = items 14..5. Page 2 = 4..0.
+
+	it('shows the first 10 rows on page 1 by default', async () => {
+		usePaginationHandler();
+		renderTriggeredAlerts();
+
+		await screen.findByText('Pag Alert 14');
+
+		expect(screen.getByText('Pag Alert 5')).toBeInTheDocument();
+		expect(screen.queryByText('Pag Alert 4')).not.toBeInTheDocument();
+		expect(screen.queryByText('Pag Alert 0')).not.toBeInTheDocument();
+	});
+
+	it('renders a "page 2" pagination button reflecting total=15 with pageSize=10', async () => {
+		usePaginationHandler();
+		renderTriggeredAlerts();
+
+		await screen.findByText('Pag Alert 14');
+
+		const nav = screen.getByRole('navigation');
+		const page2 = Array.from(nav.querySelectorAll('button')).find(
+			(b) => b.textContent?.trim() === '2',
+		);
+		expect(page2).toBeDefined();
+	});
+
+	it('navigates to page 2 and shows the next batch of alerts', async () => {
+		usePaginationHandler();
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await screen.findByText('Pag Alert 14');
+
+		const nav = screen.getByRole('navigation');
+		const page2Button = Array.from(nav.querySelectorAll('button')).find(
+			(b) => b.textContent?.trim() === '2',
+		);
+		if (!page2Button) {
+			throw new Error('Page 2 button not found');
+		}
+		await user.click(page2Button);
+
+		await waitFor(() =>
+			expect(screen.getByText('Pag Alert 0')).toBeInTheDocument(),
+		);
+		expect(screen.getByText('Pag Alert 4')).toBeInTheDocument();
+		expect(screen.queryByText('Pag Alert 14')).not.toBeInTheDocument();
+		await waitFor(() => expect(getCurrentNuqsQueryString()).toContain('page=2'));
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.rowClick.test.tsx

@@ -0,0 +1,143 @@
+import userEvent from '@testing-library/user-event';
+import { logEventMock } from '__tests__/logEventMock';
+import { safeNavigateMock } from '__tests__/safeNavigateMock';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { getTriggeredAlertRowTestId, renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — row click', () => {
+	it('navigates to the alert overview with the rule id from labels on row click', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId(getTriggeredAlertRowTestId('fp-critical-1', 'name')),
+			).toBeInTheDocument(),
+		);
+
+		await user.click(
+			screen.getByTestId(getTriggeredAlertRowTestId('fp-critical-1', 'name')),
+		);
+
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			'/alerts/overview?ruleId=rule-1',
+		);
+		expect(logEventMock).toHaveBeenCalledWith(
+			'Alert: Triggered alert clicked',
+			expect.objectContaining({
+				ruleId: 'rule-1',
+				alertName: 'High CPU Usage',
+			}),
+		);
+	});
+
+	it('opens in a new tab when ctrl+clicked', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId(getTriggeredAlertRowTestId('fp-warning-1', 'name')),
+			).toBeInTheDocument(),
+		);
+
+		await user.keyboard('{Control>}');
+		await user.click(
+			screen.getByTestId(getTriggeredAlertRowTestId('fp-warning-1', 'name')),
+		);
+		await user.keyboard('{/Control}');
+
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			'/alerts/overview?ruleId=rule-2',
+			{ newTab: true },
+		);
+	});
+
+	it('navigates correctly when ruleId is parsed from generatorURL', async () => {
+		// Override fixture so the alert has no labels.ruleId but a valid
+		// generatorURL → getRuleId() falls back to parsing the URL.
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+				res(
+					ctx.status(200),
+					ctx.json({
+						data: [
+							{
+								fingerprint: 'fp-no-rule-label',
+								startsAt: '2023-10-19T10:00:00Z',
+								endsAt: '0001-01-01T00:00:00Z',
+								updatedAt: '2023-10-20T00:00:00Z',
+								generatorURL: 'http://localhost/alerts/edit?ruleId=rule-from-url',
+								labels: { alertname: 'URL Rule Alert' },
+								annotations: {},
+								status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+								receivers: [],
+							},
+						],
+						status: 'success',
+					}),
+				),
+			),
+		);
+
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId(getTriggeredAlertRowTestId('fp-no-rule-label', 'name')),
+			).toBeInTheDocument(),
+		);
+
+		await user.click(
+			screen.getByTestId(getTriggeredAlertRowTestId('fp-no-rule-label', 'name')),
+		);
+
+		expect(safeNavigateMock).toHaveBeenCalledWith(
+			'/alerts/overview?ruleId=rule-from-url',
+		);
+	});
+
+	it('does not navigate when the row has no ruleId anywhere', async () => {
+		server.use(
+			rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+				res(
+					ctx.status(200),
+					ctx.json({
+						data: [
+							{
+								fingerprint: 'fp-no-rule',
+								startsAt: '2023-10-19T10:00:00Z',
+								endsAt: '0001-01-01T00:00:00Z',
+								updatedAt: '2023-10-20T00:00:00Z',
+								labels: { alertname: 'No Rule Alert' },
+								annotations: {},
+								status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+								receivers: [],
+							},
+						],
+						status: 'success',
+					}),
+				),
+			),
+		);
+
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(
+				screen.getByTestId(getTriggeredAlertRowTestId('fp-no-rule', 'name')),
+			).toBeInTheDocument(),
+		);
+
+		await user.click(
+			screen.getByTestId(getTriggeredAlertRowTestId('fp-no-rule', 'name')),
+		);
+
+		expect(safeNavigateMock).not.toHaveBeenCalled();
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.search.test.tsx

@@ -0,0 +1,118 @@
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from 'tests/test-utils';
+
+import { renderTriggeredAlerts } from './_helpers';
+
+describe('TriggeredAlerts — search', () => {
+	it('filters rows by alertname when typing in the search input', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+		expect(screen.getByText('Memory Warning')).toBeInTheDocument();
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'CPU');
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument();
+			expect(screen.queryByText('Memory Warning')).not.toBeInTheDocument();
+		});
+	});
+
+	it('shows all rows again when search is cleared', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'CPU');
+
+		await waitFor(() =>
+			expect(screen.queryByText('Memory Warning')).not.toBeInTheDocument(),
+		);
+
+		await user.clear(input);
+
+		await waitFor(() => {
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument();
+			expect(screen.getByText('Memory Warning')).toBeInTheDocument();
+			expect(screen.getByText('Disk Slow')).toBeInTheDocument();
+		});
+	});
+
+	it('matches rows by label value (case-insensitive)', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		// "backend" matches `service: backend` labels on Memory Warning and Network Hiccup.
+		await user.type(input, 'backend');
+
+		await waitFor(() => {
+			expect(screen.getByText('Memory Warning')).toBeInTheDocument();
+			expect(screen.getByText('Network Hiccup')).toBeInTheDocument();
+			expect(screen.queryByText('High CPU Usage')).not.toBeInTheDocument();
+			expect(screen.queryByText('Disk Slow')).not.toBeInTheDocument();
+		});
+	});
+
+	it('matches rows by label key', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'staging');
+
+		await waitFor(() => {
+			expect(screen.getByText('Disk Slow')).toBeInTheDocument();
+			expect(screen.queryByText('High CPU Usage')).not.toBeInTheDocument();
+			expect(screen.queryByText('Memory Warning')).not.toBeInTheDocument();
+		});
+	});
+
+	it('renders the no-results empty state when the search matches nothing', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts();
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'zzzzznever-matches-anything');
+
+		await waitFor(() =>
+			expect(screen.getByTestId('no-results-empty-state')).toBeInTheDocument(),
+		);
+	});
+
+	it('resets pagination to page 1 when the search changes', async () => {
+		const user = userEvent.setup({ delay: null });
+		renderTriggeredAlerts({ initialRoute: '/?page=2&limit=2' });
+
+		await waitFor(() =>
+			expect(screen.getByText('Disk Slow')).toBeInTheDocument(),
+		);
+
+		const input = screen.getByTestId('triggered-alerts-search-input');
+		await user.type(input, 'CPU');
+
+		await waitFor(() =>
+			expect(screen.getByText('High CPU Usage')).toBeInTheDocument(),
+		);
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/TriggeredAlerts.utils.test.ts

@@ -0,0 +1,181 @@
+import type { SortState } from 'components/TanStackTableView/types';
+
+import type { Alert } from '../types';
+import {
+	getAlertSortValue,
+	getRuleId,
+	normalizeAlerts,
+	sortAlerts,
+} from '../utils';
+
+const alertWithFingerprint: Alert = {
+	fingerprint: 'fp-existing',
+	labels: { alertname: 'Test', severity: 'critical' },
+	annotations: {},
+	startsAt: '2023-10-19T10:00:00Z',
+	endsAt: '0001-01-01T00:00:00Z',
+	status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+	receivers: [],
+};
+
+const alertWithoutFingerprint: Alert = {
+	...alertWithFingerprint,
+	fingerprint: undefined,
+};
+
+describe('normalizeAlerts', () => {
+	it('returns empty array when given undefined', () => {
+		expect(normalizeAlerts(undefined)).toStrictEqual([]);
+	});
+
+	it('preserves existing fingerprints', () => {
+		const result = normalizeAlerts([alertWithFingerprint]);
+		expect(result).toHaveLength(1);
+		expect(result[0].fingerprint).toBe('fp-existing');
+	});
+
+	it('mints fingerprint when missing', () => {
+		const result = normalizeAlerts([alertWithoutFingerprint]);
+		expect(result[0].fingerprint).toBeDefined();
+		expect(typeof result[0].fingerprint).toBe('string');
+		expect(result[0].fingerprint?.length).toBeGreaterThan(0);
+	});
+
+	it('does not mutate the input array', () => {
+		const input = [alertWithFingerprint];
+		const copy = JSON.parse(JSON.stringify(input));
+		normalizeAlerts(input);
+		expect(input).toStrictEqual(copy);
+	});
+});
+
+describe('getAlertSortValue', () => {
+	const alert: Alert = {
+		fingerprint: 'fp',
+		labels: { alertname: 'CPU', severity: 'critical' },
+		annotations: {},
+		startsAt: '2023-10-19T10:00:00Z',
+		endsAt: '0001-01-01T00:00:00Z',
+		status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+		receivers: [],
+	};
+
+	it('returns status.state for "status"', () => {
+		expect(getAlertSortValue(alert, 'status')).toBe('active');
+	});
+
+	it('returns alertname for "alertName"', () => {
+		expect(getAlertSortValue(alert, 'alertName')).toBe('CPU');
+	});
+
+	it('returns severity for "severity"', () => {
+		expect(getAlertSortValue(alert, 'severity')).toBe('critical');
+	});
+
+	it('returns elapsed ms for "firingSince"', () => {
+		const result = getAlertSortValue(alert, 'firingSince');
+		expect(typeof result).toBe('number');
+		expect(result).toBeGreaterThan(0);
+	});
+
+	it('returns elapsed ms for "duration"', () => {
+		const result = getAlertSortValue(alert, 'duration');
+		expect(typeof result).toBe('number');
+	});
+
+	it('returns empty string for unknown columns', () => {
+		expect(getAlertSortValue(alert, 'unknown')).toBe('');
+	});
+
+	it('returns empty string for missing fields', () => {
+		const empty = { ...alert, status: undefined, labels: undefined };
+		expect(getAlertSortValue(empty, 'status')).toBe('');
+		expect(getAlertSortValue(empty, 'alertName')).toBe('');
+		expect(getAlertSortValue(empty, 'severity')).toBe('');
+	});
+
+	it('returns empty for firingSince with no startsAt', () => {
+		const empty = { ...alert, startsAt: undefined };
+		expect(getAlertSortValue(empty, 'firingSince')).toBe('');
+	});
+});
+
+describe('sortAlerts', () => {
+	const a: Alert = {
+		fingerprint: 'a',
+		labels: { alertname: 'A' },
+		annotations: {},
+		startsAt: '2023-10-19T10:00:00Z',
+		endsAt: '0001-01-01T00:00:00Z',
+		status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+		receivers: [],
+	};
+	const b: Alert = { ...a, fingerprint: 'b', labels: { alertname: 'B' } };
+	const c: Alert = { ...a, fingerprint: 'c', labels: { alertname: 'C' } };
+
+	it('sorts ascending when given orderBy', () => {
+		const order: SortState = { columnName: 'alertName', order: 'asc' };
+		const result = sortAlerts([c, a, b], order);
+		expect(result.map((x) => x.labels?.alertname)).toStrictEqual(['A', 'B', 'C']);
+	});
+
+	it('sorts descending', () => {
+		const order: SortState = { columnName: 'alertName', order: 'desc' };
+		const result = sortAlerts([a, b, c], order);
+		expect(result.map((x) => x.labels?.alertname)).toStrictEqual(['C', 'B', 'A']);
+	});
+
+	it('falls back to default duration asc when orderBy is null', () => {
+		const result = sortAlerts([a, b, c], null);
+		expect(result).toHaveLength(3);
+	});
+});
+
+describe('getRuleId', () => {
+	const base: Alert = {
+		labels: {},
+		annotations: {},
+		startsAt: '2023-10-19T10:00:00Z',
+		endsAt: '0001-01-01T00:00:00Z',
+		status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+		receivers: [],
+		fingerprint: 'fp',
+	};
+
+	it('returns labels.ruleId when present', () => {
+		expect(getRuleId({ ...base, labels: { ruleId: 'rule-1' } })).toBe('rule-1');
+	});
+
+	it('falls back to generatorURL when ruleId label missing', () => {
+		expect(
+			getRuleId({
+				...base,
+				generatorURL: 'http://localhost/foo?ruleId=rule-42',
+			}),
+		).toBe('rule-42');
+	});
+
+	it('prefers labels.ruleId over generatorURL', () => {
+		expect(
+			getRuleId({
+				...base,
+				labels: { ruleId: 'from-label' },
+				generatorURL: 'http://localhost/foo?ruleId=from-url',
+			}),
+		).toBe('from-label');
+	});
+
+	it('returns null when generatorURL has no ruleId param', () => {
+		expect(
+			getRuleId({ ...base, generatorURL: 'http://localhost/foo' }),
+		).toBeNull();
+	});
+
+	it('returns null when generatorURL is invalid', () => {
+		expect(getRuleId({ ...base, generatorURL: 'not-a-url' })).toBeNull();
+	});
+
+	it('returns null when no source available', () => {
+		expect(getRuleId(base)).toBeNull();
+	});
+});

frontend/src/container/TriggeredAlerts/__tests__/_helpers.tsx

@@ -0,0 +1,71 @@
+import { QueryClient, QueryClientProvider } from 'react-query';
+import { MemoryRouter } from 'react-router-dom';
+import { VirtuosoMockContext } from 'react-virtuoso';
+import { render, RenderResult, screen } from '@testing-library/react';
+import TriggeredAlerts from 'container/TriggeredAlerts';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { AppContext } from 'providers/App/App';
+import TimezoneProvider from 'providers/Timezone';
+import { onNuqsUrlUpdate, resetNuqsState } from 'tests/nuqs-helpers';
+import { getAppContextMock } from 'tests/test-utils';
+
+interface RenderOptions {
+	initialRoute?: string;
+}
+
+export function renderTriggeredAlerts(
+	options: RenderOptions = {},
+): RenderResult {
+	const { initialRoute = '/' } = options;
+
+	const initialSearch = initialRoute.includes('?')
+		? initialRoute.slice(initialRoute.indexOf('?'))
+		: '';
+	resetNuqsState(initialSearch);
+
+	const queryClient = new QueryClient({
+		defaultOptions: {
+			queries: { refetchOnWindowFocus: false, retry: false },
+			mutations: { retry: false },
+		},
+	});
+
+	return render(
+		<MemoryRouter initialEntries={[initialRoute]}>
+			<NuqsTestingAdapter
+				searchParams={initialSearch}
+				onUrlUpdate={onNuqsUrlUpdate}
+				rateLimitFactor={0}
+				hasMemory
+			>
+				<QueryClientProvider client={queryClient}>
+					<AppContext.Provider value={getAppContextMock('ADMIN')}>
+						<TimezoneProvider>
+							<VirtuosoMockContext.Provider
+								value={{ viewportHeight: 800, itemHeight: 46 }}
+							>
+								<TriggeredAlerts />
+							</VirtuosoMockContext.Provider>
+						</TimezoneProvider>
+					</AppContext.Provider>
+				</QueryClientProvider>
+			</NuqsTestingAdapter>
+		</MemoryRouter>,
+	);
+}
+
+export async function findAlertRow(alertName: string): Promise<HTMLElement> {
+	const cell = await screen.findByText(alertName, {}, { timeout: 5000 });
+	const row = cell.closest('tr');
+	if (!row) {
+		throw new Error(`Row not found for alert "${alertName}"`);
+	}
+	return row as HTMLElement;
+}
+
+export function getTriggeredAlertRowTestId(
+	fingerprint: string,
+	column: 'name' | 'severity' | 'status',
+): string {
+	return `alert-row-${fingerprint}-${column}`;
+}

frontend/src/container/TriggeredAlerts/components/AlertStatusTag.tsx

@@ -2,31 +2,32 @@ import { Badge } from '@signozhq/ui/badge';
 
 interface AlertStatusTagProps {
 	state: string;
+	testId?: string;
 }
 
-function AlertStatusTag({ state }: AlertStatusTagProps): JSX.Element {
+function AlertStatusTag({ state, testId }: AlertStatusTagProps): JSX.Element {
 	switch (state) {
 		case 'unprocessed':
 			return (
-				<Badge color="success" variant="outline">
+				<Badge color="success" variant="outline" testId={testId}>
 					Unprocessed
 				</Badge>
 			);
 		case 'active':
 			return (
-				<Badge color="error" variant="outline">
+				<Badge color="error" variant="outline" testId={testId}>
 					Firing
 				</Badge>
 			);
 		case 'suppressed':
 			return (
-				<Badge color="error" variant="outline">
+				<Badge color="error" variant="outline" testId={testId}>
 					Suppressed
 				</Badge>
 			);
 		default:
 			return (
-				<Badge color="secondary" variant="outline">
+				<Badge color="secondary" variant="outline" testId={testId}>
 					Unknown
 				</Badge>
 			);

frontend/src/container/TriggeredAlerts/components/EmptyStates.tsx

@@ -3,6 +3,7 @@ import { CircleCheck, Plus, RefreshCw } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import ROUTES from 'constants/routes';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import { isModifierKeyPressed } from 'utils/app';
 
 import styles from './EmptyStates.module.scss';
 
@@ -13,9 +14,12 @@ interface EmptyStateProps {
 export function EmptyState({ onRefresh }: EmptyStateProps): JSX.Element {
 	const { safeNavigate } = useSafeNavigate();
 
-	const handleCreateAlert = useCallback((): void => {
-		safeNavigate(ROUTES.ALERTS_NEW);
-	}, [safeNavigate]);
+	const handleCreateAlert = useCallback(
+		(e: React.MouseEvent): void => {
+			safeNavigate(ROUTES.ALERTS_NEW, { newTab: isModifierKeyPressed(e) });
+		},
+		[safeNavigate],
+	);
 
 	return (
 		<div className={styles.emptyState}>
@@ -30,6 +34,7 @@ export function EmptyState({ onRefresh }: EmptyStateProps): JSX.Element {
 					color="primary"
 					prefix={<Plus size={14} />}
 					onClick={handleCreateAlert}
+					testId="triggered-alerts-empty-create-button"
 				>
 					Create Alert Rule
 				</Button>
@@ -39,6 +44,7 @@ export function EmptyState({ onRefresh }: EmptyStateProps): JSX.Element {
 						color="secondary"
 						prefix={<RefreshCw size={14} />}
 						onClick={onRefresh}
+						testId="triggered-alerts-empty-refresh-button"
 					>
 						Refresh
 					</Button>

frontend/src/container/TriggeredAlerts/components/GroupTagsCell.tsx

@@ -44,6 +44,7 @@ export function GroupTagsCell({
 				prefix={
 					localIsExpanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />
 				}
+				testId="group-expand-toggle"
 			/>
 			<div className={styles.tagsContainer}>
 				{tags.map((tag) => (

frontend/src/container/TriggeredAlerts/index.tsx

@@ -175,6 +175,7 @@ function TriggeredAlerts(): JSX.Element {
 					value={searchText}
 					onChange={handleSearchChange}
 					suffix={<Search size={14} className={styles.searchIcon} />}
+					testId="triggered-alerts-search-input"
 				/>
 				<ComboboxSimple
 					className={styles.filterSelect}
@@ -186,6 +187,7 @@ function TriggeredAlerts(): JSX.Element {
 					allowCreate
 					items={severyFilters}
 					maxDisplayedPills={2}
+					testId="triggered-alerts-filter-combobox"
 				/>
 				<ComboboxSimple
 					className={styles.filterSelect}
@@ -196,6 +198,7 @@ function TriggeredAlerts(): JSX.Element {
 					items={labelOptions}
 					multiple
 					maxDisplayedPills={2}
+					testId="triggered-alerts-groupby-combobox"
 				/>
 			</div>
 

frontend/src/container/TriggeredAlerts/table.config.tsx

@@ -21,8 +21,11 @@ export function getAlertColumns(
 			width: { fixed: '100px' },
 			enableSort: false,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => (
-				<AlertStatusTag state={String(value ?? '')} />
+			cell: ({ row, value }): JSX.Element => (
+				<AlertStatusTag
+					state={String(value ?? '')}
+					testId={`alert-row-${row.fingerprint ?? ''}-status`}
+				/>
 			),
 		},
 		{
@@ -32,8 +35,11 @@ export function getAlertColumns(
 			width: { default: '100%' },
 			enableSort: true,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => (
-				<TanStackTable.Text title={value}>
+			cell: ({ row, value }): JSX.Element => (
+				<TanStackTable.Text
+					title={value}
+					data-testid={`alert-row-${row.fingerprint ?? ''}-name`}
+				>
 					{String(value ?? '-')}
 				</TanStackTable.Text>
 			),
@@ -45,15 +51,17 @@ export function getAlertColumns(
 			width: { fixed: '120px' },
 			enableSort: true,
 			enableMove: false,
-			cell: ({ value }): JSX.Element => {
+			cell: ({ row, value }): JSX.Element => {
 				const severity = String(value ?? '').toLowerCase();
+				const testId = `alert-row-${row.fingerprint ?? ''}-severity`;
 				if (!severity) {
-					return <TanStackTable.Text>-</TanStackTable.Text>;
+					return <TanStackTable.Text data-testid={testId}>-</TanStackTable.Text>;
 				}
 				return (
 					<Badge
 						color={SEVERITY_BADGE_COLORS[severity] ?? 'secondary'}
 						variant="outline"
+						testId={testId}
 					>
 						{severity}
 					</Badge>

frontend/src/hooks/queryBuilder/__tests__/useCreateAlerts.test.tsx

@@ -17,11 +17,6 @@ jest.mock('react-redux', () => ({
 	useSelector: jest.fn(),
 }));
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('api/dashboard/substitute_vars', () => ({
 	getSubstituteVars: jest.fn(),
 }));

frontend/src/mocks-server/__mockdata__/alert_rules.ts

@@ -0,0 +1,85 @@
+import {
+	RuletypesAlertStateDTO,
+	RuletypesAlertTypeDTO,
+	RuletypesPanelTypeDTO,
+	RuletypesQueryTypeDTO,
+	RuletypesRuleTypeDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type {
+	RuletypesRuleConditionDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+const baseCondition: RuletypesRuleConditionDTO = {
+	compositeQuery: {
+		queryType: RuletypesQueryTypeDTO.builder,
+		panelType: RuletypesPanelTypeDTO.graph,
+		queries: null,
+	},
+} as unknown as RuletypesRuleConditionDTO;
+
+const make = (
+	id: string,
+	overrides: Partial<RuletypesRuleDTO>,
+): RuletypesRuleDTO => ({
+	id,
+	alert: `Alert ${id}`,
+	alertType: RuletypesAlertTypeDTO.METRIC_BASED_ALERT,
+	condition: baseCondition,
+	createdAt: '2023-10-15T10:00:00Z',
+	updatedAt: '2023-10-19T10:00:00Z',
+	createdBy: 'alice@signoz.io',
+	updatedBy: 'alice@signoz.io',
+	disabled: false,
+	state: RuletypesAlertStateDTO.inactive,
+	labels: { severity: 'info' },
+	annotations: {},
+	source: '',
+	evalWindow: '5m0s',
+	frequency: '1m0s',
+	ruleType: RuletypesRuleTypeDTO.threshold_rule,
+	...overrides,
+});
+
+export const alertRulesFixture: RuletypesRuleDTO[] = [
+	make('rule-1', {
+		alert: 'High CPU Alert',
+		state: RuletypesAlertStateDTO.firing,
+		labels: { severity: 'critical', team: 'infra' },
+	}),
+	make('rule-2', {
+		alert: 'Memory Pending Alert',
+		state: RuletypesAlertStateDTO.pending,
+		labels: { severity: 'warning', team: 'backend' },
+	}),
+	make('rule-3', {
+		alert: 'Healthy Alert',
+		state: RuletypesAlertStateDTO.inactive,
+		labels: { severity: 'info', team: 'infra' },
+	}),
+	make('rule-4', {
+		alert: 'Disabled Alert',
+		state: RuletypesAlertStateDTO.disabled,
+		disabled: true,
+		labels: { severity: 'critical', team: 'frontend' },
+	}),
+	make('rule-5', {
+		alert: 'No Labels Alert',
+		state: RuletypesAlertStateDTO.inactive,
+		labels: {},
+	}),
+];
+
+export const alertRulesPaginationFixture: RuletypesRuleDTO[] = Array.from(
+	{ length: 15 },
+	(_, i) =>
+		make(`rule-pag-${i}`, {
+			alert: `Pag Rule ${i}`,
+			state:
+				i % 2 === 0
+					? RuletypesAlertStateDTO.firing
+					: RuletypesAlertStateDTO.inactive,
+			labels: { severity: i % 2 === 0 ? 'critical' : 'warning' },
+			createdAt: `2023-10-${String(i + 1).padStart(2, '0')}T10:00:00Z`,
+		}),
+);

frontend/src/mocks-server/__mockdata__/triggered_alerts.ts

@@ -0,0 +1,102 @@
+import type { AlertmanagertypesDeprecatedGettableAlertDTO } from 'api/generated/services/sigNoz.schemas';
+
+export const triggeredAlertsFixture: AlertmanagertypesDeprecatedGettableAlertDTO[] =
+	[
+		{
+			fingerprint: 'fp-critical-1',
+			startsAt: '2023-10-19T10:00:00Z',
+			endsAt: '0001-01-01T00:00:00Z',
+			generatorURL: 'http://localhost/alerts/edit?ruleId=rule-1&panelTypes=graph',
+			labels: {
+				alertname: 'High CPU Usage',
+				severity: 'critical',
+				ruleId: 'rule-1',
+				service: 'frontend',
+				env: 'prod',
+			},
+			annotations: {
+				summary: 'CPU above 90%',
+				description: 'Frontend CPU usage critical',
+			},
+			status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+			receivers: ['slack'],
+		},
+		{
+			fingerprint: 'fp-warning-1',
+			startsAt: '2023-10-19T09:00:00Z',
+			endsAt: '0001-01-01T00:00:00Z',
+			generatorURL: 'http://localhost/alerts/edit?ruleId=rule-2',
+			labels: {
+				alertname: 'Memory Warning',
+				severity: 'warning',
+				ruleId: 'rule-2',
+				service: 'backend',
+				env: 'prod',
+			},
+			annotations: { summary: 'Memory high' },
+			status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+			receivers: ['slack'],
+		},
+		{
+			fingerprint: 'fp-info-1',
+			startsAt: '2023-10-19T08:00:00Z',
+			endsAt: '0001-01-01T00:00:00Z',
+			generatorURL: 'http://localhost/alerts/edit?ruleId=rule-3',
+			labels: {
+				alertname: 'Disk Slow',
+				severity: 'info',
+				ruleId: 'rule-3',
+				service: 'frontend',
+				env: 'staging',
+			},
+			annotations: { summary: 'Disk slow' },
+			status: { state: 'unprocessed', silencedBy: [], inhibitedBy: [] },
+			receivers: ['email'],
+		},
+		{
+			fingerprint: 'fp-suppressed-1',
+			startsAt: '2023-10-19T07:00:00Z',
+			endsAt: '0001-01-01T00:00:00Z',
+			generatorURL: 'http://localhost/alerts/edit?ruleId=rule-4',
+			labels: {
+				alertname: 'Network Hiccup',
+				severity: 'error',
+				ruleId: 'rule-4',
+				service: 'backend',
+				env: 'dev',
+			},
+			annotations: { summary: 'Network errors' },
+			status: { state: 'suppressed', silencedBy: ['s-1'], inhibitedBy: [] },
+			receivers: ['pagerduty'],
+		},
+		{
+			fingerprint: 'fp-noseverity',
+			startsAt: '2023-10-19T06:00:00Z',
+			endsAt: '0001-01-01T00:00:00Z',
+			labels: {
+				alertname: 'Unknown Alert',
+				service: 'misc',
+			},
+			annotations: {},
+			status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+			receivers: [],
+		},
+	];
+
+// Bigger fixture for pagination tests (15 entries → 2 pages at limit=10).
+export const triggeredAlertsPaginationFixture: AlertmanagertypesDeprecatedGettableAlertDTO[] =
+	Array.from({ length: 15 }, (_, i) => ({
+		fingerprint: `fp-pag-${i}`,
+		startsAt: `2023-10-${String(i + 1).padStart(2, '0')}T10:00:00Z`,
+		endsAt: '0001-01-01T00:00:00Z',
+		generatorURL: `http://localhost/alerts/edit?ruleId=rule-pag-${i}`,
+		labels: {
+			alertname: `Pag Alert ${i}`,
+			severity: i % 2 === 0 ? 'critical' : 'warning',
+			ruleId: `rule-pag-${i}`,
+			service: 'frontend',
+		},
+		annotations: {},
+		status: { state: 'active', silencedBy: [], inhibitedBy: [] },
+		receivers: [],
+	}));

frontend/src/mocks-server/handlers.ts

@@ -3,6 +3,8 @@ import { rest } from 'msw';
 import commonEnTranslation from '../../public/locales/en/common.json';
 import enTranslation from '../../public/locales/en/translation.json';
 import { allAlertChannels } from './__mockdata__/alerts';
+import { alertRulesFixture } from './__mockdata__/alert_rules';
+import { triggeredAlertsFixture } from './__mockdata__/triggered_alerts';
 import { billingSuccessResponse } from './__mockdata__/billing';
 import {
 	dashboardSuccessResponse,
@@ -236,6 +238,38 @@ export const handlers = [
 	rest.get('http://localhost/api/v1/channels', (_, res, ctx) =>
 		res(ctx.status(200), ctx.json({ data: allAlertChannels, status: 'success' })),
 	),
+	rest.get('http://localhost/api/v1/alerts', (_, res, ctx) =>
+		res(
+			ctx.status(200),
+			ctx.json({ data: triggeredAlertsFixture, status: 'success' }),
+		),
+	),
+	rest.get('http://localhost/api/v2/rules', (_, res, ctx) =>
+		res(
+			ctx.status(200),
+			ctx.json({ data: alertRulesFixture, status: 'success' }),
+		),
+	),
+	rest.post('http://localhost/api/v2/rules', async (req, res, ctx) => {
+		const body = (await req.json()) as { alert?: string };
+		return res(
+			ctx.status(201),
+			ctx.json({
+				data: {
+					...alertRulesFixture[0],
+					id: 'new-rule-id',
+					alert: body?.alert ?? 'New Rule',
+				},
+				status: 'success',
+			}),
+		);
+	}),
+	rest.patch('http://localhost/api/v2/rules/:id', (_, res, ctx) =>
+		res(ctx.status(200), ctx.json({ status: 'success' })),
+	),
+	rest.delete('http://localhost/api/v2/rules/:id', (_, res, ctx) =>
+		res(ctx.status(200), ctx.json({ status: 'success' })),
+	),
 	rest.delete('http://localhost/api/v1/channels/:id', (_, res, ctx) =>
 		res(
 			ctx.status(200),

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/Panel.tsx

@@ -6,6 +6,10 @@ import { EllipsisVertical } from '@signozhq/icons';
 import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
 import cx from 'classnames';
 
+import type { DashboardSection } from '../../utils';
+import type { DeletePanelArgs } from './hooks/useDeletePanel';
+import type { MovePanelArgs } from './hooks/useMovePanelToSection';
+import PanelActionsMenu from './PanelActionsMenu/PanelActionsMenu';
 import styles from './Panel.module.scss';
 
 interface Props {
@@ -17,9 +21,22 @@ interface Props {
 	 * data. Currently unused on purpose.
 	 */
 	isVisible?: boolean;
+	/** Section actions — present only in editable sectioned mode. */
+	currentLayoutIndex?: number;
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
 }
 
-function Panel({ panel, panelId, isVisible }: Props): JSX.Element {
+function Panel({
+	panel,
+	panelId,
+	isVisible,
+	currentLayoutIndex,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
 	const name = panel?.spec?.display?.name || `Panel ${panelId.slice(0, 6)}`;
 	const description = panel?.spec?.display?.description;
 	const kind = panel?.spec?.plugin?.kind?.replace(/^signoz\//, '') ?? 'unknown';
@@ -48,7 +65,17 @@ function Panel({ panel, panelId, isVisible }: Props): JSX.Element {
 					</Typography.Text>
 					<Badge className={styles.badge}>{kind}</Badge>
 				</div>
-				<EllipsisVertical size={14} />
+				{currentLayoutIndex !== undefined && (onMovePanel || onDeletePanel) ? (
+					<PanelActionsMenu
+						panelId={panelId}
+						currentLayoutIndex={currentLayoutIndex}
+						sections={sections ?? []}
+						onMovePanel={onMovePanel}
+						onDeletePanel={onDeletePanel}
+					/>
+				) : (
+					<EllipsisVertical size={14} />
+				)}
 			</div>
 
 			<div className={styles.body}>

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelActionsMenu/PanelActionsMenu.module.scss

@@ -0,0 +1,16 @@
+.trigger {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	background: transparent;
+	border: none;
+	border-radius: 2px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		color: var(--bg-vanilla-100, #fff);
+		background: var(--bg-slate-400, #1d212d);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelActionsMenu/PanelActionsMenu.tsx

@@ -0,0 +1,95 @@
+import { useMemo } from 'react';
+import { EllipsisVertical, FolderInput, Trash2 } from '@signozhq/icons';
+import { DropdownMenuSimple } from '@signozhq/ui/dropdown-menu';
+import type { MenuItem } from '@signozhq/ui/dropdown-menu';
+
+import type { DashboardSection } from '../../../utils';
+import type { DeletePanelArgs } from '../hooks/useDeletePanel';
+import type { MovePanelArgs } from '../hooks/useMovePanelToSection';
+import styles from './PanelActionsMenu.module.scss';
+
+interface Props {
+	panelId: string;
+	currentLayoutIndex: number;
+	sections: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
+}
+
+function PanelActionsMenu({
+	panelId,
+	currentLayoutIndex,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const items = useMemo<MenuItem[]>(() => {
+		const result: MenuItem[] = [];
+
+		if (onMovePanel) {
+			const targets = sections.filter(
+				(s) => s.title && s.layoutIndex !== currentLayoutIndex,
+			);
+			if (targets.length === 0) {
+				result.push({
+					key: 'move',
+					label: 'Move to section',
+					icon: <FolderInput size={14} />,
+					disabled: true,
+				});
+			} else {
+				result.push({
+					key: 'move',
+					label: 'Move to section',
+					icon: <FolderInput size={14} />,
+					children: targets.map((s) => ({
+						key: `move-${s.layoutIndex}`,
+						label: s.title,
+						onClick: (): void =>
+							onMovePanel({
+								panelId,
+								fromLayoutIndex: currentLayoutIndex,
+								toLayoutIndex: s.layoutIndex,
+							}),
+					})),
+				});
+			}
+		}
+
+		if (onDeletePanel) {
+			if (result.length > 0) {
+				result.push({ type: 'divider' });
+			}
+			result.push({
+				key: 'delete-panel',
+				danger: true,
+				icon: <Trash2 size={14} />,
+				label: 'Delete panel',
+				onClick: (): void =>
+					onDeletePanel({ panelId, layoutIndex: currentLayoutIndex }),
+			});
+		}
+
+		return result;
+	}, [sections, currentLayoutIndex, panelId, onMovePanel, onDeletePanel]);
+
+	return (
+		<DropdownMenuSimple menu={{ items }}>
+			<button
+				type="button"
+				className={styles.trigger}
+				aria-label="Panel actions"
+				data-testid={`panel-actions-${panelId}`}
+				// Stop pointer/mouse down from reaching the RGL drag handle this
+				// button lives inside, so opening the menu never starts a panel drag.
+				onPointerDown={(e): void => e.stopPropagation()}
+				onMouseDown={(e): void => e.stopPropagation()}
+				onClick={(e): void => e.stopPropagation()}
+			>
+				<EllipsisVertical size={14} />
+			</button>
+		</DropdownMenuSimple>
+	);
+}
+
+export default PanelActionsMenu;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.module.scss

@@ -0,0 +1,22 @@
+.grid {
+	display: grid;
+	grid-template-columns: repeat(2, 1fr);
+	gap: 8px;
+}
+
+.typeButton {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	padding: 12px;
+	background: var(--bg-ink-400, #0b0c0e);
+	border: 1px solid var(--bg-slate-400, #1d212d);
+	border-radius: 4px;
+	color: var(--bg-vanilla-100, #fff);
+	cursor: pointer;
+	text-align: left;
+
+	&:hover {
+		border-color: var(--bg-robin-500);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.tsx

@@ -0,0 +1,82 @@
+import { Modal } from 'antd';
+import {
+	BarChart,
+	ChartLine,
+	ChartPie,
+	Hash,
+	List,
+	Table,
+} from '@signozhq/icons';
+
+import styles from './PanelTypeSelectionModal.module.scss';
+
+interface PanelType {
+	pluginKind: string;
+	label: string;
+	icon: JSX.Element;
+}
+
+const PANEL_TYPES: PanelType[] = [
+	{
+		pluginKind: 'signoz/TimeSeriesPanel',
+		label: 'Time Series',
+		icon: <ChartLine size={16} />,
+	},
+	{ pluginKind: 'signoz/NumberPanel', label: 'Value', icon: <Hash size={16} /> },
+	{ pluginKind: 'signoz/TablePanel', label: 'Table', icon: <Table size={16} /> },
+	{
+		pluginKind: 'signoz/BarChartPanel',
+		label: 'Bar Chart',
+		icon: <BarChart size={16} />,
+	},
+	{
+		pluginKind: 'signoz/PieChartPanel',
+		label: 'Pie Chart',
+		icon: <ChartPie size={16} />,
+	},
+	{
+		pluginKind: 'signoz/HistogramPanel',
+		label: 'Histogram',
+		icon: <BarChart size={16} />,
+	},
+	{ pluginKind: 'signoz/ListPanel', label: 'List', icon: <List size={16} /> },
+];
+
+interface Props {
+	open: boolean;
+	onClose: () => void;
+	onSelect: (pluginKind: string) => void;
+}
+
+function PanelTypeSelectionModal({
+	open,
+	onClose,
+	onSelect,
+}: Props): JSX.Element {
+	return (
+		<Modal
+			open={open}
+			title="Select a panel type"
+			onCancel={onClose}
+			footer={null}
+			destroyOnClose
+		>
+			<div className={styles.grid}>
+				{PANEL_TYPES.map((type) => (
+					<button
+						key={type.pluginKind}
+						type="button"
+						className={styles.typeButton}
+						data-testid={`panel-type-${type.pluginKind}`}
+						onClick={(): void => onSelect(type.pluginKind)}
+					>
+						{type.icon}
+						{type.label}
+					</button>
+				))}
+			</div>
+		</Modal>
+	);
+}
+
+export default PanelTypeSelectionModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useAddPanelToSection.ts

@@ -0,0 +1,76 @@
+import { useCallback } from 'react';
+import { v4 as uuid } from 'uuid';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import {
+	addPanelToSectionOps,
+	createDefaultPanel,
+	panelRef,
+} from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+export interface AddPanelArgs {
+	layoutIndex: number;
+	pluginKind: string;
+}
+
+/**
+ * Creates a new panel and places its item ref at the bottom of the target
+ * section, as one atomic patch. Structure-only: the panel is a valid minimal
+ * placeholder (its query is filled in once the panel editor lands).
+ */
+export function useAddPanelToSection({
+	sections,
+}: Params): (args: AddPanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({ layoutIndex, pluginKind }: AddPanelArgs): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const target = sections.find((s) => s.layoutIndex === layoutIndex);
+			if (!target) {
+				return;
+			}
+
+			const panelId = uuid();
+			const nextY = target.items.reduce(
+				(max, i) => Math.max(max, i.y + i.height),
+				0,
+			);
+
+			try {
+				await patchDashboardV2(
+					{ id: dashboardId },
+					addPanelToSectionOps({
+						panelId,
+						panel: createDefaultPanel(pluginKind),
+						layoutIndex,
+						item: {
+							x: 0,
+							y: nextY,
+							width: 6,
+							height: 6,
+							content: { $ref: panelRef(panelId) },
+						},
+					}),
+				);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDeletePanel.ts

@@ -0,0 +1,54 @@
+import { useCallback } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { removePanelOp, replaceSectionItemsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+export interface DeletePanelArgs {
+	panelId: string;
+	layoutIndex: number;
+}
+
+/**
+ * Removes a panel: drops its item ref from the section's items and deletes the
+ * panel from `spec.panels`, as one atomic patch.
+ */
+export function useDeletePanel({
+	sections,
+}: Params): (args: DeletePanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({ panelId, layoutIndex }: DeletePanelArgs): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const section = sections.find((s) => s.layoutIndex === layoutIndex);
+			if (!section) {
+				return;
+			}
+
+			const nextItems = section.items.filter((i) => i.id !== panelId);
+			try {
+				await patchDashboardV2({ id: dashboardId }, [
+					replaceSectionItemsOp(layoutIndex, nextItems),
+					removePanelOp(panelId),
+				]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useMovePanelToSection.ts

@@ -0,0 +1,79 @@
+import { useCallback } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { movePanelBetweenSectionsOps } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+export interface MovePanelArgs {
+	panelId: string;
+	fromLayoutIndex: number;
+	toLayoutIndex: number;
+}
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+/**
+ * Relocates a panel's item ref from one section to another. The panel itself
+ * stays in `spec.panels`; only the grid item moves, dropped into a free row at
+ * the bottom of the target section. Persisted as one atomic patch.
+ */
+export function useMovePanelToSection({
+	sections,
+}: Params): (args: MovePanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({
+			panelId,
+			fromLayoutIndex,
+			toLayoutIndex,
+		}: MovePanelArgs): Promise<void> => {
+			if (!dashboardId || fromLayoutIndex === toLayoutIndex) {
+				return;
+			}
+
+			const source = sections.find((s) => s.layoutIndex === fromLayoutIndex);
+			const target = sections.find((s) => s.layoutIndex === toLayoutIndex);
+			if (!source || !target) {
+				return;
+			}
+
+			const moved = source.items.find((i) => i.id === panelId);
+			if (!moved) {
+				return;
+			}
+
+			const sourceItems = source.items.filter((i) => i.id !== panelId);
+			// Place at a fresh row at the bottom of the target section.
+			const nextY = target.items.reduce(
+				(max, i) => Math.max(max, i.y + i.height),
+				0,
+			);
+			const targetItems = [...target.items, { ...moved, x: 0, y: nextY }];
+
+			try {
+				await patchDashboardV2(
+					{ id: dashboardId },
+					movePanelBetweenSectionsOps({
+						sourceIndex: fromLayoutIndex,
+						sourceItems,
+						targetIndex: toLayoutIndex,
+						targetItems,
+					}),
+				);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/AddSectionControl/AddSectionControl.module.scss

@@ -0,0 +1,17 @@
+.addButton {
+	display: inline-flex;
+	align-items: center;
+	gap: 6px;
+	margin-top: 8px;
+	padding: 8px 12px;
+	background: transparent;
+	border: 1px dashed var(--bg-slate-400, #1d212d);
+	border-radius: 4px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		border-color: var(--bg-robin-500);
+		color: var(--bg-vanilla-100, #fff);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/AddSectionControl/AddSectionControl.tsx

@@ -0,0 +1,67 @@
+import { useState } from 'react';
+import { Plus } from '@signozhq/icons';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+
+import type { DashboardSection } from '../../../utils';
+import { useAddSection } from '../hooks/useAddSection';
+import { useFirstSectionMigration } from '../hooks/useFirstSectionMigration';
+import FirstSectionMigrationModal from '../FirstSectionMigrationModal';
+import styles from './AddSectionControl.module.scss';
+
+const DEFAULT_SECTION_TITLE = 'New section';
+
+interface Props {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+	isSectioned: boolean;
+}
+
+function AddSectionControl({
+	sections,
+	layouts,
+	isSectioned,
+}: Props): JSX.Element {
+	const [isMigrationOpen, setIsMigrationOpen] = useState(false);
+	const { addSection } = useAddSection({ layouts });
+	const { migrate, isSaving } = useFirstSectionMigration({ sections });
+
+	// Free-flowing dashboard with existing panels → must migrate before sections
+	// can coexist (every panel must belong to a section once any exists).
+	const needsMigration =
+		!isSectioned && sections.some((s) => s.items.length > 0);
+
+	const handleClick = (): void => {
+		if (needsMigration) {
+			setIsMigrationOpen(true);
+			return;
+		}
+		void addSection(DEFAULT_SECTION_TITLE);
+	};
+
+	const handleConfirmMigration = async (): Promise<void> => {
+		await migrate(DEFAULT_SECTION_TITLE);
+		setIsMigrationOpen(false);
+	};
+
+	return (
+		<>
+			<button
+				type="button"
+				className={styles.addButton}
+				onClick={handleClick}
+				data-testid="add-section"
+			>
+				<Plus size={14} />
+				Add section
+			</button>
+			<FirstSectionMigrationModal
+				open={isMigrationOpen}
+				isSaving={isSaving}
+				onClose={(): void => setIsMigrationOpen(false)}
+				onConfirm={handleConfirmMigration}
+			/>
+		</>
+	);
+}
+
+export default AddSectionControl;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/FirstSectionMigrationModal.tsx

@@ -0,0 +1,41 @@
+import { Modal } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+
+interface Props {
+	open: boolean;
+	isSaving: boolean;
+	onClose: () => void;
+	onConfirm: () => void;
+}
+
+/**
+ * Shown when the user adds the first section to a free-flowing dashboard that
+ * already has panels. Confirms grouping the existing panels into a section
+ * before proceeding.
+ */
+function FirstSectionMigrationModal({
+	open,
+	isSaving,
+	onClose,
+	onConfirm,
+}: Props): JSX.Element {
+	return (
+		<Modal
+			open={open}
+			title="Group panels into sections?"
+			onCancel={onClose}
+			onOk={onConfirm}
+			okText="Continue"
+			okButtonProps={{ disabled: isSaving, 'data-testid': 'confirm-migration' }}
+			destroyOnClose
+		>
+			<Typography.Text>
+				This dashboard&apos;s panels are currently free-flowing. Adding a section
+				will move the existing panels into their own section, and a new empty
+				section will be added below. You can rename sections afterwards.
+			</Typography.Text>
+		</Modal>
+	);
+}
+
+export default FirstSectionMigrationModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/RenameSectionModal.tsx

@@ -0,0 +1,64 @@
+import { useEffect, useState } from 'react';
+import { Modal } from 'antd';
+import { Input } from '@signozhq/ui/input';
+
+interface Props {
+	open: boolean;
+	initialValue: string;
+	isSaving: boolean;
+	onClose: () => void;
+	onSubmit: (title: string) => void;
+}
+
+function RenameSectionModal({
+	open,
+	initialValue,
+	isSaving,
+	onClose,
+	onSubmit,
+}: Props): JSX.Element {
+	const [value, setValue] = useState<string>(initialValue);
+
+	// Reseed the field each time the modal opens.
+	useEffect(() => {
+		if (open) {
+			setValue(initialValue);
+		}
+	}, [open, initialValue]);
+
+	const submit = (): void => {
+		const trimmed = value.trim();
+		if (trimmed) {
+			onSubmit(trimmed);
+		}
+	};
+
+	return (
+		<Modal
+			open={open}
+			title="Rename section"
+			onCancel={onClose}
+			onOk={submit}
+			okText="Rename"
+			okButtonProps={{ disabled: isSaving || !value.trim() }}
+			destroyOnClose
+		>
+			<Input
+				testId="rename-section-input"
+				autoFocus
+				value={value}
+				maxLength={120}
+				placeholder="Section name"
+				onChange={(e): void => setValue(e.target.value)}
+				onKeyDown={(e): void => {
+					if (e.key === 'Enter') {
+						e.preventDefault();
+						submit();
+					}
+				}}
+			/>
+		</Modal>
+	);
+}
+
+export default RenameSectionModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/Section/Section.tsx

@@ -1,17 +1,45 @@
 import { useRef, useState } from 'react';
+import { Modal } from 'antd';
 
 import { useIntersectionObserver } from 'hooks/useIntersectionObserver';
 
 import type { DashboardSection } from '../../../utils';
+import type { AddPanelArgs } from '../../Panel/hooks/useAddPanelToSection';
+import type { DeletePanelArgs } from '../../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../../Panel/hooks/useMovePanelToSection';
+import PanelTypeSelectionModal from '../../Panel/PanelTypeSelectionModal/PanelTypeSelectionModal';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import { useDeleteSection } from '../hooks/useDeleteSection';
+import { useRenameSection } from '../hooks/useRenameSection';
+import { useToggleSectionCollapse } from '../hooks/useToggleSectionCollapse';
+import RenameSectionModal from '../RenameSectionModal';
 import SectionGrid from '../SectionGrid/SectionGrid';
-import SectionHeader from '../SectionHeader/SectionHeader';
+import SectionHeader, {
+	type SectionDragHandle,
+} from '../SectionHeader/SectionHeader';
 import styles from './Section.module.scss';
 
 interface Props {
 	section: DashboardSection;
+	/** Adds a panel to this section; present only in editable sectioned mode. */
+	onAddPanel?: (args: AddPanelArgs) => void;
+	/** All sections + per-panel handlers, for the panel "Move to section" / delete actions. */
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
+	/** Provided by SortableSection in sectioned mode; absent for untitled/free-flow. */
+	dragHandle?: SectionDragHandle;
 }
 
-function Section({ section }: Props): JSX.Element {
+function Section({
+	section,
+	onAddPanel,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+	dragHandle,
+}: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
 	const containerRef = useRef<HTMLDivElement>(null);
 	// Placeholder signal for lazy panel query-loading (consumed in a later PR):
 	// true once the section scrolls into (or near) the viewport.
@@ -19,10 +47,48 @@ function Section({ section }: Props): JSX.Element {
 		rootMargin: '200px',
 	});
 
-	const [open, setOpen] = useState<boolean>(section.open);
-	const toggle = (): void => setOpen((prev) => !prev);
+	const { open, toggle } = useToggleSectionCollapse({ sectionId: section.id });
 
-	const grid = <SectionGrid items={section.items} isVisible={isVisible} />;
+	const [isRenaming, setIsRenaming] = useState(false);
+	const { rename, isSaving } = useRenameSection({
+		layoutIndex: section.layoutIndex,
+	});
+
+	const handleRenameSubmit = async (title: string): Promise<void> => {
+		const ok = await rename(title);
+		if (ok) {
+			setIsRenaming(false);
+		}
+	};
+
+	const [isAddingPanel, setIsAddingPanel] = useState(false);
+	const handleSelectPanelType = (pluginKind: string): void => {
+		onAddPanel?.({ layoutIndex: section.layoutIndex, pluginKind });
+		setIsAddingPanel(false);
+	};
+
+	const { deleteSection } = useDeleteSection({ section });
+	const confirmDeleteSection = (): void => {
+		Modal.confirm({
+			title: `Delete section "${section.title ?? ''}"?`,
+			content: 'Panels in this section will be removed.',
+			okText: 'Delete',
+			okButtonProps: { danger: true },
+			centered: true,
+			onOk: () => deleteSection(),
+		});
+	};
+
+	const grid = (
+		<SectionGrid
+			items={section.items}
+			layoutIndex={section.layoutIndex}
+			isVisible={isVisible}
+			sections={sections}
+			onMovePanel={onMovePanel}
+			onDeletePanel={onDeletePanel}
+		/>
+	);
 
 	if (!section.title) {
 		// Untitled section — just the grid (no header chrome), but still observed
@@ -51,8 +117,26 @@ function Section({ section }: Props): JSX.Element {
 				open={open}
 				onToggle={toggle}
 				repeatVariable={section.repeatVariable}
+				dragHandle={dragHandle}
+				onRename={isEditable ? (): void => setIsRenaming(true) : undefined}
+				onAddPanel={
+					isEditable && onAddPanel ? (): void => setIsAddingPanel(true) : undefined
+				}
+				onDeleteSection={isEditable ? confirmDeleteSection : undefined}
 			/>
 			{open ? grid : null}
+			<RenameSectionModal
+				open={isRenaming}
+				initialValue={section.title}
+				isSaving={isSaving}
+				onClose={(): void => setIsRenaming(false)}
+				onSubmit={handleRenameSubmit}
+			/>
+			<PanelTypeSelectionModal
+				open={isAddingPanel}
+				onClose={(): void => setIsAddingPanel(false)}
+				onSelect={handleSelectPanelType}
+			/>
 		</div>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionActionsMenu/SectionActionsMenu.module.scss

@@ -0,0 +1,16 @@
+.trigger {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	background: transparent;
+	border: none;
+	border-radius: 2px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		color: var(--bg-vanilla-100, #fff);
+		background: var(--bg-slate-400, #1d212d);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionActionsMenu/SectionActionsMenu.tsx

@@ -0,0 +1,68 @@
+import { useMemo } from 'react';
+import { EllipsisVertical, PenLine, Plus, Trash2 } from '@signozhq/icons';
+import { DropdownMenuSimple } from '@signozhq/ui/dropdown-menu';
+import type { MenuItem } from '@signozhq/ui/dropdown-menu';
+
+import styles from './SectionActionsMenu.module.scss';
+
+interface Props {
+	sectionId: string;
+	onAddPanel?: () => void;
+	onRename?: () => void;
+	onDeleteSection?: () => void;
+}
+
+function SectionActionsMenu({
+	sectionId,
+	onAddPanel,
+	onRename,
+	onDeleteSection,
+}: Props): JSX.Element {
+	const items = useMemo<MenuItem[]>(() => {
+		const result: MenuItem[] = [];
+		if (onAddPanel) {
+			result.push({
+				key: 'add-panel',
+				icon: <Plus size={14} />,
+				label: 'Add panel',
+				onClick: onAddPanel,
+			});
+		}
+		if (onRename) {
+			result.push({
+				key: 'rename',
+				icon: <PenLine size={14} />,
+				label: 'Rename section',
+				onClick: onRename,
+			});
+		}
+		if (onDeleteSection) {
+			result.push(
+				{ type: 'divider' },
+				{
+					key: 'delete-section',
+					danger: true,
+					icon: <Trash2 size={14} />,
+					label: 'Delete section',
+					onClick: onDeleteSection,
+				},
+			);
+		}
+		return result;
+	}, [onAddPanel, onRename, onDeleteSection]);
+
+	return (
+		<DropdownMenuSimple menu={{ items }}>
+			<button
+				type="button"
+				className={styles.trigger}
+				aria-label="Section actions"
+				data-testid={`dashboard-section-actions-${sectionId}`}
+			>
+				<EllipsisVertical size={14} />
+			</button>
+		</DropdownMenuSimple>
+	);
+}
+
+export default SectionActionsMenu;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionDragPreview/SectionDragPreview.module.scss

@@ -0,0 +1,7 @@
+.preview {
+	border: 1px solid var(--bg-robin-500);
+	border-radius: 4px;
+	background: var(--bg-ink-400, #0b0c0e);
+	box-shadow: 0 8px 24px rgb(0 0 0 / 40%);
+	cursor: grabbing;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionDragPreview/SectionDragPreview.tsx

@@ -0,0 +1,32 @@
+import type { DashboardSection } from '../../../utils';
+import SectionHeader from '../SectionHeader/SectionHeader';
+import styles from './SectionDragPreview.module.scss';
+
+interface Props {
+	section: DashboardSection;
+}
+
+/**
+ * Lightweight preview rendered inside the DragOverlay while a section is being
+ * dragged. Deliberately header-only (no react-grid-layout) so the overlay is
+ * cheap and never triggers RGL width re-measurement.
+ */
+function SectionDragPreview({ section }: Props): JSX.Element {
+	const panelCount = section.items.length;
+	const title = `${section.title ?? ''} · ${panelCount} ${
+		panelCount === 1 ? 'panel' : 'panels'
+	}`;
+
+	return (
+		<div className={styles.preview}>
+			<SectionHeader
+				sectionId={`${section.id}-preview`}
+				title={title}
+				open={false}
+				onToggle={(): void => undefined}
+			/>
+		</div>
+	);
+}
+
+export default SectionDragPreview;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionGrid/SectionGrid.tsx

@@ -2,18 +2,35 @@ import { useMemo } from 'react';
 import GridLayout, { WidthProvider, type Layout } from 'react-grid-layout';
 
 import type { DashboardSection } from '../../../utils';
+import type { DeletePanelArgs } from '../../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../../Panel/hooks/useMovePanelToSection';
 import Panel from '../../Panel/Panel';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import { usePersistLayout } from '../hooks/usePersistLayout';
 import styles from './SectionGrid.module.scss';
 
 const ResponsiveGridLayout = WidthProvider(GridLayout);
 
 interface Props {
 	items: DashboardSection['items'];
+	layoutIndex: number;
 	/** Forwarded to panels — true when the parent section is in the viewport. */
 	isVisible?: boolean;
+	/** All sections + handlers — present only in editable sectioned mode (panel "Move to section" / delete). */
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
 }
 
-function SectionGrid({ items, isVisible }: Props): JSX.Element {
+function SectionGrid({
+	items,
+	layoutIndex,
+	isVisible,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
 	const rglLayout = useMemo<Layout[]>(
 		() =>
 			items.map((item) => ({
@@ -26,6 +43,8 @@ function SectionGrid({ items, isVisible }: Props): JSX.Element {
 		[items],
 	);
 
+	const { handleLayoutChange } = usePersistLayout({ layoutIndex, items });
+
 	return (
 		<ResponsiveGridLayout
 			className={styles.grid}
@@ -34,13 +53,24 @@ function SectionGrid({ items, isVisible }: Props): JSX.Element {
 			autoSize
 			useCSSTransforms
 			layout={rglLayout}
-			isDraggable={false}
-			isResizable={false}
+			draggableHandle=".panel-drag-handle"
+			isDraggable={isEditable}
+			isResizable={isEditable}
+			onDragStop={handleLayoutChange}
+			onResizeStop={handleLayoutChange}
 			margin={[8, 8]}
 		>
 			{items.map((item) => (
 				<div key={item.id}>
-					<Panel panel={item.panel} panelId={item.id} isVisible={isVisible} />
+					<Panel
+						panel={item.panel}
+						panelId={item.id}
+						isVisible={isVisible}
+						currentLayoutIndex={layoutIndex}
+						sections={isEditable ? sections : undefined}
+						onMovePanel={isEditable ? onMovePanel : undefined}
+						onDeletePanel={isEditable ? onDeletePanel : undefined}
+					/>
 				</div>
 			))}
 		</ResponsiveGridLayout>

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionHeader/SectionHeader.tsx

@@ -1,15 +1,29 @@
-import { ChevronDown, ChevronRight } from '@signozhq/icons';
+import type { DraggableAttributes } from '@dnd-kit/core';
+import type { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+import { ChevronDown, ChevronRight, GripVertical } from '@signozhq/icons';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
 
+import SectionActionsMenu from '../SectionActionsMenu/SectionActionsMenu';
 import styles from './SectionHeader.module.scss';
 
+export interface SectionDragHandle {
+	attributes: DraggableAttributes;
+	listeners: SyntheticListenerMap | undefined;
+	setActivatorNodeRef: (element: HTMLElement | null) => void;
+}
+
 interface Props {
 	sectionId: string;
 	title: string;
 	open: boolean;
 	onToggle: () => void;
 	repeatVariable?: string;
+	/** Provided by SortableSection in sectioned mode; absent for untitled/free-flow. */
+	dragHandle?: SectionDragHandle;
+	onRename?: () => void;
+	onAddPanel?: () => void;
+	onDeleteSection?: () => void;
 }
 
 function SectionHeader({
@@ -18,9 +32,27 @@ function SectionHeader({
 	open,
 	onToggle,
 	repeatVariable,
+	dragHandle,
+	onRename,
+	onAddPanel,
+	onDeleteSection,
 }: Props): JSX.Element {
+	const hasActions = !!(onAddPanel || onRename || onDeleteSection);
 	return (
 		<div className={cx(styles.header, { [styles.headerOpen]: open })}>
+			{dragHandle ? (
+				<button
+					type="button"
+					className={styles.dragHandle}
+					ref={dragHandle.setActivatorNodeRef}
+					aria-label="Drag to reorder section"
+					data-testid={`dashboard-section-drag-${sectionId}`}
+					{...dragHandle.attributes}
+					{...dragHandle.listeners}
+				>
+					<GripVertical size={14} />
+				</button>
+			) : null}
 			<button
 				type="button"
 				className={styles.toggle}
@@ -35,6 +67,14 @@ function SectionHeader({
 					</Typography.Text>
 				) : null}
 			</button>
+			{hasActions ? (
+				<SectionActionsMenu
+					sectionId={sectionId}
+					onAddPanel={onAddPanel}
+					onRename={onRename}
+					onDeleteSection={onDeleteSection}
+				/>
+			) : null}
 		</div>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionList.tsx

@@ -0,0 +1,102 @@
+import { useMemo } from 'react';
+import { closestCenter, DndContext, DragOverlay } from '@dnd-kit/core';
+import {
+	restrictToParentElement,
+	restrictToVerticalAxis,
+} from '@dnd-kit/modifiers';
+import {
+	SortableContext,
+	verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+
+import type { DashboardSection } from '../../utils';
+import { useAddPanelToSection } from '../Panel/hooks/useAddPanelToSection';
+import { useDeletePanel } from '../Panel/hooks/useDeletePanel';
+import { useMovePanelToSection } from '../Panel/hooks/useMovePanelToSection';
+import { useDashboardStore } from '../../store/useDashboardStore';
+import { useSectionDragReorder } from './hooks/useSectionDragReorder';
+import Section from './Section/Section';
+import SectionDragPreview from './SectionDragPreview/SectionDragPreview';
+import SortableSection from './SortableSection';
+
+interface Props {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+function SectionList({ sections, layouts }: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
+
+	const {
+		sensors,
+		orderedSections,
+		activeSection,
+		onDragStart,
+		onDragEnd,
+		onDragCancel,
+	} = useSectionDragReorder({ sections, layouts });
+
+	const onAddPanel = useAddPanelToSection({ sections });
+	const onMovePanel = useMovePanelToSection({ sections });
+	const onDeletePanel = useDeletePanel({ sections });
+
+	// Only titled sections participate in reordering; untitled (free-flow)
+	// blocks render in place without a drag handle.
+	const sortableIds = useMemo(
+		() => orderedSections.filter((s) => s.title).map((s) => s.id),
+		[orderedSections],
+	);
+
+	if (!isEditable) {
+		return (
+			<>
+				{sections.map((section) => (
+					<Section key={section.id} section={section} />
+				))}
+			</>
+		);
+	}
+
+	return (
+		<DndContext
+			sensors={sensors}
+			collisionDetection={closestCenter}
+			modifiers={[restrictToVerticalAxis, restrictToParentElement]}
+			onDragStart={onDragStart}
+			onDragEnd={onDragEnd}
+			onDragCancel={onDragCancel}
+		>
+			<SortableContext items={sortableIds} strategy={verticalListSortingStrategy}>
+				{orderedSections.map((section) =>
+					section.title ? (
+						<SortableSection
+							key={section.id}
+							section={section}
+							sections={sections}
+							onAddPanel={onAddPanel}
+							onMovePanel={onMovePanel}
+							onDeletePanel={onDeletePanel}
+						/>
+					) : (
+						<Section
+							key={section.id}
+							section={section}
+							sections={sections}
+							onAddPanel={onAddPanel}
+							onMovePanel={onMovePanel}
+							onDeletePanel={onDeletePanel}
+						/>
+					),
+				)}
+			</SortableContext>
+			{/* dropAnimation disabled: optimistic reorder already places the section,
+			    so animating the overlay back would cause a visible snap/shake. */}
+			<DragOverlay dropAnimation={null}>
+				{activeSection ? <SectionDragPreview section={activeSection} /> : null}
+			</DragOverlay>
+		</DndContext>
+	);
+}
+
+export default SectionList;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SortableSection.tsx

@@ -0,0 +1,59 @@
+import { useSortable } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+
+import type { DashboardSection } from '../../utils';
+import type { AddPanelArgs } from '../Panel/hooks/useAddPanelToSection';
+import type { DeletePanelArgs } from '../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../Panel/hooks/useMovePanelToSection';
+import Section from './Section/Section';
+
+interface Props {
+	section: DashboardSection;
+	sections: DashboardSection[];
+	onAddPanel: (args: AddPanelArgs) => void;
+	onMovePanel: (args: MovePanelArgs) => void;
+	onDeletePanel: (args: DeletePanelArgs) => void;
+}
+
+function SortableSection({
+	section,
+	sections,
+	onAddPanel,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const {
+		attributes,
+		listeners,
+		setNodeRef,
+		setActivatorNodeRef,
+		transform,
+		transition,
+		isDragging,
+	} = useSortable({ id: section.id });
+
+	// dnd-kit drives the drag transform per-frame, so this must be an inline
+	// style — there is no static-stylesheet equivalent for a live transform.
+	// While dragging, the original is hidden (the DragOverlay renders the moving
+	// preview); keeping it in place preserves the gap and lets siblings animate.
+	const style: React.CSSProperties = {
+		transform: CSS.Transform.toString(transform),
+		transition,
+		opacity: isDragging ? 0 : undefined,
+	};
+
+	return (
+		<div ref={setNodeRef} style={style}>
+			<Section
+				section={section}
+				sections={sections}
+				onAddPanel={onAddPanel}
+				onMovePanel={onMovePanel}
+				onDeletePanel={onDeletePanel}
+				dragHandle={{ attributes, listeners, setActivatorNodeRef }}
+			/>
+		</div>
+	);
+}
+
+export default SortableSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useAddSection.ts

@@ -0,0 +1,59 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import {
+	addSectionOp,
+	newGridLayout,
+	reorderLayoutsOp,
+} from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+
+interface Params {
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+interface Result {
+	addSection: (title: string) => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Appends an empty titled section. When the dashboard has no layouts yet, the
+ * layouts array is created via a `replace` (an `add` to a missing/empty array
+ * pointer is unreliable); otherwise a new Grid is appended.
+ */
+export function useAddSection({ layouts }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const addSection = useCallback(
+		async (title: string): Promise<void> => {
+			const trimmed = title.trim();
+			if (!dashboardId || !trimmed) {
+				return;
+			}
+			const op =
+				!layouts || layouts.length === 0
+					? reorderLayoutsOp([newGridLayout(trimmed)])
+					: addSectionOp(trimmed);
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [op]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[layouts, dashboardId, refetch, showErrorModal],
+	);
+
+	return { addSection, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useDeleteSection.ts

@@ -0,0 +1,51 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { removePanelOp, removeSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	section: DashboardSection;
+}
+
+interface Result {
+	deleteSection: () => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Deletes a section: removes its Grid layout and deletes every panel it
+ * contained from `spec.panels` (orphan cleanup), as one atomic patch.
+ */
+export function useDeleteSection({ section }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const deleteSection = useCallback(async (): Promise<void> => {
+		if (!dashboardId) {
+			return;
+		}
+		const ops: DashboardtypesJSONPatchOperationDTO[] = section.items.map((i) =>
+			removePanelOp(i.id),
+		);
+		ops.push(removeSectionOp(section.layoutIndex));
+		try {
+			setIsSaving(true);
+			await patchDashboardV2({ id: dashboardId }, ops);
+			refetch();
+		} catch (error) {
+			showErrorModal(error as APIError);
+		} finally {
+			setIsSaving(false);
+		}
+	}, [section, dashboardId, refetch, showErrorModal]);
+
+	return { deleteSection, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useFirstSectionMigration.ts

@@ -0,0 +1,64 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { addSectionOp, titleUntitledSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+interface Result {
+	migrate: (newSectionTitle: string) => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Converts a free-flowing dashboard into a sectioned one: every existing
+ * untitled layout that holds panels is titled in place ("Section 1", "Section
+ * 2", …), then the brand-new section the user asked for is appended — all in one
+ * atomic patch. Used once the user confirms the migration prompt.
+ */
+export function useFirstSectionMigration({ sections }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const migrate = useCallback(
+		async (newSectionTitle: string): Promise<void> => {
+			const trimmed = newSectionTitle.trim();
+			if (!dashboardId || !trimmed) {
+				return;
+			}
+
+			const ops: DashboardtypesJSONPatchOperationDTO[] = [];
+			let counter = 1;
+			sections.forEach((s) => {
+				if (!s.title && s.items.length > 0) {
+					ops.push(titleUntitledSectionOp(s.layoutIndex, `Section ${counter}`));
+					counter += 1;
+				}
+			});
+			ops.push(addSectionOp(trimmed));
+
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, ops);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+
+	return { migrate, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/usePersistLayout.ts

@@ -0,0 +1,97 @@
+import { useCallback, useState } from 'react';
+import type { Layout } from 'react-grid-layout';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { replaceSectionItemsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { GridItem } from '../../../utils';
+
+interface Params {
+	layoutIndex: number;
+	items: GridItem[];
+}
+
+interface Result {
+	handleLayoutChange: (rglLayout: Layout[]) => void;
+	isSaving: boolean;
+}
+
+/** Maps an RGL layout back onto the section's grid items, preserving panel refs. */
+function mergeRglLayout(rglLayout: Layout[], items: GridItem[]): GridItem[] {
+	const byId = new Map(items.map((item) => [item.id, item]));
+	return rglLayout
+		.map((entry) => {
+			const existing = byId.get(entry.i);
+			if (!existing) {
+				return null;
+			}
+			return {
+				...existing,
+				x: entry.x,
+				y: entry.y,
+				width: entry.w,
+				height: entry.h,
+			};
+		})
+		.filter((item): item is GridItem => item !== null);
+}
+
+function hasGeometryChanged(next: GridItem[], prev: GridItem[]): boolean {
+	if (next.length !== prev.length) {
+		return true;
+	}
+	const prevById = new Map(prev.map((item) => [item.id, item]));
+	return next.some((item) => {
+		const before = prevById.get(item.id);
+		if (!before) {
+			return true;
+		}
+		return (
+			before.x !== item.x ||
+			before.y !== item.y ||
+			before.width !== item.width ||
+			before.height !== item.height
+		);
+	});
+}
+
+/**
+ * Persists panel geometry within a single section. Call the returned handler
+ * from RGL's `onDragStop`/`onResizeStop` (stop events only — not continuous
+ * `onLayoutChange`) to limit network churn.
+ */
+export function usePersistLayout({ layoutIndex, items }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const handleLayoutChange = useCallback(
+		async (rglLayout: Layout[]): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const nextItems = mergeRglLayout(rglLayout, items);
+			if (!hasGeometryChanged(nextItems, items)) {
+				return;
+			}
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [
+					replaceSectionItemsOp(layoutIndex, nextItems),
+				]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[dashboardId, items, layoutIndex, refetch, showErrorModal],
+	);
+
+	return { handleLayoutChange, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useRenameSection.ts

@@ -0,0 +1,50 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { renameSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+
+interface Params {
+	layoutIndex: number;
+}
+
+interface Result {
+	rename: (title: string) => Promise<boolean>;
+	isSaving: boolean;
+}
+
+/** Renames a section's title via `replace /spec/layouts/<i>/spec/display/title`. */
+export function useRenameSection({ layoutIndex }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const rename = useCallback(
+		async (title: string): Promise<boolean> => {
+			const trimmed = title.trim();
+			if (!dashboardId || !trimmed) {
+				return false;
+			}
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [
+					renameSectionOp(layoutIndex, trimmed),
+				]);
+				refetch();
+				return true;
+			} catch (error) {
+				showErrorModal(error as APIError);
+				return false;
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[dashboardId, layoutIndex, refetch, showErrorModal],
+	);
+
+	return { rename, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useSectionDragReorder.ts

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+	type DragEndEvent,
+	type DragStartEvent,
+	KeyboardSensor,
+	PointerSensor,
+	useSensor,
+	useSensors,
+} from '@dnd-kit/core';
+import { arrayMove, sortableKeyboardCoordinates } from '@dnd-kit/sortable';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { reorderLayoutsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+interface Result {
+	sensors: ReturnType<typeof useSensors>;
+	/** Display order — optimistically reordered on drop so the UI doesn't wait on refetch. */
+	orderedSections: DashboardSection[];
+	/** The section currently being dragged (for the DragOverlay preview), or null. */
+	activeSection: DashboardSection | null;
+	onDragStart: (event: DragStartEvent) => void;
+	onDragEnd: (event: DragEndEvent) => void;
+	onDragCancel: () => void;
+}
+
+/**
+ * Owns section-reorder drag state. Reorders happen optimistically in local
+ * state (keyed by stable section id) and persist via a single
+ * `replace /spec/layouts` patch; the optimistic order is cleared once fresh
+ * server data arrives. Each section maps 1:1 to a Grid layout via `layoutIndex`,
+ * so the new layouts array is rebuilt by mapping the reordered sections back.
+ */
+export function useSectionDragReorder({ sections, layouts }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [activeId, setActiveId] = useState<string | null>(null);
+	const [localOrderIds, setLocalOrderIds] = useState<string[] | null>(null);
+	const { showErrorModal } = useErrorModal();
+
+	const sensors = useSensors(
+		useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+		useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
+	);
+
+	// Server data is the source of truth — drop optimistic order whenever it changes.
+	useEffect(() => {
+		setLocalOrderIds(null);
+	}, [sections]);
+
+	const orderedSections = useMemo<DashboardSection[]>(() => {
+		if (!localOrderIds) {
+			return sections;
+		}
+		const byId = new Map(sections.map((s) => [s.id, s]));
+		const ordered = localOrderIds
+			.map((id) => byId.get(id))
+			.filter((s): s is DashboardSection => s !== undefined);
+		return ordered.length === sections.length ? ordered : sections;
+	}, [sections, localOrderIds]);
+
+	const onDragStart = useCallback((event: DragStartEvent): void => {
+		setActiveId(String(event.active.id));
+	}, []);
+
+	const onDragCancel = useCallback((): void => {
+		setActiveId(null);
+	}, []);
+
+	const onDragEnd = useCallback(
+		async (event: DragEndEvent): Promise<void> => {
+			setActiveId(null);
+			const { active, over } = event;
+			if (!over || active.id === over.id || !dashboardId || !layouts) {
+				return;
+			}
+
+			const oldIndex = orderedSections.findIndex((s) => s.id === active.id);
+			const newIndex = orderedSections.findIndex((s) => s.id === over.id);
+			if (oldIndex < 0 || newIndex < 0) {
+				return;
+			}
+
+			const newOrdered = arrayMove(orderedSections, oldIndex, newIndex);
+			setLocalOrderIds(newOrdered.map((s) => s.id));
+
+			const newLayouts = newOrdered
+				.map((s) => layouts[s.layoutIndex])
+				.filter((l): l is DashboardtypesLayoutDTO => l !== undefined);
+
+			try {
+				await patchDashboardV2({ id: dashboardId }, [reorderLayoutsOp(newLayouts)]);
+				refetch();
+			} catch (error) {
+				setLocalOrderIds(null); // revert optimistic order on failure
+				showErrorModal(error as APIError);
+			}
+		},
+		[orderedSections, layouts, dashboardId, refetch, showErrorModal],
+	);
+
+	const activeSection = useMemo(
+		() => orderedSections.find((s) => s.id === activeId) ?? null,
+		[orderedSections, activeId],
+	);
+
+	return {
+		sensors,
+		orderedSections,
+		activeSection,
+		onDragStart,
+		onDragEnd,
+		onDragCancel,
+	};
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useToggleSectionCollapse.ts

@@ -0,0 +1,36 @@
+import { useCallback } from 'react';
+
+import {
+	selectIsSectionOpen,
+	useDashboardStore,
+} from '../../../store/useDashboardStore';
+
+interface Params {
+	sectionId: string;
+}
+
+interface Result {
+	open: boolean;
+	toggle: () => void;
+}
+
+/**
+ * Owns a section's expand/collapse state. Collapse is a frontend-only, per-user
+ * preference (not in the dashboard spec): it lives in the persisted zustand
+ * store, keyed by dashboardId + section id, and survives reloads. Default open.
+ */
+export function useToggleSectionCollapse({ sectionId }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const open = useDashboardStore(selectIsSectionOpen(dashboardId, sectionId));
+	const toggleSectionCollapse = useDashboardStore(
+		(s) => s.toggleSectionCollapse,
+	);
+
+	const toggle = useCallback((): void => {
+		if (dashboardId) {
+			toggleSectionCollapse(dashboardId, sectionId);
+		}
+	}, [dashboardId, sectionId, toggleSectionCollapse]);
+
+	return { open, toggle };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/index.tsx

@@ -7,8 +7,11 @@ import type {
 	DashboardtypesPanelDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
+import { useDashboardStore } from '../store/useDashboardStore';
 import { layoutsToSections } from '../utils';
+import AddSectionControl from './Section/AddSectionControl/AddSectionControl';
 import Section from './Section/Section/Section';
+import SectionList from './Section/SectionList';
 import styles from './PanelsAndSectionsLayout.module.scss';
 
 import 'react-grid-layout/css/styles.css';
@@ -20,6 +23,8 @@ interface Props {
 }
 
 function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
+
 	const sections = useMemo(
 		() => layoutsToSections(layouts, panels),
 		[layouts, panels],
@@ -28,6 +33,11 @@ function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
 	const isEmpty =
 		sections.length === 0 || sections.every((s) => s.items.length === 0);
 
+	// Sectioned mode = at least one titled layout. Sections then become a
+	// reorderable list; otherwise the dashboard is a single free-flowing grid
+	// with no section chrome or reordering.
+	const isSectioned = useMemo(() => sections.some((s) => !!s.title), [sections]);
+
 	const renderContent = (): ReactNode => {
 		if (isEmpty) {
 			return (
@@ -42,12 +52,27 @@ function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
 			);
 		}
 
+		if (isSectioned) {
+			return <SectionList sections={sections} layouts={layouts} />;
+		}
+
 		return sections.map((section) => (
 			<Section key={section.id} section={section} />
 		));
 	};
 
-	return <div className={styles.body}>{renderContent()}</div>;
+	return (
+		<div className={styles.body}>
+			{renderContent()}
+			{isEditable ? (
+				<AddSectionControl
+					sections={sections}
+					layouts={layouts}
+					isSectioned={isSectioned}
+				/>
+			) : null}
+		</div>
+	);
 }
 
 export default PanelsAndSectionsLayout;

frontend/src/pages/DashboardPageV2/DashboardContainer/index.tsx

@@ -1,10 +1,13 @@
-import { useMemo } from 'react';
+import { useEffect, useMemo } from 'react';
 import { FullScreen, useFullScreenHandle } from 'react-full-screen';
 
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
+import useComponentPermission from 'hooks/useComponentPermission';
+import { useAppContext } from 'providers/App/App';
 
 import DashboardDescription from './DashboardDescription';
 import PanelsAndSectionsLayout from './PanelsAndSectionsLayout';
+import { useDashboardStore } from './store/useDashboardStore';
 import styles from './DashboardContainer.module.scss';
 
 interface Props {
@@ -15,6 +18,17 @@ interface Props {
 function DashboardContainer({ dashboard, refetch }: Props): JSX.Element {
 	const fullScreenHandle = useFullScreenHandle();
 
+	const { user } = useAppContext();
+	const [editDashboard] = useComponentPermission(['edit_dashboard'], user.role);
+	const isEditable = !dashboard.locked && editDashboard;
+
+	// Publish edit context to the store so hooks/components read it from there
+	// instead of receiving dashboardId/isEditable/refetch as props down the tree.
+	const setEditContext = useDashboardStore((s) => s.setEditContext);
+	useEffect(() => {
+		setEditContext({ dashboardId: dashboard.id ?? '', isEditable, refetch });
+	}, [dashboard.id, isEditable, refetch, setEditContext]);
+
 	const { spec } = dashboard;
 	const layouts = useMemo(() => spec?.layouts ?? [], [spec?.layouts]);
 	const panels = useMemo(() => spec?.panels ?? {}, [spec?.panels]);

frontend/src/pages/DashboardPageV2/DashboardContainer/patchOps.ts

@@ -0,0 +1,177 @@
+import type {
+	DashboardGridItemDTO,
+	DashboardtypesJSONPatchOperationDTO,
+	DashboardtypesLayoutDTO,
+	DashboardtypesPanelDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { DashboardtypesJSONPatchOperationDTOOp } from 'api/generated/services/sigNoz.schemas';
+
+import type { GridItem } from './utils';
+
+/**
+ * Pure RFC-6902 JSON-Patch builders for the V2 dashboard spec. These are
+ * intentionally side-effect-free (no React, no network) so they can be unit
+ * tested and reused by the layout hooks. JSON pointers target the postable
+ * shape: `/spec/layouts/...`, `/spec/panels/...` (matches the existing V2
+ * patches in DashboardSettings/General and DashboardDescription).
+ */
+
+const { add, replace, remove } = DashboardtypesJSONPatchOperationDTOOp;
+
+const PANEL_REF_PREFIX = '#/spec/panels/';
+
+export function panelRef(panelId: string): string {
+	return `${PANEL_REF_PREFIX}${panelId}`;
+}
+
+/**
+ * Builds a minimal, backend-valid panel for a given plugin kind. The spec
+ * requires exactly one query whose plugin kind is allowed for the panel;
+ * `signoz/BuilderQuery` is allowed for every panel kind and its contents are not
+ * validated, so an empty builder query is the safe default. The real query is
+ * filled in once the panel editor lands.
+ */
+export function createDefaultPanel(pluginKind: string): DashboardtypesPanelDTO {
+	// The DTO types plugin/query kinds as large generated enum unions; the kind
+	// here is chosen dynamically by the user, so we build the structurally-valid
+	// shape and assert the type.
+	return {
+		kind: 'Panel',
+		spec: {
+			display: { name: 'New panel' },
+			plugin: { kind: pluginKind, spec: {} },
+			queries: [
+				{
+					kind: 'TimeSeriesQuery',
+					spec: { plugin: { kind: 'signoz/BuilderQuery', spec: { name: 'A' } } },
+				},
+			],
+		},
+	} as unknown as DashboardtypesPanelDTO;
+}
+
+/** Converts a UI grid item back into the spec's grid-item DTO shape. */
+export function gridItemToDTO(item: GridItem): DashboardGridItemDTO {
+	return {
+		x: item.x,
+		y: item.y,
+		width: item.width,
+		height: item.height,
+		content: { $ref: panelRef(item.id) },
+	};
+}
+
+/** Replace the entire items array of one section (used on panel move/resize). */
+export function replaceSectionItemsOp(
+	layoutIndex: number,
+	items: GridItem[],
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: replace,
+		path: `/spec/layouts/${layoutIndex}/spec/items`,
+		value: items.map(gridItemToDTO),
+	};
+}
+
+/** Replace the whole layouts array (used on section reorder — avoids move-index ambiguity). */
+export function reorderLayoutsOp(
+	layouts: DashboardtypesLayoutDTO[],
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: replace, path: '/spec/layouts', value: layouts };
+}
+
+/** An empty titled Grid layout (one section). */
+export function newGridLayout(title: string): DashboardtypesLayoutDTO {
+	return {
+		kind: 'Grid' as DashboardtypesLayoutDTO['kind'],
+		spec: { display: { title }, items: [] },
+	};
+}
+
+/** Append a new, empty titled Grid section. */
+export function addSectionOp(
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: add, path: '/spec/layouts/-', value: newGridLayout(title) };
+}
+
+interface AddPanelToSectionArgs {
+	panelId: string;
+	panel: DashboardtypesPanelDTO;
+	layoutIndex: number;
+	item: DashboardGridItemDTO;
+}
+
+/** Add a panel to `spec.panels` and an item ref into a section, as one atomic patch. */
+export function addPanelToSectionOps({
+	panelId,
+	panel,
+	layoutIndex,
+	item,
+}: AddPanelToSectionArgs): DashboardtypesJSONPatchOperationDTO[] {
+	return [
+		{ op: add, path: `/spec/panels/${panelId}`, value: panel },
+		{ op: add, path: `/spec/layouts/${layoutIndex}/spec/items/-`, value: item },
+	];
+}
+
+interface MovePanelArgs {
+	sourceIndex: number;
+	sourceItems: GridItem[];
+	targetIndex: number;
+	targetItems: GridItem[];
+}
+
+/** Move a panel's item ref from one section to another (panel stays in spec.panels). */
+export function movePanelBetweenSectionsOps({
+	sourceIndex,
+	sourceItems,
+	targetIndex,
+	targetItems,
+}: MovePanelArgs): DashboardtypesJSONPatchOperationDTO[] {
+	return [
+		replaceSectionItemsOp(sourceIndex, sourceItems),
+		replaceSectionItemsOp(targetIndex, targetItems),
+	];
+}
+
+/** Rename an existing section's title. */
+export function renameSectionOp(
+	layoutIndex: number,
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: replace,
+		path: `/spec/layouts/${layoutIndex}/spec/display/title`,
+		value: title,
+	};
+}
+
+/**
+ * First-section migration: give an existing untitled (free-flowing) layout a
+ * title, turning it into a section in place while preserving its panels.
+ */
+export function titleUntitledSectionOp(
+	layoutIndex: number,
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: add,
+		path: `/spec/layouts/${layoutIndex}/spec/display`,
+		value: { title },
+	};
+}
+
+/** Remove a section. Panel cleanup (orphaned refs) is handled by the caller. */
+export function removeSectionOp(
+	layoutIndex: number,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: remove, path: `/spec/layouts/${layoutIndex}` };
+}
+
+/** Remove a panel definition from `spec.panels`. */
+export function removePanelOp(
+	panelId: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: remove, path: `/spec/panels/${panelId}` };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/collapseSlice.ts

@@ -0,0 +1,35 @@
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+/**
+ * Section collapse state — frontend-only and persisted to localStorage. Keyed by
+ * dashboardId → section stable id → open. An absent entry means "open" (the
+ * default). This is intentionally NOT server state: collapse is a per-user UI
+ * preference, so it lives here instead of in the dashboard spec.
+ */
+export interface CollapseSlice {
+	collapsed: Record<string, Record<string, boolean>>;
+	toggleSectionCollapse: (dashboardId: string, sectionId: string) => void;
+}
+
+export const createCollapseSlice: StateCreator<
+	DashboardStore,
+	[['zustand/persist', unknown]],
+	[],
+	CollapseSlice
+> = (set, get) => ({
+	collapsed: {},
+	toggleSectionCollapse: (dashboardId, sectionId): void => {
+		const { collapsed } = get();
+		const current = collapsed[dashboardId]?.[sectionId];
+		// Absent → open by default, so the first toggle closes it.
+		const next = current === undefined ? false : !current;
+		set({
+			collapsed: {
+				...collapsed,
+				[dashboardId]: { ...collapsed[dashboardId], [sectionId]: next },
+			},
+		});
+	},
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/editContextSlice.ts

@@ -0,0 +1,38 @@
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+/**
+ * Edit context shared across the V2 dashboard tree — the dashboard id, whether
+ * the user can edit, and the react-query refetch. Set once by DashboardContainer
+ * so hooks/components read it from the store instead of receiving it as props
+ * through every layer. Not persisted.
+ */
+export interface EditContextSlice {
+	dashboardId: string;
+	isEditable: boolean;
+	refetch: () => void;
+	setEditContext: (ctx: {
+		dashboardId: string;
+		isEditable: boolean;
+		refetch: () => void;
+	}) => void;
+}
+
+export const createEditContextSlice: StateCreator<
+	DashboardStore,
+	[['zustand/persist', unknown]],
+	[],
+	EditContextSlice
+> = (set) => ({
+	dashboardId: '',
+	isEditable: false,
+	refetch: (): void => undefined,
+	setEditContext: (ctx): void => {
+		set({
+			dashboardId: ctx.dashboardId,
+			isEditable: ctx.isEditable,
+			refetch: ctx.refetch,
+		});
+	},
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/store/useDashboardStore.ts

@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+import {
+	createEditContextSlice,
+	type EditContextSlice,
+} from './slices/editContextSlice';
+import {
+	createCollapseSlice,
+	type CollapseSlice,
+} from './slices/collapseSlice';
+
+export type DashboardStore = EditContextSlice & CollapseSlice;
+
+/**
+ * V2 dashboard session store. Holds cross-cutting client state only — never the
+ * dashboard spec (that stays in react-query via useGetDashboardV2). Two slices:
+ * - edit-context: dashboardId / isEditable / refetch (set once, not persisted).
+ * - collapse: per-section open state (frontend-only, persisted to localStorage).
+ */
+export const useDashboardStore = create<DashboardStore>()(
+	persist(
+		(...a) => ({
+			...createEditContextSlice(...a),
+			...createCollapseSlice(...a),
+		}),
+		{
+			name: '@signoz/dashboard-v2',
+			// Persist only the collapse map — context (incl. the refetch fn) is transient.
+			partialize: (state) => ({ collapsed: state.collapsed }),
+		},
+	),
+);
+
+/** Selector: is a section open? Absent entry (or no dashboard) → open by default. */
+export const selectIsSectionOpen =
+	(dashboardId: string, sectionId: string) =>
+	(state: DashboardStore): boolean => {
+		if (!dashboardId) {
+			return true;
+		}
+		const value = state.collapsed[dashboardId]?.[sectionId];
+		return value === undefined ? true : value;
+	};

frontend/src/pages/DashboardPageV2/DashboardContainer/utils.ts

@@ -72,7 +72,6 @@ export interface DashboardSection {
 	/** Position of this section's Grid in `spec.layouts`. All JSON-Patch ops target by this. */
 	layoutIndex: number;
 	title: string | undefined;
-	open: boolean;
 	items: GridItem[];
 	repeatVariable: string | undefined;
 }
@@ -127,15 +126,11 @@ export function layoutsToSections(
 				.filter((it): it is GridItem => it !== null);
 
 			const title = spec?.display?.title;
-			// `open` defaults to true when no collapse field is set (the section
-			// is expanded by default).
-			const open = spec?.display?.collapse?.open !== false;
 
 			return {
 				id: getSectionStableId(items, idx),
 				layoutIndex: idx,
 				title,
-				open,
 				items,
 				repeatVariable: spec?.repeatVariable,
 			};

frontend/src/pages/Settings/__tests__/Settings.test.tsx

@@ -10,11 +10,6 @@ jest.mock('components/MarkdownRenderer/MarkdownRenderer', () => ({
 		children,
 }));
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('lib/history', () => ({
 	push: jest.fn(),
 	listen: jest.fn(() => jest.fn()),

frontend/src/pages/SignUp/__tests__/SignUp.test.tsx

@@ -14,11 +14,6 @@ jest.mock('AppRoutes/utils', () => ({
 
 const mockAfterLogin = jest.mocked(afterLogin);
 
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock('lib/history', () => ({
 	__esModule: true,
 	default: {

frontend/src/tests/nuqs-helpers.ts

@@ -0,0 +1,41 @@
+// Helpers for tests that drive components built with `nuqs`.
+//
+// We replace `NuqsAdapter` (which throttles URL writes to `window.history`)
+// with `NuqsTestingAdapter`. The testing adapter applies URL updates
+// synchronously (`rateLimitFactor: 0`) and stores state in memory
+// (`hasMemory: true`) so subsequent reads see the latest value without any
+// `flushNuqsUrl` sleep. Each test gets a fresh queue because
+// `resetUrlUpdateQueueOnMount` defaults to `true`.
+//
+// Reads on `window.location.search` are no longer authoritative since the
+// adapter does not push to the browser history. Use
+// `getCurrentNuqsQueryString()` (or assert on `lastNuqsUrlUpdate`) instead.
+
+import type { OnUrlUpdateFunction } from 'nuqs/adapters/testing';
+
+let lastUrlUpdate: { searchParams: URLSearchParams; queryString: string } = {
+	searchParams: new URLSearchParams(),
+	queryString: '',
+};
+
+export function resetNuqsState(initialQuery = ''): void {
+	lastUrlUpdate = {
+		searchParams: new URLSearchParams(initialQuery),
+		queryString: initialQuery,
+	};
+}
+
+export const onNuqsUrlUpdate: OnUrlUpdateFunction = (event) => {
+	lastUrlUpdate = {
+		searchParams: event.searchParams,
+		queryString: event.queryString,
+	};
+};
+
+export function getCurrentNuqsQueryString(): string {
+	return lastUrlUpdate.queryString;
+}
+
+export function getCurrentNuqsSearchParams(): URLSearchParams {
+	return lastUrlUpdate.searchParams;
+}