fix: add default aggregation count() if none is present in logs/traces

conf/example.yaml

@@ -155,8 +155,8 @@ querier:
   cache_ttl: 168h
   # The interval for recent data that should not be cached.
   flux_interval: 5m
-  # The maximum number of queries a single query range request runs at once.
-  max_concurrent_queries: 8
+  # The maximum number of concurrent queries for missing ranges.
+  max_concurrent_queries: 4
   # When filtering logs by trace_id, clamp the query window to the trace time
   # range with padding to include slightly delayed log exports. Logs only; set
   # to 0 to disable.

docs/api/openapi.yml

@@ -2682,7 +2682,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value
@@ -3649,7 +3648,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value
@@ -3686,7 +3684,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -3395,7 +3395,6 @@ export interface DashboardtypesThresholdWithLabelDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }
@@ -3923,7 +3922,6 @@ export interface DashboardtypesComparisonThresholdDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }
@@ -4212,7 +4210,6 @@ export interface DashboardtypesTableThresholdDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/CheckboxValueRow.tsx

@@ -2,7 +2,6 @@ import { Button } from 'antd';
 import { Checkbox } from '@signozhq/ui/checkbox';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
 
 interface CheckboxValueRowProps {
 	value: string;
@@ -47,11 +46,9 @@ function CheckboxValueRow({
 				{customRendererForValue ? (
 					customRendererForValue(value)
 				) : (
-					<TooltipSimple title={value} side="top" align="center" arrow>
-						<Typography.Text className="value-string" truncate={1}>
-							{String(value)}
-						</Typography.Text>
-					</TooltipSimple>
+					<Typography.Text className="value-string" truncate={1}>
+						{String(value)}
+					</Typography.Text>
 				)}
 				<Button type="text" className="only-btn">
 					{onlyButtonLabel}

frontend/src/constants/localStorage.ts

@@ -31,7 +31,6 @@ export enum LOCALSTORAGE {
 	METRICS_LIST_OPTIONS = 'METRICS_LIST_OPTIONS',
 	SHOW_EXCEPTIONS_QUICK_FILTERS = 'SHOW_EXCEPTIONS_QUICK_FILTERS',
 	QUICK_FILTERS_SETTINGS_ANNOUNCEMENT = 'QUICK_FILTERS_SETTINGS_ANNOUNCEMENT',
-	QUICK_FILTERS_WIDTH_LOGS = 'QUICK_FILTERS_WIDTH_LOGS',
 	FUNNEL_STEPS = 'FUNNEL_STEPS',
 	SPAN_DETAILS_PINNED_ATTRIBUTES = 'SPAN_DETAILS_PINNED_ATTRIBUTES',
 	LAST_USED_CUSTOM_TIME_RANGES = 'LAST_USED_CUSTOM_TIME_RANGES',

frontend/src/container/DashboardContainer/DashboardDescription/Description.styles.scss

@@ -149,18 +149,6 @@
 		line-height: 22px; /* 157.143% */
 		letter-spacing: -0.07px;
 		padding: 20px 16px 0px 16px;
-		/* Preserve author-entered line breaks in the description. */
-		white-space: pre-wrap;
-		overflow-wrap: anywhere;
-
-		a {
-			color: var(--accent-primary);
-			text-decoration: underline;
-
-			&:hover {
-				text-decoration: none;
-			}
-		}
 	}
 
 	.dashboard-variables {

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

@@ -43,7 +43,6 @@ import { sortLayout } from 'providers/Dashboard/util';
 import { DashboardData } from 'types/api/dashboard/getAll';
 import { Props } from 'types/api/dashboard/update';
 import { ROLES, USER_ROLES } from 'types/roles';
-import { linkifyText } from 'utils/linkifyText';
 import { ComponentTypes } from 'utils/permission';
 import { v4 as uuid } from 'uuid';
 
@@ -516,9 +515,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 				</div>
 			)}
 			{!isEmpty(description) && (
-				<section className="dashboard-description-section">
-					{linkifyText(description ?? '')}
-				</section>
+				<section className="dashboard-description-section">{description}</section>
 			)}
 
 			{!isEmpty(dashboardVariables) && (

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/DashboardInfo/DashboardInfo.module.scss

@@ -32,22 +32,6 @@
 	cursor: help;
 }
 
-.descriptionTooltip {
-	display: block;
-	overflow-wrap: anywhere;
-	/* Preserve author-entered line breaks in the description. */
-	white-space: pre-wrap;
-
-	a {
-		color: var(--accent-primary);
-		text-decoration: underline;
-
-		&:hover {
-			text-decoration: none;
-		}
-	}
-}
-
 .publicLink {
 	display: inline-flex;
 	align-items: center;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/DashboardInfo/DashboardInfo.tsx

@@ -14,7 +14,6 @@ import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
 import { isEmpty } from 'lodash-es';
-import { linkifyText } from 'utils/linkifyText';
 import { openInNewTab } from 'utils/navigation';
 
 import styles from './DashboardInfo.module.scss';
@@ -144,14 +143,7 @@ function DashboardInfo({
 			)}
 
 			{hasDescription && (
-				<TooltipSimple
-					side="bottom"
-					title={
-						<span className={styles.descriptionTooltip}>
-							{linkifyText(description)}
-						</span>
-					}
-				>
+				<TooltipSimple title={description} disableHoverableContent>
 					<SolidInfoCircle
 						className={styles.descriptionIcon}
 						size={14}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/JsonEditorDrawer.module.scss

@@ -48,13 +48,6 @@
 	gap: 12px;
 }
 
-.footerStatus {
-	display: flex;
-	min-width: 0;
-	flex-direction: column;
-	gap: 2px;
-}
-
 .validation {
 	min-width: 0;
 	overflow: hidden;
@@ -64,32 +57,6 @@
 	white-space: nowrap;
 }
 
-.danglingWarning {
-	display: flex;
-	min-width: 0;
-	align-items: center;
-	gap: 4px;
-	color: var(--bg-amber-400);
-	font-size: 12px;
-}
-
-.warningIcon {
-	flex: none;
-}
-
-.warningText {
-	overflow: hidden;
-	color: var(--bg-amber-400);
-	font-size: 12px;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-
-// Above the JSON drawer (antd Drawer sits at ~1100) so the id list is visible.
-.warningTooltip {
-	z-index: 1101;
-}
-
 .validationValid {
 	color: var(--bg-forest-400);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/JsonEditorDrawer.tsx

@@ -1,8 +1,6 @@
 import { KeyboardEvent, useCallback } from 'react';
 import MEditor from '@monaco-editor/react';
-import { TriangleAlert } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
 import { Drawer } from 'antd';
@@ -28,18 +26,8 @@ function JsonEditorDrawer({
 }: JsonEditorDrawerProps): JSX.Element {
 	const [, copyToClipboard] = useCopyToClipboard();
 
-	const {
-		draft,
-		setDraft,
-		validity,
-		isDirty,
-		isSaving,
-		danglingPanelIds,
-		missingPanelRefs,
-		format,
-		reset,
-		apply,
-	} = useJsonEditor({ dashboard, isOpen, onApplied: onClose });
+	const { draft, setDraft, validity, isDirty, isSaving, format, reset, apply } =
+		useJsonEditor({ dashboard, isOpen, onApplied: onClose });
 
 	const onCopy = useCallback((): void => {
 		copyToClipboard(draft);
@@ -60,7 +48,6 @@ function JsonEditorDrawer({
 
 	const onKeyDown = useCallback(
 		(event: KeyboardEvent<HTMLDivElement>): void => {
-			event.stopPropagation();
 			if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
 				event.preventDefault();
 				void apply();
@@ -73,19 +60,6 @@ function JsonEditorDrawer({
 	const validationText = validity.valid
 		? `Valid JSON · ${validity.lineCount} lines`
 		: `Line ${validity.errorLine ?? '?'} · ${validity.message ?? 'Invalid JSON'}`;
-	const plural = (n: number): string => (n === 1 ? '' : 's');
-	const danglingWarning =
-		danglingPanelIds.length > 0
-			? `${danglingPanelIds.length} panel${plural(
-					danglingPanelIds.length,
-				)} not present in layout — they won't be shown after saving.`
-			: null;
-	const missingRefWarning =
-		missingPanelRefs.length > 0
-			? `${missingPanelRefs.length} layout item${plural(
-					missingPanelRefs.length,
-				)} ${missingPanelRefs.length === 1 ? 'references' : 'reference'} a panel that no longer exists.`
-			: null;
 
 	return (
 		<Drawer
@@ -97,49 +71,15 @@ function JsonEditorDrawer({
 			rootClassName={styles.root}
 			footer={
 				<div className={styles.footer}>
-					<div className={styles.footerStatus}>
-						<Typography.Text
-							className={cx(styles.validation, {
-								[styles.validationValid]: validity.valid,
-								[styles.validationInvalid]: !validity.valid,
-							})}
-							data-testid="json-editor-validation"
-						>
-							{validationText}
-						</Typography.Text>
-						{danglingWarning && (
-							<TooltipSimple
-								title={danglingPanelIds.join(', ')}
-								tooltipContentProps={{ className: styles.warningTooltip }}
-							>
-								<span
-									className={styles.danglingWarning}
-									data-testid="json-editor-dangling-warning"
-								>
-									<TriangleAlert size={12} className={styles.warningIcon} />
-									<Typography.Text className={styles.warningText}>
-										{danglingWarning}
-									</Typography.Text>
-								</span>
-							</TooltipSimple>
-						)}
-						{missingRefWarning && (
-							<TooltipSimple
-								title={missingPanelRefs.join(', ')}
-								tooltipContentProps={{ className: styles.warningTooltip }}
-							>
-								<span
-									className={styles.danglingWarning}
-									data-testid="json-editor-missing-ref-warning"
-								>
-									<TriangleAlert size={12} className={styles.warningIcon} />
-									<Typography.Text className={styles.warningText}>
-										{missingRefWarning}
-									</Typography.Text>
-								</span>
-							</TooltipSimple>
-						)}
-					</div>
+					<Typography.Text
+						className={cx(styles.validation, {
+							[styles.validationValid]: validity.valid,
+							[styles.validationInvalid]: !validity.valid,
+						})}
+						data-testid="json-editor-validation"
+					>
+						{validationText}
+					</Typography.Text>
 					<div className={styles.footerActions}>
 						<Button
 							variant="outlined"

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/__tests__/JsonEditorDrawer.test.tsx

@@ -1,5 +1,4 @@
 import { fireEvent, render, screen } from '@testing-library/react';
-import { TooltipProvider } from '@signozhq/ui/tooltip';
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 
 import JsonEditorDrawer from '../JsonEditorDrawer';
@@ -49,13 +48,11 @@ function hookValue(
 		validity: { valid: true, lineCount: 3 },
 		isDirty: true,
 		isSaving: false,
-		danglingPanelIds: [],
-		missingPanelRefs: [],
 		format: jest.fn(),
 		reset: jest.fn(),
 		apply: jest.fn().mockResolvedValue(undefined),
 		...overrides,
-	} as ReturnType<typeof useJsonEditor>;
+	};
 }
 
 describe('JsonEditorDrawer', () => {
@@ -84,42 +81,6 @@ describe('JsonEditorDrawer', () => {
 		);
 	});
 
-	it('warns about dangling panels, and hides the warning when there are none', () => {
-		mockUseJsonEditor.mockReturnValue(
-			hookValue({ danglingPanelIds: ['p1', 'p2'] }),
-		);
-		const { rerender } = render(
-			<TooltipProvider>
-				<JsonEditorDrawer dashboard={dashboard} isOpen onClose={jest.fn()} />
-			</TooltipProvider>,
-		);
-		expect(screen.getByTestId('json-editor-dangling-warning')).toHaveTextContent(
-			'2 panels not present in layout',
-		);
-
-		mockUseJsonEditor.mockReturnValue(hookValue({ danglingPanelIds: [] }));
-		rerender(
-			<TooltipProvider>
-				<JsonEditorDrawer dashboard={dashboard} isOpen onClose={jest.fn()} />
-			</TooltipProvider>,
-		);
-		expect(
-			screen.queryByTestId('json-editor-dangling-warning'),
-		).not.toBeInTheDocument();
-	});
-
-	it('warns about layout refs to missing panels', () => {
-		mockUseJsonEditor.mockReturnValue(hookValue({ missingPanelRefs: ['ghost'] }));
-		render(
-			<TooltipProvider>
-				<JsonEditorDrawer dashboard={dashboard} isOpen onClose={jest.fn()} />
-			</TooltipProvider>,
-		);
-		expect(
-			screen.getByTestId('json-editor-missing-ref-warning'),
-		).toHaveTextContent('1 layout item references a panel that no longer exists');
-	});
-
 	it('shows the error line and message when invalid', () => {
 		mockUseJsonEditor.mockReturnValue(
 			hookValue({

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/__tests__/danglingPanels.test.ts

@@ -1,69 +0,0 @@
-import type { DashboardtypesDashboardSpecDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { findPanelLayoutIssues } from '../danglingPanels';
-
-const grid = (refs: string[]): unknown => ({
-	kind: 'Grid',
-	spec: { items: refs.map((r) => ({ content: { $ref: r } })) },
-});
-
-// Cast a loose fixture to the spec type — the helper is defensive against the
-// untrusted, hand-edited JSON it runs on.
-const spec = (value: unknown): DashboardtypesDashboardSpecDTO =>
-	value as DashboardtypesDashboardSpecDTO;
-
-describe('findPanelLayoutIssues', () => {
-	it('flags nothing when panels and layouts agree', () => {
-		expect(
-			findPanelLayoutIssues(
-				spec({
-					panels: { a: {}, b: {} },
-					layouts: [grid(['#/spec/panels/a', '#/spec/panels/b'])],
-				}),
-			),
-		).toStrictEqual({ danglingPanelIds: [], missingPanelRefs: [] });
-	});
-
-	it('lists panels placed in no layout as dangling', () => {
-		const result = findPanelLayoutIssues(
-			spec({
-				panels: { a: {}, b: {}, c: {} },
-				layouts: [grid(['#/spec/panels/a'])],
-			}),
-		);
-		expect(result.danglingPanelIds.sort()).toStrictEqual(['b', 'c']);
-		expect(result.missingPanelRefs).toStrictEqual([]);
-	});
-
-	it('treats a removed/empty layout as orphaning every panel', () => {
-		expect(
-			findPanelLayoutIssues(
-				spec({ panels: { a: {}, b: {} }, layouts: [] }),
-			).danglingPanelIds.sort(),
-		).toStrictEqual(['a', 'b']);
-	});
-
-	it('lists layout refs to a panel that no longer exists as missing', () => {
-		const result = findPanelLayoutIssues(
-			spec({
-				panels: { a: {} },
-				layouts: [grid(['#/spec/panels/a', '#/spec/panels/ghost'])],
-			}),
-		);
-		expect(result.danglingPanelIds).toStrictEqual([]);
-		expect(result.missingPanelRefs).toStrictEqual(['ghost']);
-	});
-
-	it('handles empty / malformed specs', () => {
-		expect(
-			findPanelLayoutIssues(spec({ panels: {}, layouts: [] })),
-		).toStrictEqual({
-			danglingPanelIds: [],
-			missingPanelRefs: [],
-		});
-		expect(findPanelLayoutIssues(undefined)).toStrictEqual({
-			danglingPanelIds: [],
-			missingPanelRefs: [],
-		});
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/__tests__/useJsonEditor.test.tsx

@@ -203,47 +203,4 @@ describe('useJsonEditor', () => {
 		rerender({ isOpen: true });
 		expect(result.current.draft).toBe(serialized);
 	});
-
-	it('reports panels not placed in any layout as dangling', () => {
-		const withDangling = {
-			...dashboard,
-			spec: { ...dashboard.spec, panels: { p1: {} }, layouts: [] },
-		} as unknown as DashboardtypesGettableDashboardV2DTO;
-		const { result } = renderHook(() =>
-			useJsonEditor({
-				dashboard: withDangling,
-				isOpen: true,
-				onApplied: jest.fn(),
-			}),
-		);
-
-		expect(result.current.danglingPanelIds).toStrictEqual(['p1']);
-		expect(result.current.missingPanelRefs).toStrictEqual([]);
-	});
-
-	it('reports layout refs to panels that no longer exist as missing', () => {
-		const withMissing = {
-			...dashboard,
-			spec: {
-				...dashboard.spec,
-				panels: {},
-				layouts: [
-					{
-						kind: 'Grid',
-						spec: { items: [{ content: { $ref: '#/spec/panels/ghost' } }] },
-					},
-				],
-			},
-		} as unknown as DashboardtypesGettableDashboardV2DTO;
-		const { result } = renderHook(() =>
-			useJsonEditor({
-				dashboard: withMissing,
-				isOpen: true,
-				onApplied: jest.fn(),
-			}),
-		);
-
-		expect(result.current.missingPanelRefs).toStrictEqual(['ghost']);
-		expect(result.current.danglingPanelIds).toStrictEqual([]);
-	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/danglingPanels.ts

@@ -1,47 +0,0 @@
-import type {
-	DashboardtypesDashboardSpecDTO,
-	DashboardtypesLayoutDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-import { extractPanelIdFromRef } from '../../utils';
-
-export interface PanelLayoutIssues {
-	// Panels defined in `spec.panels` that no layout places — they render nowhere.
-	danglingPanelIds: string[];
-	// Panel ids a layout item references that no longer exist in `spec.panels`.
-	missingPanelRefs: string[];
-}
-
-const referencedPanelIds = (
-	layouts: DashboardtypesLayoutDTO[],
-): Set<string> => {
-	const referenced = new Set<string>();
-	layouts.forEach((layout) => {
-		if (layout?.kind !== 'Grid') {
-			return;
-		}
-		(layout.spec?.items ?? []).forEach((item) => {
-			const id = extractPanelIdFromRef(item?.content?.$ref);
-			if (id) {
-				referenced.add(id);
-			}
-		});
-	});
-	return referenced;
-};
-
-// The two ways a hand-edited spec can desync panels and layouts: a panel with no
-// layout slot (renders nowhere), or a layout slot pointing at a panel that was
-// removed (broken reference). Guarded for untrusted, user-edited JSON.
-export function findPanelLayoutIssues(
-	spec: DashboardtypesDashboardSpecDTO | undefined,
-): PanelLayoutIssues {
-	const panels = spec?.panels ?? {};
-	const panelIds = Object.keys(panels);
-	const referenced = referencedPanelIds(spec?.layouts ?? []);
-
-	return {
-		danglingPanelIds: panelIds.filter((id) => !referenced.has(id)),
-		missingPanelRefs: [...referenced].filter((id) => !(id in panels)),
-	};
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/JsonEditorDrawer/useJsonEditor.ts

@@ -1,15 +1,11 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { toast } from '@signozhq/ui/sonner';
 import { updateDashboardV2 } from 'api/generated/services/dashboard';
-import type {
-	DashboardtypesDashboardSpecDTO,
-	DashboardtypesGettableDashboardV2DTO,
-} from 'api/generated/services/sigNoz.schemas';
+import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
-import { toAPIError } from 'utils/errorUtils';
+import APIError from 'types/api/error';
 
 import { dashboardToUpdatable } from './dashboardToUpdatable';
-import { findPanelLayoutIssues } from './danglingPanels';
 import { useDashboardStore } from '../../store/useDashboardStore';
 
 export interface JsonValidity {
@@ -32,10 +28,6 @@ interface Result {
 	validity: JsonValidity;
 	isDirty: boolean;
 	isSaving: boolean;
-	// Panel ids in the draft's `spec.panels` referenced by no layout — orphaned.
-	danglingPanelIds: string[];
-	// Panel ids a layout references that are missing from the draft's `spec.panels`.
-	missingPanelRefs: string[];
 	format: () => void;
 	reset: () => void;
 	apply: () => Promise<void>;
@@ -117,23 +109,6 @@ export function useJsonEditor({
 
 	const isDirty = draft !== appliedText;
 
-	const { danglingPanelIds, missingPanelRefs } = useMemo<{
-		danglingPanelIds: string[];
-		missingPanelRefs: string[];
-	}>(() => {
-		if (!validity.valid) {
-			return { danglingPanelIds: [], missingPanelRefs: [] };
-		}
-		try {
-			const parsed = JSON.parse(draft) as {
-				spec?: DashboardtypesDashboardSpecDTO;
-			};
-			return findPanelLayoutIssues(parsed.spec);
-		} catch {
-			return { danglingPanelIds: [], missingPanelRefs: [] };
-		}
-	}, [draft, validity.valid]);
-
 	const format = useCallback((): void => {
 		try {
 			setDraft(JSON.stringify(JSON.parse(draft), null, 2));
@@ -163,7 +138,7 @@ export function useJsonEditor({
 			refetch();
 			onApplied();
 		} catch (error) {
-			showErrorModal(toAPIError(error as Parameters<typeof toAPIError>[0]));
+			showErrorModal(error as APIError);
 		} finally {
 			setIsSaving(false);
 		}
@@ -184,8 +159,6 @@ export function useJsonEditor({
 		validity,
 		isDirty,
 		isSaving,
-		danglingPanelIds,
-		missingPanelRefs,
 		format,
 		reset,
 		apply,

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

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
 import type {
 	DashboardtypesGettableDashboardV2DTO,
 	DashboardtypesJSONPatchOperationDTO,
@@ -55,32 +54,20 @@ function Overview({ dashboard }: OverviewProps): JSX.Element {
 
 	const buildPatch = useCallback((): DashboardtypesJSONPatchOperationDTO[] => {
 		const ops: DashboardtypesJSONPatchOperationDTO[] = [];
-		const op = (
-			operation: DashboardtypesJSONPatchOperationDTO['op'],
-			path: string,
-			value: unknown,
-		): DashboardtypesJSONPatchOperationDTO => ({ op: operation, path, value });
 		const replace = (
 			path: string,
 			value: unknown,
-		): DashboardtypesJSONPatchOperationDTO =>
-			op(DashboardtypesPatchOpDTO.replace, path, value);
+		): DashboardtypesJSONPatchOperationDTO => ({
+			op: 'replace' as DashboardtypesJSONPatchOperationDTO['op'],
+			path,
+			value,
+		});
 
 		if (updatedTitle !== title && updatedTitle !== '') {
 			ops.push(replace('/spec/display/name', updatedTitle));
 		}
 		if (updatedDescription !== description) {
-			// `replace` fails when the description doesn't exist yet, so add it when
-			// the current one is empty (`add` creates or replaces the member).
-			ops.push(
-				op(
-					description
-						? DashboardtypesPatchOpDTO.replace
-						: DashboardtypesPatchOpDTO.add,
-					'/spec/display/description',
-					updatedDescription,
-				),
-			);
+			ops.push(replace('/spec/display/description', updatedDescription));
 		}
 		if (updatedImage !== image) {
 			ops.push(replace('/image', updatedImage));

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/useVariableForm.ts

@@ -46,12 +46,8 @@ export interface UseVariableForm {
 	handleSave: () => void;
 }
 
-// `defaultValue` is a string | string[] on the wire; the editor uses a single
-// string, so take the first when it's an array.
-const readDefaultValue = (model: VariableFormModel): string => {
-	const dv = model.defaultValue;
-	return Array.isArray(dv) ? (dv[0] ?? '') : (dv ?? '');
-};
+const readDefaultValue = (model: VariableFormModel): string =>
+	((model.defaultValue as { value?: string })?.value ?? '') as string;
 
 /** Form state, derivations and handlers for the variable editor. */
 export function useVariableForm({

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/VariableSelector.tsx

@@ -18,22 +18,22 @@ interface VariableSelectorProps {
 	variable: VariableFormModel;
 	/** All variables (Dynamic uses them to scope options by sibling selections). */
 	variables: VariableFormModel[];
+	/** Names this variable depends on (for Query gating). */
+	parents: string[];
 	/** All current selections (Query passes them as the request payload). */
 	selections: VariableSelectionMap;
 	selection: VariableSelection;
 	onChange: (selection: VariableSelection) => void;
-	/** Batched fill applied when options resolve (Query/Dynamic auto-selection). */
-	onAutoSelect: (selection: VariableSelection) => void;
 }
 
 /** One labelled variable control; dispatches on the variable type. */
 function VariableSelector({
 	variable,
 	variables,
+	parents,
 	selections,
 	selection,
 	onChange,
-	onAutoSelect,
 }: VariableSelectorProps): JSX.Element {
 	const customOptions = useMemo(
 		() =>
@@ -61,10 +61,10 @@ function VariableSelector({
 				return (
 					<QuerySelector
 						variable={variable}
+						parents={parents}
 						selections={selections}
 						selection={selection}
 						onChange={onChange}
-						onAutoSelect={onAutoSelect}
 					/>
 				);
 			case 'DYNAMIC':
@@ -75,7 +75,6 @@ function VariableSelector({
 						selections={selections}
 						selection={selection}
 						onChange={onChange}
-						onAutoSelect={onAutoSelect}
 					/>
 				);
 			case 'CUSTOM':

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/VariablesBar.module.scss

@@ -112,13 +112,3 @@
 		box-shadow: none !important;
 	}
 }
-
-.overflowTooltip {
-	display: flex;
-	flex-direction: column;
-	gap: 2px;
-}
-
-.overflowName {
-	font-weight: var(--font-weight-medium);
-}

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

@@ -1,33 +1,14 @@
 import { useState } from 'react';
 import { ChevronLeft } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
 import cx from 'classnames';
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 import { useInlineOverflowCount } from 'hooks/useInlineOverflowCount';
 
-import type { VariableSelection } from './selectionTypes';
 import { useVariableSelection } from './useVariableSelection';
 import VariableSelector from './VariableSelector';
 import styles from './VariablesBar.module.scss';
 
-// Short display of a variable's current selection, for the collapsed +N tooltip.
-function formatSelection(selection: VariableSelection | undefined): string {
-	if (!selection) {
-		return '—';
-	}
-	if (selection.allSelected) {
-		return 'ALL';
-	}
-	const { value } = selection;
-	if (Array.isArray(value)) {
-		return value.length > 0 ? value.join(', ') : '—';
-	}
-	return value === '' || value === null || value === undefined
-		? '—'
-		: String(value);
-}
-
 interface VariablesBarProps {
 	dashboard: DashboardtypesGettableDashboardV2DTO;
 }
@@ -42,7 +23,7 @@ interface VariablesBarProps {
  * either way so auto-selection and option fetching keep driving the panels.
  */
 function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
-	const { variables, selection, setSelection, autoSelect } =
+	const { variables, dependencyData, selection, setSelection } =
 		useVariableSelection(dashboard);
 	const [expanded, setExpanded] = useState(false);
 	const { containerRef, visibleCount, overflowCount } = useInlineOverflowCount({
@@ -57,22 +38,6 @@ function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
 	}
 
 	const hasOverflow = overflowCount > 0;
-	const hiddenVariables =
-		!expanded && hasOverflow ? variables.slice(visibleCount) : [];
-
-	const moreButton = (
-		<Button
-			variant="outlined"
-			color="secondary"
-			size="md"
-			prefix={expanded ? <ChevronLeft size={14} /> : undefined}
-			aria-expanded={expanded}
-			testId="dashboard-variables-more"
-			onClick={(): void => setExpanded((prev) => !prev)}
-		>
-			{expanded ? 'Less' : `+${overflowCount}`}
-		</Button>
-	);
 
 	return (
 		<div className={styles.bar} data-testid="dashboard-variables-bar">
@@ -92,6 +57,7 @@ function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
 						<VariableSelector
 							variable={variable}
 							variables={variables}
+							parents={dependencyData.parentGraph[variable.name] ?? []}
 							selections={selection}
 							selection={
 								selection[variable.name] ?? {
@@ -100,32 +66,23 @@ function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
 								}
 							}
 							onChange={(next): void => setSelection(variable.name, next)}
-							onAutoSelect={(next): void => autoSelect(variable.name, next)}
 						/>
 					</div>
 				))}
 
 				{hasOverflow && (
 					<span className={styles.moreButton}>
-						{expanded ? (
-							moreButton
-						) : (
-							<TooltipSimple
-								side="top"
-								title={
-									<div className={styles.overflowTooltip}>
-										{hiddenVariables.map((variable) => (
-											<div key={variable.name}>
-												<span className={styles.overflowName}>{variable.name}</span>:{' '}
-												{formatSelection(selection[variable.name])}
-											</div>
-										))}
-									</div>
-								}
-							>
-								{moreButton}
-							</TooltipSimple>
-						)}
+						<Button
+							variant="outlined"
+							color="secondary"
+							size="md"
+							prefix={expanded ? <ChevronLeft size={14} /> : undefined}
+							aria-expanded={expanded}
+							testId="dashboard-variables-more"
+							onClick={(): void => setExpanded((prev) => !prev)}
+						>
+							{expanded ? 'Less' : `+${overflowCount}`}
+						</Button>
 					</span>
 				)}
 			</div>

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/selectors/DynamicSelector.tsx

@@ -1,8 +1,7 @@
 import { useMemo } from 'react';
-import { useQuery } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
-import { getFieldValues } from 'api/dynamicVariables/getFieldValues';
+import { useGetFieldValues } from 'hooks/dynamicVariables/useGetFieldValues';
 import type { AppState } from 'store/reducers';
 import type { GlobalReducer } from 'types/reducer/globalTime';
 
@@ -11,14 +10,12 @@ import {
 	sortValuesByOrder,
 } from '../../DashboardSettings/Variables/variableFormModel';
 import type { VariableFormModel } from '../../DashboardSettings/Variables/variableFormModel';
-import { useDashboardStore } from '../../store/useDashboardStore';
 import { buildExistingDynamicVariableQuery } from '../dynamicFilter';
 import type {
 	VariableSelection,
 	VariableSelectionMap,
 } from '../selectionTypes';
 import { useAutoSelect } from '../useAutoSelect';
-import { useVariableFetchState } from '../useVariableFetchState';
 import ValueSelector from './ValueSelector';
 
 interface DynamicSelectorProps {
@@ -28,16 +25,12 @@ interface DynamicSelectorProps {
 	selections: VariableSelectionMap;
 	selection: VariableSelection;
 	onChange: (selection: VariableSelection) => void;
-	/** Batched auto-selection fill applied when options resolve. */
-	onAutoSelect: (selection: VariableSelection) => void;
 }
 
 /**
  * Dynamic-variable options sourced from live telemetry field values for the
  * chosen signal + attribute, scoped by the other dynamic variables' selections
- * (so e.g. `pod` narrows to the chosen `namespace`). WHEN to fetch is owned by
- * the runtime fetch engine: dynamics fetch together once the query variables have
- * values, and refetch (via a `cycleId` bump) whenever any variable value changes.
+ * (so e.g. `pod` narrows to the chosen `namespace`).
  */
 function DynamicSelector({
 	variable,
@@ -45,7 +38,6 @@ function DynamicSelector({
 	selections,
 	selection,
 	onChange,
-	onAutoSelect,
 }: DynamicSelectorProps): JSX.Element {
 	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
@@ -56,51 +48,14 @@ function DynamicSelector({
 		[variables, selections, variable.name],
 	);
 
-	const {
-		variableFetchCycleId,
-		isVariableFetching,
-		isVariableSettled,
-		isVariableWaiting,
-		hasVariableFetchedOnce,
-	} = useVariableFetchState(variable.name);
-	const onVariableFetchComplete = useDashboardStore(
-		(s) => s.onVariableFetchComplete,
-	);
-	const onVariableFetchFailure = useDashboardStore(
-		(s) => s.onVariableFetchFailure,
-	);
-
-	const { data, isFetching } = useQuery(
-		[
-			'dashboard-variable-dynamic',
-			variable.name,
-			variable.dynamicSignal,
-			variable.dynamicAttribute,
-			existingQuery,
-			minTime,
-			maxTime,
-			variableFetchCycleId,
-		],
-		() =>
-			getFieldValues(
-				signalForApi(variable.dynamicSignal),
-				variable.dynamicAttribute,
-				undefined,
-				minTime,
-				maxTime,
-				existingQuery || undefined,
-			),
-		{
-			enabled:
-				!!variable.dynamicAttribute &&
-				(isVariableFetching || (isVariableSettled && hasVariableFetchedOnce)),
-			refetchOnWindowFocus: false,
-			onSettled: (_, error) =>
-				error
-					? onVariableFetchFailure(variable.name)
-					: onVariableFetchComplete(variable.name),
-		},
-	);
+	const { data, isFetching } = useGetFieldValues({
+		signal: signalForApi(variable.dynamicSignal),
+		name: variable.dynamicAttribute,
+		startUnixMilli: minTime,
+		endUnixMilli: maxTime,
+		existingQuery: existingQuery || undefined,
+		enabled: !!variable.dynamicAttribute,
+	});
 
 	const options = useMemo(() => {
 		const payload = data?.data;
@@ -109,14 +64,14 @@ function DynamicSelector({
 		return sortValuesByOrder(values, variable.sort).map(String);
 	}, [data, variable.sort]);
 
-	useAutoSelect(variable, options, selection, onAutoSelect);
+	useAutoSelect(variable, options, selection, onChange);
 
 	return (
 		<ValueSelector
 			options={options}
 			multiSelect={variable.multiSelect}
 			showAllOption={variable.showAllOption}
-			loading={isFetching || isVariableWaiting}
+			loading={isFetching}
 			selection={selection}
 			onChange={onChange}
 			testId={`variable-select-${variable.name}`}

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/selectors/QuerySelector.tsx

@@ -8,82 +8,58 @@ import type { GlobalReducer } from 'types/reducer/globalTime';
 
 import { sortValuesByOrder } from '../../DashboardSettings/Variables/variableFormModel';
 import type { VariableFormModel } from '../../DashboardSettings/Variables/variableFormModel';
-import { useDashboardStore } from '../../store/useDashboardStore';
 import type {
 	VariableSelection,
 	VariableSelectionMap,
 } from '../selectionTypes';
-import { selectionToPayload } from '../selectionUtils';
+import { isResolved, selectionToPayload } from '../selectionUtils';
 import { useAutoSelect } from '../useAutoSelect';
-import { useVariableFetchState } from '../useVariableFetchState';
 import ValueSelector from './ValueSelector';
 
 interface QuerySelectorProps {
 	variable: VariableFormModel;
+	/** Names this variable's query references; it waits until they're resolved. */
+	parents: string[];
 	/** All current selections, fed to the query as `{ name: value }`. */
 	selections: VariableSelectionMap;
 	selection: VariableSelection;
 	onChange: (selection: VariableSelection) => void;
-	/** Batched auto-selection fill applied when options resolve. */
-	onAutoSelect: (selection: VariableSelection) => void;
 }
 
 /**
- * Query-driven options. WHEN to fetch is owned by the runtime fetch engine
- * (`variableFetchSlice`): the query is `enabled` while this variable is fetching
- * (or settled-after-a-first-fetch, so a cycle bump re-runs it), and the engine's
- * per-variable `cycleId` keys the request — so a parent's value change refetches
- * only the dependent variables, in dependency order. The current selections feed
- * the request payload but are deliberately NOT in the key (V1 parity).
+ * Query-driven options. Dependency orchestration is declarative: the query is
+ * `enabled` only once every parent is resolved, and the parent values are in the
+ * query key — so it refetches automatically when a parent changes (and a cyclic
+ * dependency is simply never enabled).
  */
 function QuerySelector({
 	variable,
+	parents,
 	selections,
 	selection,
 	onChange,
-	onAutoSelect,
 }: QuerySelectorProps): JSX.Element {
 	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
 	const payload = useMemo(() => selectionToPayload(selections), [selections]);
-
-	const {
-		variableFetchCycleId,
-		isVariableFetching,
-		isVariableSettled,
-		isVariableWaiting,
-		hasVariableFetchedOnce,
-	} = useVariableFetchState(variable.name);
-	const onVariableFetchComplete = useDashboardStore(
-		(s) => s.onVariableFetchComplete,
-	);
-	const onVariableFetchFailure = useDashboardStore(
-		(s) => s.onVariableFetchFailure,
-	);
+	const enabled = parents.every((parent) => isResolved(selections[parent]));
 
 	const { data, isFetching } = useQuery(
 		[
 			'dashboard-variable',
 			variable.name,
 			variable.queryValue,
+			payload,
 			minTime,
 			maxTime,
-			variableFetchCycleId,
 		],
 		() =>
 			dashboardVariablesQuery({
 				query: variable.queryValue,
 				variables: payload,
 			}),
-		{
-			enabled: isVariableFetching || (isVariableSettled && hasVariableFetchedOnce),
-			refetchOnWindowFocus: false,
-			onSettled: (_, error) =>
-				error
-					? onVariableFetchFailure(variable.name)
-					: onVariableFetchComplete(variable.name),
-		},
+		{ enabled, refetchOnWindowFocus: false },
 	);
 
 	const options = useMemo(() => {
@@ -96,14 +72,14 @@ function QuerySelector({
 		).map(String);
 	}, [data, variable.sort]);
 
-	useAutoSelect(variable, options, selection, onAutoSelect);
+	useAutoSelect(variable, options, selection, onChange);
 
 	return (
 		<ValueSelector
 			options={options}
 			multiSelect={variable.multiSelect}
 			showAllOption={variable.showAllOption}
-			loading={isFetching || isVariableWaiting}
+			loading={isFetching}
 			selection={selection}
 			onChange={onChange}
 			testId={`variable-select-${variable.name}`}

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/useAutoSelect.ts

@@ -12,7 +12,7 @@ export function useAutoSelect(
 	variable: VariableFormModel,
 	options: string[],
 	selection: VariableSelection,
-	onAutoSelect: (selection: VariableSelection) => void,
+	onChange: (selection: VariableSelection) => void,
 ): void {
 	useEffect(() => {
 		if (options.length === 0 || selection.allSelected) {
@@ -28,11 +28,11 @@ export function useAutoSelect(
 		if (isValid) {
 			return;
 		}
-		const dv = variable.defaultValue;
-		const fallback = Array.isArray(dv) ? dv[0] : dv;
+		const fallback = (variable.defaultValue as { value?: string } | undefined)
+			?.value;
 		const initial =
 			fallback && options.includes(fallback) ? fallback : options[0];
-		onAutoSelect({
+		onChange({
 			value: variable.multiSelect ? [initial] : initial,
 			allSelected: false,
 		});

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/useVariableFetchState.ts

@@ -1,44 +0,0 @@
-import {
-	selectVariableCycleId,
-	selectVariableFetchedOnce,
-	selectVariableFetchState,
-	type VariableFetchState,
-} from '../store/slices/variableFetchSlice';
-import { useDashboardStore } from '../store/useDashboardStore';
-
-export interface VariableFetchStateResult {
-	variableFetchState: VariableFetchState;
-	/** Include in the selector's react-query key to auto-cancel stale requests. */
-	variableFetchCycleId: number;
-	/** Actively fetching (first load or revalidating). */
-	isVariableFetching: boolean;
-	/** Stable — the fetch completed (or errored). */
-	isVariableSettled: boolean;
-	/** Blocked on parent dependencies (query order) or query variables (dynamics). */
-	isVariableWaiting: boolean;
-	/** Completed at least one fetch — keeps the query subscribed so a cycle bump refetches. */
-	hasVariableFetchedOnce: boolean;
-}
-
-/**
- * Per-variable view of the runtime fetch engine (`variableFetchSlice`), consumed
- * by the Query/Dynamic selectors to gate their fetch and key it by cycle id.
- * V2-native equivalent of V1's `useVariableFetchState`.
- */
-export function useVariableFetchState(name: string): VariableFetchStateResult {
-	const variableFetchState = useDashboardStore(selectVariableFetchState(name));
-	const variableFetchCycleId = useDashboardStore(selectVariableCycleId(name));
-	const hasVariableFetchedOnce = useDashboardStore(
-		selectVariableFetchedOnce(name),
-	);
-
-	return {
-		variableFetchState,
-		variableFetchCycleId,
-		isVariableFetching:
-			variableFetchState === 'loading' || variableFetchState === 'revalidating',
-		isVariableSettled: variableFetchState === 'idle',
-		isVariableWaiting: variableFetchState === 'waiting',
-		hasVariableFetchedOnce,
-	};
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/useVariableSelection.ts

@@ -1,10 +1,6 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo } from 'react';
 import { parseAsJson, useQueryState } from 'nuqs';
-// eslint-disable-next-line no-restricted-imports -- global time selector still on redux
-import { useSelector } from 'react-redux';
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
-import type { AppState } from 'store/reducers';
-import type { GlobalReducer } from 'types/reducer/globalTime';
 
 import { dtoToFormModel } from '../DashboardSettings/Variables/variableAdapters';
 import type { VariableFormModel } from '../DashboardSettings/Variables/variableFormModel';
@@ -16,8 +12,8 @@ import type {
 	VariableSelectionMap,
 } from './selectionTypes';
 import {
-	deriveFetchContext,
-	doAllQueryVariablesHaveValues,
+	computeVariableDependencies,
+	type VariableDependencyData,
 } from './variableDependencies';
 
 /** URL sentinel for an "ALL values selected" state (matches V1). */
@@ -33,14 +29,12 @@ export const variablesUrlParser = parseAsJson<
 );
 
 function defaultSelection(model: VariableFormModel): VariableSelection {
-	// `defaultValue` is a string | string[] on the wire.
-	const def = model.defaultValue;
-	if (Array.isArray(def) && def.length > 0) {
+	const def = (
+		model.defaultValue as { value?: SelectedVariableValue } | undefined
+	)?.value;
+	if (def !== undefined && def !== null && def !== '') {
 		return { value: def, allSelected: false };
 	}
-	if (typeof def === 'string' && def !== '') {
-		return { value: model.multiSelect ? [def] : def, allSelected: false };
-	}
 	return { value: model.multiSelect ? [] : '', allSelected: false };
 }
 
@@ -52,14 +46,9 @@ function fromUrlValue(raw: SelectedVariableValue): VariableSelection {
 
 interface UseVariableSelection {
 	variables: VariableFormModel[];
+	dependencyData: VariableDependencyData;
 	selection: VariableSelectionMap;
 	setSelection: (name: string, selection: VariableSelection) => void;
-	/**
-	 * Auto-selection fill (default/first-option) applied when options arrive. Unlike
-	 * {@link UseVariableSelection.setSelection}, fills from the initial load burst are
-	 * coalesced into one store write + one downstream refresh.
-	 */
-	autoSelect: (name: string, selection: VariableSelection) => void;
 }
 
 /**
@@ -76,37 +65,27 @@ export function useVariableSelection(
 		() => (dashboard.spec?.variables ?? []).map(dtoToFormModel),
 		[dashboard.spec?.variables],
 	);
-	const fetchContext = useMemo(() => deriveFetchContext(variables), [variables]);
+	const dependencyData = useMemo(
+		() => computeVariableDependencies(variables),
+		[variables],
+	);
 
 	const selection = useDashboardStore(selectVariableValues(dashboardId));
 	const setVariableValue = useDashboardStore((s) => s.setVariableValue);
 	const setVariableValues = useDashboardStore((s) => s.setVariableValues);
-	const initVariableFetch = useDashboardStore((s) => s.initVariableFetch);
-	const enqueueFetchAll = useDashboardStore((s) => s.enqueueFetchAll);
-	const enqueueDescendants = useDashboardStore((s) => s.enqueueDescendants);
-	const enqueueDescendantsBatch = useDashboardStore(
-		(s) => s.enqueueDescendantsBatch,
-	);
-
-	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	// Latest selection, read by the fetch-cycle effect without subscribing to it
-	// (so a value change doesn't re-trigger a full fetch cycle).
-	const selectionRef = useRef(selection);
-	selectionRef.current = selection;
 
 	const [urlValues, setUrlValues] = useQueryState(
 		'variables',
 		variablesUrlParser.withOptions({ history: 'replace' }),
 	);
 
-	// Seed selections: URL wins, then persisted store, then default.
+	// Seed selections for this dashboard: URL wins, then persisted store, then default.
 	useEffect(() => {
 		if (!dashboardId || variables.length === 0) {
 			return;
 		}
+		// `selection` here is the persisted (localStorage) map on mount — the
+		// effect deliberately doesn't depend on it, so seeding runs once per set.
 		const stored = selection;
 		const seeded: VariableSelectionMap = {};
 		variables.forEach((variable) => {
@@ -123,83 +102,16 @@ export function useVariableSelection(
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [dashboardId, variables]);
 
-	// Start a full fetch cycle on load / dependency-order / time change. Runs after
-	// the seeding effect above, so it reads the seeded selection from the store; a
-	// value change instead goes through `enqueueDescendants`, not this effect.
-	const orderKey = `${fetchContext.queryVariableOrder.join(
-		',',
-	)}|${fetchContext.dynamicVariableOrder.join(',')}`;
-	useEffect(() => {
-		if (!dashboardId || variables.length === 0) {
-			return;
-		}
-		const names = variables
-			.map((v) => v.name)
-			.filter((name): name is string => !!name);
-		initVariableFetch(names, fetchContext);
-		enqueueFetchAll(
-			doAllQueryVariablesHaveValues(variables, selectionRef.current),
-		);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [dashboardId, orderKey, minTime, maxTime]);
-
 	const setSelection = useCallback(
 		(name: string, next: VariableSelection): void => {
 			setVariableValue(dashboardId, name, next);
-			enqueueDescendants(name);
 			void setUrlValues((prev) => ({
 				...(prev ?? {}),
 				[name]: next.allSelected ? ALL_SELECTED : next.value,
 			}));
 		},
-		[dashboardId, setVariableValue, enqueueDescendants, setUrlValues],
+		[dashboardId, setVariableValue, setUrlValues],
 	);
 
-	// Coalesce the initial load burst of auto-selections: each selector fills its
-	// value as its options resolve (at different times). Collecting them into one
-	// store write + one `enqueueDescendantsBatch` means dependents re-fetch once
-	// with the settled parent values, instead of once per fill.
-	const pendingAutoFillRef = useRef<VariableSelectionMap>({});
-	const autoFillFrameRef = useRef<number | null>(null);
-
-	const flushAutoFills = useCallback((): void => {
-		autoFillFrameRef.current = null;
-		const fills = pendingAutoFillRef.current;
-		pendingAutoFillRef.current = {};
-		const names = Object.keys(fills);
-		if (names.length === 0 || !dashboardId) {
-			return;
-		}
-		setVariableValues(dashboardId, { ...selectionRef.current, ...fills });
-		void setUrlValues((prev) => {
-			const next = { ...(prev ?? {}) };
-			names.forEach((name) => {
-				const sel = fills[name];
-				next[name] = sel.allSelected ? ALL_SELECTED : sel.value;
-			});
-			return next;
-		});
-		enqueueDescendantsBatch(names);
-	}, [dashboardId, setVariableValues, setUrlValues, enqueueDescendantsBatch]);
-
-	const autoSelect = useCallback(
-		(name: string, next: VariableSelection): void => {
-			pendingAutoFillRef.current[name] = next;
-			if (autoFillFrameRef.current == null) {
-				autoFillFrameRef.current = requestAnimationFrame(flushAutoFills);
-			}
-		},
-		[flushAutoFills],
-	);
-
-	useEffect(
-		() => (): void => {
-			if (autoFillFrameRef.current != null) {
-				cancelAnimationFrame(autoFillFrameRef.current);
-			}
-		},
-		[],
-	);
-
-	return { variables, selection, setSelection, autoSelect };
+	return { variables, dependencyData, selection, setSelection };
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/variableDependencies.ts

@@ -1,11 +1,6 @@
 import { textContainsVariableReference } from 'lib/dashboardVariables/variableReference';
 
-import type {
-	VariableFormModel,
-	VariableType,
-} from '../DashboardSettings/Variables/variableFormModel';
-import type { VariableSelectionMap } from './selectionTypes';
-import { isResolved } from './selectionUtils';
+import type { VariableFormModel } from '../DashboardSettings/Variables/variableFormModel';
 
 /**
  * Inter-variable dependency graph for runtime selection. A QUERY variable
@@ -202,57 +197,3 @@ export function computeVariableDependencies(
 ): VariableDependencyData {
 	return buildDependencyData(buildDependencies(variables));
 }
-
-/**
- * Static context the runtime fetch engine (`variableFetchSlice`) needs to order
- * fetches: the dependency graph plus the per-name type index and the QUERY /
- * DYNAMIC fetch orders. Derived from the variable definitions; stable until the
- * spec's variables change. Mirrors V1's `getVariableDependencyContext`.
- */
-export interface VariableFetchContext {
-	dependencyData: VariableDependencyData;
-	/** variable name → its type. */
-	variableTypes: Record<string, VariableType>;
-	/** QUERY variables in topological (parent-before-child) order. */
-	queryVariableOrder: string[];
-	/** DYNAMIC variable names (they implicitly depend on all QUERY values). */
-	dynamicVariableOrder: string[];
-}
-
-export function deriveFetchContext(
-	variables: VariableFormModel[],
-): VariableFetchContext {
-	const dependencyData = computeVariableDependencies(variables);
-	const variableTypes: Record<string, VariableType> = {};
-	variables.forEach((v) => {
-		if (v.name) {
-			variableTypes[v.name] = v.type;
-		}
-	});
-	const queryVariableOrder = dependencyData.order.filter(
-		(name) => variableTypes[name] === 'QUERY',
-	);
-	const dynamicVariableOrder = variables
-		.filter((v) => v.type === 'DYNAMIC' && !!v.name)
-		.map((v) => v.name);
-	return {
-		dependencyData,
-		variableTypes,
-		queryVariableOrder,
-		dynamicVariableOrder,
-	};
-}
-
-/**
- * Whether every QUERY variable already has a usable selection — decides at load
- * time whether dynamic variables may fetch immediately or must wait for the
- * query variables to settle first (V1 parity).
- */
-export function doAllQueryVariablesHaveValues(
-	variables: VariableFormModel[],
-	selection: VariableSelectionMap,
-): boolean {
-	return variables
-		.filter((v) => v.type === 'QUERY')
-		.every((v) => isResolved(selection[v.name]));
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/__tests__/variableFetchSlice.test.ts

@@ -1,97 +0,0 @@
-import {
-	emptyVariableFormModel,
-	type VariableFormModel,
-} from '../../../DashboardSettings/Variables/variableFormModel';
-import { deriveFetchContext } from '../../../VariablesBar/variableDependencies';
-import { useDashboardStore } from '../../useDashboardStore';
-
-function model(overrides: Partial<VariableFormModel>): VariableFormModel {
-	return { ...emptyVariableFormModel(), ...overrides };
-}
-
-// q1 (root query) → q2 (query referencing $q1) ; d1 (dynamic).
-const q1 = model({ name: 'q1', type: 'QUERY', queryValue: 'SELECT 1' });
-const q2 = model({ name: 'q2', type: 'QUERY', queryValue: 'SELECT $q1' });
-const d1 = model({ name: 'd1', type: 'DYNAMIC', dynamicAttribute: 'pod' });
-const context = deriveFetchContext([q1, q2, d1]);
-
-function store(): ReturnType<typeof useDashboardStore.getState> {
-	return useDashboardStore.getState();
-}
-function states(): Record<string, string> {
-	return store().variableFetchStates;
-}
-
-beforeEach(() => {
-	useDashboardStore.setState({
-		variableFetchStates: {},
-		variableLastUpdated: {},
-		variableCycleIds: {},
-		variableFetchContext: null,
-	});
-	store().initVariableFetch(['q1', 'q2', 'd1'], context);
-});
-
-describe('variableFetchSlice', () => {
-	it('initializes every variable to idle', () => {
-		expect(states()).toStrictEqual({ q1: 'idle', q2: 'idle', d1: 'idle' });
-	});
-
-	it('enqueueFetchAll loads roots, waits dependents and (ungated) dynamics', () => {
-		store().enqueueFetchAll(false);
-		expect(states()).toStrictEqual({
-			q1: 'loading',
-			q2: 'waiting',
-			d1: 'waiting',
-		});
-		expect(store().variableCycleIds).toStrictEqual({ q1: 1, q2: 1, d1: 1 });
-	});
-
-	it('enqueueFetchAll loads dynamics immediately when query values exist', () => {
-		store().enqueueFetchAll(true);
-		expect(states().d1).toBe('loading');
-	});
-
-	it('completing a parent unblocks its query child, then unlocks dynamics', () => {
-		store().enqueueFetchAll(false);
-		store().onVariableFetchComplete('q1');
-		expect(states()).toMatchObject({ q1: 'idle', q2: 'loading', d1: 'waiting' });
-
-		store().onVariableFetchComplete('q2');
-		expect(states()).toMatchObject({ q1: 'idle', q2: 'idle', d1: 'loading' });
-	});
-
-	it('enqueueDescendants revalidates only descendants + dynamics', () => {
-		store().enqueueFetchAll(false);
-		store().onVariableFetchComplete('q1');
-		store().onVariableFetchComplete('q2');
-		store().onVariableFetchComplete('d1');
-
-		store().enqueueDescendants('q1');
-		// q2 depends on q1 (settled) → revalidates; d1 waits (q2 no longer settled).
-		expect(states().q2).toBe('revalidating');
-		expect(states().d1).toBe('waiting');
-	});
-
-	it('enqueueDescendantsBatch bumps each descendant + dynamic exactly once', () => {
-		store().enqueueFetchAll(false);
-		store().onVariableFetchComplete('q1');
-		store().onVariableFetchComplete('q2');
-		store().onVariableFetchComplete('d1');
-		const before = { ...store().variableCycleIds };
-
-		// q1 and q2 auto-select together: q2 is a descendant of q1 but is also in
-		// the batch — it should still bump only once, as should the dynamic.
-		store().enqueueDescendantsBatch(['q1', 'q2']);
-		const after = store().variableCycleIds;
-		expect(after.q2).toBe(before.q2 + 1);
-		expect(after.d1).toBe(before.d1 + 1);
-	});
-
-	it('a failed parent idles its query descendants', () => {
-		store().enqueueFetchAll(false);
-		store().onVariableFetchFailure('q1');
-		expect(states().q1).toBe('error');
-		expect(states().q2).toBe('idle');
-	});
-});

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

@@ -1,261 +0,0 @@
-import type { StateCreator } from 'zustand';
-
-import type { VariableFetchContext } from '../../VariablesBar/variableDependencies';
-import type { DashboardStore } from '../useDashboardStore';
-import {
-	areAllQueryVariablesSettled,
-	type FetchMaps,
-	isSettled,
-	resolveFetchState,
-	unlockWaitingDynamicVariables,
-	type VariableFetchState,
-} from './variableFetchSlice.utils';
-
-export type { VariableFetchState } from './variableFetchSlice.utils';
-
-/**
- * Runtime fetch orchestration for dashboard variables — native port of V1's
- * `variableFetchStore`. Decides WHEN each variable's options fetch: query
- * variables in dependency order, dynamics together once query values exist,
- * text/custom never. `cycleIds` is a per-variable request nonce keyed into each
- * selector's react-query key (bump = fresh fetch, auto-cancel stale). Transient.
- * `enqueueFetchAll` = load/time change; `enqueueDescendants` = one value changed.
- */
-export interface VariableFetchSlice {
-	variableFetchStates: Record<string, VariableFetchState>;
-	variableLastUpdated: Record<string, number>;
-	variableCycleIds: Record<string, number>;
-	/** Static dependency context, set by `initVariableFetch` (null before init). */
-	variableFetchContext: VariableFetchContext | null;
-
-	/** Seed state entries for the current variable set and store the context. */
-	initVariableFetch: (names: string[], context: VariableFetchContext) => void;
-	/** Start a full fetch cycle for every fetchable variable (load / time change). */
-	enqueueFetchAll: (doAllQueryVariablesHaveValuesSelected: boolean) => void;
-	/** Mark a variable's fetch as done; unblock its waiting children / dynamics. */
-	onVariableFetchComplete: (name: string) => void;
-	/** Mark a variable's fetch as failed; idle its query descendants. */
-	onVariableFetchFailure: (name: string) => void;
-	/** Cascade a value change to a variable's query descendants + the dynamics. */
-	enqueueDescendants: (name: string) => void;
-	/**
-	 * Batched value-change cascade: refresh the union of the given variables'
-	 * query descendants plus the dynamics, each exactly once. Used to collapse the
-	 * initial burst of auto-selections into a single downstream fetch.
-	 */
-	enqueueDescendantsBatch: (names: string[]) => void;
-}
-
-/** Snapshot the three fetch maps into mutable clones for a single action. */
-function cloneMaps(state: DashboardStore): FetchMaps {
-	return {
-		states: { ...state.variableFetchStates },
-		lastUpdated: { ...state.variableLastUpdated },
-		cycleIds: { ...state.variableCycleIds },
-	};
-}
-
-export const createVariableFetchSlice: StateCreator<
-	DashboardStore,
-	[['zustand/persist', unknown]],
-	[],
-	VariableFetchSlice
-> = (set, get) => ({
-	variableFetchStates: {},
-	variableLastUpdated: {},
-	variableCycleIds: {},
-	variableFetchContext: null,
-
-	initVariableFetch: (names, context): void => {
-		const maps = cloneMaps(get());
-		// Initialize new variables to idle, preserving existing states.
-		names.forEach((name) => {
-			if (!maps.states[name]) {
-				maps.states[name] = 'idle';
-			}
-		});
-		// Drop entries for variables that no longer exist.
-		const nameSet = new Set(names);
-		Object.keys(maps.states).forEach((name) => {
-			if (!nameSet.has(name)) {
-				delete maps.states[name];
-				delete maps.lastUpdated[name];
-				delete maps.cycleIds[name];
-			}
-		});
-		set({
-			variableFetchStates: maps.states,
-			variableLastUpdated: maps.lastUpdated,
-			variableCycleIds: maps.cycleIds,
-			variableFetchContext: context,
-		});
-	},
-
-	enqueueFetchAll: (doAllQueryVariablesHaveValuesSelected): void => {
-		const { variableFetchContext } = get();
-		if (!variableFetchContext) {
-			return;
-		}
-		const {
-			dependencyData,
-			variableTypes,
-			queryVariableOrder,
-			dynamicVariableOrder,
-		} = variableFetchContext;
-		const maps = cloneMaps(get());
-
-		// Query variables: roots start immediately, dependents wait for parents.
-		queryVariableOrder.forEach((name) => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
-			const parents = dependencyData.parentGraph[name] || [];
-			const hasQueryParents = parents.some((p) => variableTypes[p] === 'QUERY');
-			maps.states[name] = hasQueryParents
-				? 'waiting'
-				: resolveFetchState(maps, name);
-		});
-
-		// Dynamic variables: start now if query variables already have values,
-		// otherwise wait until the query variables settle.
-		dynamicVariableOrder.forEach((name) => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
-			maps.states[name] = doAllQueryVariablesHaveValuesSelected
-				? resolveFetchState(maps, name)
-				: 'waiting';
-		});
-
-		set({
-			variableFetchStates: maps.states,
-			variableLastUpdated: maps.lastUpdated,
-			variableCycleIds: maps.cycleIds,
-		});
-	},
-
-	onVariableFetchComplete: (name): void => {
-		const { variableFetchContext } = get();
-		const maps = cloneMaps(get());
-		maps.states[name] = 'idle';
-		maps.lastUpdated[name] = Date.now();
-
-		if (variableFetchContext) {
-			const { dependencyData, variableTypes, dynamicVariableOrder } =
-				variableFetchContext;
-			// Unblock waiting query-type children.
-			(dependencyData.graph[name] || []).forEach((child) => {
-				if (variableTypes[child] === 'QUERY' && maps.states[child] === 'waiting') {
-					maps.states[child] = resolveFetchState(maps, child);
-				}
-			});
-			// Once all query variables settle, unlock any waiting dynamics.
-			if (
-				variableTypes[name] === 'QUERY' &&
-				areAllQueryVariablesSettled(maps.states, variableTypes)
-			) {
-				unlockWaitingDynamicVariables(maps, dynamicVariableOrder);
-			}
-		}
-
-		set({
-			variableFetchStates: maps.states,
-			variableLastUpdated: maps.lastUpdated,
-			variableCycleIds: maps.cycleIds,
-		});
-	},
-
-	onVariableFetchFailure: (name): void => {
-		const { variableFetchContext } = get();
-		const maps = cloneMaps(get());
-		maps.states[name] = 'error';
-
-		if (variableFetchContext) {
-			const { dependencyData, variableTypes, dynamicVariableOrder } =
-				variableFetchContext;
-			// Query descendants can't proceed without this parent — idle them.
-			(dependencyData.transitiveDescendants[name] || []).forEach((desc) => {
-				if (variableTypes[desc] === 'QUERY') {
-					maps.states[desc] = 'idle';
-				}
-			});
-			if (
-				variableTypes[name] === 'QUERY' &&
-				areAllQueryVariablesSettled(maps.states, variableTypes)
-			) {
-				unlockWaitingDynamicVariables(maps, dynamicVariableOrder);
-			}
-		}
-
-		set({
-			variableFetchStates: maps.states,
-			variableLastUpdated: maps.lastUpdated,
-			variableCycleIds: maps.cycleIds,
-		});
-	},
-
-	enqueueDescendants: (name): void => {
-		get().enqueueDescendantsBatch([name]);
-	},
-
-	enqueueDescendantsBatch: (names): void => {
-		const { variableFetchContext } = get();
-		if (!variableFetchContext || names.length === 0) {
-			return;
-		}
-		const { dependencyData, variableTypes, dynamicVariableOrder } =
-			variableFetchContext;
-		const maps = cloneMaps(get());
-
-		// Union of the changed variables' query descendants, refreshed once each:
-		// refetch when all their parents are settled, else wait.
-		const queryDescendants = new Set<string>();
-		names.forEach((name) => {
-			(dependencyData.transitiveDescendants[name] || []).forEach((desc) => {
-				if (variableTypes[desc] === 'QUERY') {
-					queryDescendants.add(desc);
-				}
-			});
-		});
-		queryDescendants.forEach((desc) => {
-			maps.cycleIds[desc] = (maps.cycleIds[desc] || 0) + 1;
-			const parents = dependencyData.parentGraph[desc] || [];
-			const allParentsSettled = parents.every((p) => isSettled(maps.states[p]));
-			maps.states[desc] = allParentsSettled
-				? resolveFetchState(maps, desc)
-				: 'waiting';
-		});
-
-		// Dynamics implicitly depend on all query values: refetch now if the query
-		// variables are settled, otherwise wait for them.
-		dynamicVariableOrder.forEach((dynName) => {
-			maps.cycleIds[dynName] = (maps.cycleIds[dynName] || 0) + 1;
-			maps.states[dynName] = areAllQueryVariablesSettled(
-				maps.states,
-				variableTypes,
-			)
-				? resolveFetchState(maps, dynName)
-				: 'waiting';
-		});
-
-		set({
-			variableFetchStates: maps.states,
-			variableLastUpdated: maps.lastUpdated,
-			variableCycleIds: maps.cycleIds,
-		});
-	},
-});
-
-/** Selector: the fetch state for a single variable (defaults to idle). */
-export const selectVariableFetchState =
-	(name: string) =>
-	(state: DashboardStore): VariableFetchState =>
-		state.variableFetchStates[name] ?? 'idle';
-
-/** Selector: the current fetch cycle id for a single variable (defaults to 0). */
-export const selectVariableCycleId =
-	(name: string) =>
-	(state: DashboardStore): number =>
-		state.variableCycleIds[name] ?? 0;
-
-/** Selector: whether a variable has completed at least one fetch. */
-export const selectVariableFetchedOnce =
-	(name: string) =>
-	(state: DashboardStore): boolean =>
-		(state.variableLastUpdated[name] ?? 0) > 0;

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/variableFetchSlice.utils.ts

@@ -1,51 +0,0 @@
-import type { VariableType } from '../../DashboardSettings/Variables/variableFormModel';
-
-/** Per-variable fetch lifecycle (ported from V1's `variableFetchStore`). */
-export type VariableFetchState =
-	| 'idle'
-	| 'loading'
-	| 'revalidating'
-	| 'waiting'
-	| 'error';
-
-/** Mutable clones a fetch action works over before committing back in one `set`. */
-export interface FetchMaps {
-	states: Record<string, VariableFetchState>;
-	lastUpdated: Record<string, number>;
-	cycleIds: Record<string, number>;
-}
-
-/** Settled = can make no further progress (idle or error). */
-export function isSettled(state: VariableFetchState | undefined): boolean {
-	return state === 'idle' || state === 'error';
-}
-
-/** Fetch-start state: `revalidating` if fetched before, else `loading`. */
-export function resolveFetchState(
-	maps: FetchMaps,
-	name: string,
-): VariableFetchState {
-	return (maps.lastUpdated[name] || 0) > 0 ? 'revalidating' : 'loading';
-}
-
-/** True once every QUERY variable is settled. */
-export function areAllQueryVariablesSettled(
-	states: Record<string, VariableFetchState>,
-	variableTypes: Record<string, VariableType>,
-): boolean {
-	return Object.entries(variableTypes)
-		.filter(([, type]) => type === 'QUERY')
-		.every(([name]) => isSettled(states[name]));
-}
-
-/** Move any `waiting` dynamic variables into loading/revalidating. */
-export function unlockWaitingDynamicVariables(
-	maps: FetchMaps,
-	dynamicVariableOrder: string[],
-): void {
-	dynamicVariableOrder.forEach((dynName) => {
-		if (maps.states[dynName] === 'waiting') {
-			maps.states[dynName] = resolveFetchState(maps, dynName);
-		}
-	});
-}

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

@@ -13,15 +13,10 @@ import {
 	createVariableSelectionSlice,
 	type VariableSelectionSlice,
 } from './slices/variableSelectionSlice';
-import {
-	createVariableFetchSlice,
-	type VariableFetchSlice,
-} from './slices/variableFetchSlice';
 
 export type DashboardStore = EditContextSlice &
 	CollapseSlice &
-	VariableSelectionSlice &
-	VariableFetchSlice;
+	VariableSelectionSlice;
 
 /**
  * V2 dashboard session store. Holds cross-cutting client state only — never the
@@ -36,7 +31,6 @@ export const useDashboardStore = create<DashboardStore>()(
 			...createEditContextSlice(...a),
 			...createCollapseSlice(...a),
 			...createVariableSelectionSlice(...a),
-			...createVariableFetchSlice(...a),
 		}),
 		{
 			name: '@signoz/dashboard-v2',

frontend/src/pages/DashboardsListPageV2/components/DashboardsList/CommandHeader.tsx

@@ -7,7 +7,6 @@ import styles from './DashboardsList.module.scss';
 interface Props {
 	label: string;
 	count: number;
-	isModified: boolean;
 	canCreate: boolean;
 	onCreate: () => void;
 }
@@ -15,7 +14,6 @@ interface Props {
 function CommandHeader({
 	label,
 	count,
-	isModified,
 	canCreate,
 	onCreate,
 }: Props): JSX.Element {
@@ -23,7 +21,6 @@ function CommandHeader({
 		<div className={styles.commandHeader}>
 			<div className={styles.headingBlock}>
 				<Typography.Title className={styles.title}>{label}</Typography.Title>
-				{isModified && <span className={styles.dirtyDot} title="Unsaved changes" />}
 				<span className={styles.countPill}>{count}</span>
 			</div>
 			<div className={styles.grow} />

frontend/src/pages/DashboardsListPageV2/components/DashboardsList/DashboardsList.module.scss

@@ -93,14 +93,6 @@
 	flex: 1;
 }
 
-.dirtyDot {
-	width: 7px;
-	height: 7px;
-	border-radius: 50%;
-	background: var(--warning-background);
-	flex: none;
-}
-
 .countPill {
 	padding: 2px 9px;
 	border-radius: 999px;

frontend/src/pages/DashboardsListPageV2/components/DashboardsList/DashboardsList.tsx

@@ -10,9 +10,9 @@ import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useAppContext } from 'providers/App/App';
 import { toAPIError } from 'utils/errorUtils';
 
+import { combineQueries } from '../../utils/filterQuery';
 import { useAccumulatedTags } from '../../hooks/useAccumulatedTags';
 import { useActiveView } from '../../hooks/useActiveView';
-import { useCreatorOptions } from '../../hooks/useCreatorOptions';
 import { useDashboardFilters } from '../../hooks/useDashboardFilters';
 import {
 	usePage,
@@ -25,6 +25,7 @@ import { BuiltinViewId } from '../../types';
 import type { SelectedTag, UpdatedWindow } from '../../types';
 import type { DashboardListItem } from '../../utils/helpers';
 import { applyClientView } from '../../utils/views';
+import type { CreatorOption } from '../FilterZone/FilterChips';
 import FilterZone from '../FilterZone/FilterZone';
 import NewDashboardModal from '../NewDashboardModal/NewDashboardModal';
 import StatusBar from '../StatusBar/StatusBar';
@@ -71,13 +72,13 @@ function DashboardsList(): JSX.Element {
 		customViewsLoading,
 		isCustomActive,
 		isModified,
+		viewQuery,
 		clientView,
 		selectView,
 		saveView,
 		saveActiveView,
 		resetView,
 		removeView,
-		renameView,
 	} = useActiveView({
 		filters,
 		applyFilters,
@@ -152,13 +153,13 @@ function DashboardsList(): JSX.Element {
 
 	const listParams = useMemo(
 		() => ({
-			query: query || undefined,
+			query: combineQueries(viewQuery, query) || undefined,
 			sort: sortColumn,
 			order: sortOrder,
 			limit: clientView ? CLIENT_VIEW_LIMIT : PAGE_SIZE,
 			offset: clientView ? 0 : (page - 1) * PAGE_SIZE,
 		}),
-		[query, sortColumn, sortOrder, page, clientView],
+		[viewQuery, query, sortColumn, sortOrder, page, clientView],
 	);
 
 	const {
@@ -194,19 +195,24 @@ function DashboardsList(): JSX.Element {
 	);
 	const total = clientView ? dashboards.length : (response?.data?.total ?? 0);
 
-	// Authors present on the loaded page — a fallback for the creator filter until
-	// the org-wide user list resolves.
-	const pageAuthorEmails = useMemo<string[]>(
-		() =>
-			rawDashboards
-				.map((d) => d.createdBy)
-				.filter((email): email is string => !!email),
-		[rawDashboards],
-	);
-	const creatorOptions = useCreatorOptions({
-		currentUserEmail: user.email,
-		fallbackEmails: pageAuthorEmails,
-	});
+	// Creator filter options: distinct authors on the loaded page plus the
+	// current user (so "me" is always selectable). Page-scoped until a members
+	// source backs this.
+	const creatorOptions = useMemo<CreatorOption[]>(() => {
+		const emails = new Set<string>();
+		if (user.email) {
+			emails.add(user.email);
+		}
+		rawDashboards.forEach((d) => {
+			if (d.createdBy) {
+				emails.add(d.createdBy);
+			}
+		});
+		return [...emails].sort().map((email) => ({
+			email,
+			label: email === user.email ? `${email} (me)` : email,
+		}));
+	}, [rawDashboards, user.email]);
 
 	// All key:value tags the API reports for the org's dashboards, powering the
 	// Tags filter chip and DSL key suggestions. Accumulated across refetches so
@@ -283,8 +289,8 @@ function DashboardsList(): JSX.Element {
 				onSave={saveView}
 				onSaveChanges={saveActiveView}
 				onReset={handleResetView}
+				onClearFilters={handleClearAll}
 				onDelete={handleRemoveView}
-				onRename={renameView}
 			/>
 			<div className={styles.main}>
 				<div className={styles.mainScroll}>
@@ -299,7 +305,6 @@ function DashboardsList(): JSX.Element {
 								<CommandHeader
 									label={activeLabel}
 									count={total}
-									isModified={isModified}
 									canCreate={canCreateNewDashboard}
 									onCreate={openCreate}
 								/>

frontend/src/pages/DashboardsListPageV2/components/ViewsRail/SaveViewPopover.tsx

@@ -6,45 +6,32 @@ import { Typography } from '@signozhq/ui/typography';
 
 import styles from './ViewsRail.module.scss';
 
-export const VIEW_NAME_MAX_LENGTH = 128;
-
 interface Props {
 	open: boolean;
 	onOpenChange: (open: boolean) => void;
-	onSubmit: (name: string) => void;
+	onSave: (name: string) => void;
 	trigger: ReactNode;
-	title: string;
-	confirmLabel: string;
-	initialName?: string;
-	testIdPrefix?: string;
 }
 
-// Name-input popover shared by "save as view" and "rename view"; enforces the
-// view-name length cap in one place.
-function ViewNamePopover({
+function SaveViewPopover({
 	open,
 	onOpenChange,
-	onSubmit,
+	onSave,
 	trigger,
-	title,
-	confirmLabel,
-	initialName = '',
-	testIdPrefix = 'view-name',
 }: Props): JSX.Element {
-	const [name, setName] = useState(initialName);
+	const [name, setName] = useState('');
 
 	useEffect(() => {
 		if (open) {
-			setName(initialName);
+			setName('');
 		}
-	}, [open, initialName]);
+	}, [open]);
 
-	const trimmed = name.trim();
-	const canSave = trimmed.length > 0 && trimmed.length <= VIEW_NAME_MAX_LENGTH;
+	const canSave = name.trim().length > 0;
 
 	const handleSave = (): void => {
 		if (canSave) {
-			onSubmit(trimmed);
+			onSave(name);
 			onOpenChange(false);
 		}
 	};
@@ -57,14 +44,13 @@ function ViewNamePopover({
 			trigger={trigger}
 		>
 			<div className={styles.savePopover}>
-				<div className={styles.saveTitle}>{title}</div>
+				<div className={styles.saveTitle}>Save as view</div>
 				<Typography.Text className={styles.saveLabel}>Name</Typography.Text>
 				<Input
 					value={name}
 					autoFocus
-					maxLength={VIEW_NAME_MAX_LENGTH}
 					placeholder="e.g. Prod alerts"
-					testId={`${testIdPrefix}-name`}
+					testId="save-view-name"
 					onChange={(e: ChangeEvent<HTMLInputElement>): void =>
 						setName(e.target.value)
 					}
@@ -88,10 +74,10 @@ function ViewNamePopover({
 						color="primary"
 						size="sm"
 						disabled={!canSave}
-						testId={`${testIdPrefix}-confirm`}
+						testId="save-view-confirm"
 						onClick={handleSave}
 					>
-						{confirmLabel}
+						Save view
 					</Button>
 				</div>
 			</div>
@@ -99,4 +85,4 @@ function ViewNamePopover({
 	);
 }
 
-export default ViewNamePopover;
+export default SaveViewPopover;

frontend/src/pages/DashboardsListPageV2/components/ViewsRail/ViewsRail.module.scss

@@ -145,40 +145,30 @@
 	flex: none;
 }
 
-// Ghost action icons overlaid on the row's right edge — absolutely positioned so
-// they never reserve layout space or affect row height. Hidden until row hover,
-// and inert while hidden so they can't intercept clicks meant for the row.
-.itemActions {
+.itemAction {
+	// Blended ghost icon overlaid on the row's right edge — absolutely positioned
+	// so it never reserves layout space or affects the row height. Transparent so
+	// the row's hover background shows through; turns red only on its own hover.
 	position: absolute;
 	right: 6px;
 	top: 50%;
 	transform: translateY(-50%);
-	display: flex;
-	align-items: center;
-	gap: 2px;
-	opacity: 0;
-	pointer-events: none;
-	transition: opacity 0.1s;
-}
-
-.itemAction {
 	--button-height: 20px;
 	--button-padding: 0;
 	--button-border-radius: 4px;
 	--button-variant-ghost-color: var(--l3-foreground);
-	--button-variant-ghost-hover-background-color: var(--l1-background);
-	--button-variant-ghost-hover-color: var(--l1-foreground);
-	width: 20px;
-	height: 20px;
-	flex: none;
-}
-
-.itemActionDanger {
 	--button-variant-ghost-hover-background-color: var(--danger-background);
 	--button-variant-ghost-hover-color: var(--danger-color, #fff);
+	width: 20px;
+	height: 20px;
+	opacity: 0;
+	// Hidden until row hover, and inert while hidden so it can't intercept clicks
+	// meant for the row.
+	pointer-events: none;
+	transition: opacity 0.1s;
 }
 
-.row:hover .itemActions {
+.row:hover .itemAction {
 	opacity: 1;
 	pointer-events: auto;
 }

frontend/src/pages/DashboardsListPageV2/components/ViewsRail/ViewsRail.tsx

@@ -3,19 +3,12 @@ import { Modal } from 'antd';
 import { Button } from '@signozhq/ui/button';
 import { Input } from '@signozhq/ui/input';
 import { Typography } from '@signozhq/ui/typography';
-import {
-	Bookmark,
-	CircleAlert,
-	PenLine,
-	Plus,
-	Search,
-	Trash2,
-} from '@signozhq/icons';
+import { Bookmark, CircleAlert, Plus, Search, Trash2 } from '@signozhq/icons';
 import cx from 'classnames';
 
 import type { SavedView } from '../../types';
 import { type BuiltinView } from '../../utils/views';
-import ViewNamePopover from './ViewNamePopover';
+import SaveViewPopover from './SaveViewPopover';
 
 import styles from './ViewsRail.module.scss';
 
@@ -31,8 +24,8 @@ interface Props {
 	onSave: (name: string) => void;
 	onSaveChanges: () => void;
 	onReset: () => void;
+	onClearFilters: () => void;
 	onDelete: (id: string) => void;
-	onRename: (id: string, name: string) => void;
 }
 
 interface ViewRow {
@@ -56,11 +49,10 @@ function ViewsRail({
 	onSave,
 	onSaveChanges,
 	onReset,
+	onClearFilters,
 	onDelete,
-	onRename,
 }: Props): JSX.Element {
 	const [saveOpen, setSaveOpen] = useState(false);
-	const [renamingId, setRenamingId] = useState<string | null>(null);
 	const [query, setQuery] = useState('');
 	const [modal, contextHolder] = Modal.useModal();
 
@@ -130,44 +122,20 @@ function ViewsRail({
 					)}
 				</Button>
 				{row.deletable && (
-					<div className={styles.itemActions}>
-						<ViewNamePopover
-							open={renamingId === row.id}
-							onOpenChange={(open): void => setRenamingId(open ? row.id : null)}
-							onSubmit={(name): void => onRename(row.id, name)}
-							title="Rename view"
-							confirmLabel="Rename"
-							initialName={row.label}
-							testIdPrefix="rename-view"
-							trigger={
-								<Button
-									variant="ghost"
-									color="secondary"
-									size="icon"
-									className={styles.itemAction}
-									aria-label="Rename view"
-									title="Rename view"
-									onClick={(e): void => e.stopPropagation()}
-								>
-									<PenLine size={12} />
-								</Button>
-							}
-						/>
-						<Button
-							variant="ghost"
-							color="secondary"
-							size="icon"
-							className={cx(styles.itemAction, styles.itemActionDanger)}
-							aria-label="Delete view"
-							title="Delete view"
-							onClick={(e): void => {
-								e.stopPropagation();
-								confirmDelete(row.id, row.label);
-							}}
-						>
-							<Trash2 size={12} />
-						</Button>
-					</div>
+					<Button
+						variant="ghost"
+						color="secondary"
+						size="icon"
+						className={styles.itemAction}
+						aria-label="Delete view"
+						title="Delete view"
+						onClick={(e): void => {
+							e.stopPropagation();
+							confirmDelete(row.id, row.label);
+						}}
+					>
+						<Trash2 size={12} />
+					</Button>
 				)}
 			</div>
 		);
@@ -177,13 +145,10 @@ function ViewsRail({
 		<aside className={cx(styles.rail, { [styles.collapsed]: collapsed })}>
 			<div className={styles.header}>
 				<h4 className={styles.headerTitle}>Views</h4>
-				<ViewNamePopover
+				<SaveViewPopover
 					open={saveOpen}
 					onOpenChange={setSaveOpen}
-					onSubmit={onSave}
-					title="Save as view"
-					confirmLabel="Save view"
-					testIdPrefix="save-view"
+					onSave={onSave}
 					trigger={
 						<Button
 							variant="ghost"
@@ -303,8 +268,13 @@ function ViewsRail({
 						>
 							Save as new view
 						</Button>
-						<Button variant="ghost" color="secondary" size="sm" onClick={onReset}>
-							Reset
+						<Button
+							variant="ghost"
+							color="secondary"
+							size="sm"
+							onClick={onClearFilters}
+						>
+							Clear
 						</Button>
 					</div>
 				</div>

frontend/src/pages/DashboardsListPageV2/hooks/useActiveView.ts

@@ -7,6 +7,7 @@ import type {
 
 import {
 	areFilterStatesEqual,
+	combineQueries,
 	DEFAULT_FILTER_STATE,
 	filterStateToQuery,
 } from '../utils/filterQuery';
@@ -14,6 +15,7 @@ import { BuiltinViewId } from '../types';
 import type { DashboardFilterState, SavedView } from '../types';
 import {
 	BUILTIN_VIEWS,
+	builtinViewQuery,
 	builtinViewSnapshot,
 	type BuiltinView,
 	isClientView,
@@ -40,14 +42,15 @@ export interface UseActiveViewResult {
 	isCustomActive: boolean;
 	// Current filters diverge from the active view's canonical snapshot.
 	isModified: boolean;
-	// Whether the active view constrains the list client-side (pinned/recent).
+	// Extra server-query fragment the active view contributes, and whether it
+	// constrains the list client-side (pinned/recent).
+	viewQuery: string;
 	clientView: boolean;
 	selectView: (id: string) => void;
 	saveView: (name: string) => void;
 	saveActiveView: () => void;
 	resetView: () => void;
 	removeView: (id: string) => void;
-	renameView: (id: string, name: string) => void;
 }
 
 // The canonical filter snapshot a saved view "is": the backend stores a flat
@@ -124,9 +127,11 @@ export function useActiveView({
 
 	const saveView = useCallback(
 		(name: string): void => {
-			// The active view's clause already lives in the filter state (e.g. Locked
-			// seeds `locked = true` into search), so the chips fold into one query.
-			const query = filterStateToQuery(filters);
+			// Fold the current built-in clause + chips into a single query string.
+			const query = combineQueries(
+				builtinViewQuery(activeViewId),
+				filterStateToQuery(filters),
+			);
 			void (async (): Promise<void> => {
 				const created = await createView({
 					name,
@@ -142,7 +147,15 @@ export function useActiveView({
 				}
 			})();
 		},
-		[filters, createView, sortColumn, sortOrder, setActiveViewId, applyFilters],
+		[
+			activeViewId,
+			filters,
+			createView,
+			sortColumn,
+			sortOrder,
+			setActiveViewId,
+			applyFilters,
+		],
 	);
 
 	const saveActiveView = useCallback((): void => {
@@ -187,23 +200,6 @@ export function useActiveView({
 		[deleteView, activeViewId, setActiveViewId, applyFilters],
 	);
 
-	// Rename only touches the view's name; its stored query/sort/order are preserved.
-	const renameView = useCallback(
-		(id: string, name: string): void => {
-			const view = customViews.find((v) => v.id === id);
-			if (!view) {
-				return;
-			}
-			updateView(id, {
-				name,
-				query: view.query,
-				sort: view.sort,
-				order: view.order,
-			});
-		},
-		[customViews, updateView],
-	);
-
 	return {
 		activeViewId,
 		builtinViews: BUILTIN_VIEWS,
@@ -211,12 +207,12 @@ export function useActiveView({
 		customViewsLoading,
 		isCustomActive: !!activeCustom,
 		isModified,
+		viewQuery: builtinViewQuery(activeViewId),
 		clientView: isClientView(activeViewId),
 		selectView,
 		saveView,
 		saveActiveView,
 		resetView,
 		removeView,
-		renameView,
 	};
 }

frontend/src/pages/DashboardsListPageV2/hooks/useCreatorOptions.ts

@@ -1,43 +0,0 @@
-import { useMemo } from 'react';
-import { useListUsers } from 'api/generated/services/users';
-
-import type { CreatorOption } from '../components/FilterZone/FilterChips';
-
-interface Args {
-	currentUserEmail: string;
-	// Authors on the loaded page — kept selectable until the org list resolves.
-	fallbackEmails: string[];
-}
-
-// Creator-filter options sourced from the org's full user list, so authors who
-// aren't on the current page are still selectable (v2 "List users" API).
-export function useCreatorOptions({
-	currentUserEmail,
-	fallbackEmails,
-}: Args): CreatorOption[] {
-	const { data } = useListUsers();
-
-	return useMemo<CreatorOption[]>(() => {
-		const users = data?.data ?? [];
-		const emails = new Set<string>();
-		if (currentUserEmail) {
-			emails.add(currentUserEmail);
-		}
-		users.forEach((u) => u.email && emails.add(u.email));
-		// Until the org list resolves (or if it comes back empty), keep the page's
-		// authors selectable so the filter never regresses to just "me".
-		if (users.length === 0) {
-			fallbackEmails.forEach((e) => emails.add(e));
-		}
-
-		const labelFor = (email: string): string => {
-			if (email === currentUserEmail) {
-				return `${email} (me)`;
-			}
-			const match = users.find((u) => u.email === email);
-			return match?.displayName ? `${match.displayName} (${email})` : email;
-		};
-
-		return [...emails].sort().map((email) => ({ email, label: labelFor(email) }));
-	}, [data, currentUserEmail, fallbackEmails]);
-}

frontend/src/pages/DashboardsListPageV2/hooks/useSavedViews.ts

@@ -2,7 +2,6 @@ import { useCallback, useMemo } from 'react';
 import { useQueryClient } from 'react-query';
 import { toast } from '@signozhq/ui/sonner';
 import {
-	getListDashboardViewsQueryKey,
 	invalidateListDashboardViews,
 	useCreateDashboardView,
 	useDeleteDashboardView,
@@ -13,7 +12,6 @@ import {
 	type DashboardtypesDashboardViewDTO,
 	DashboardtypesListOrderDTO,
 	DashboardtypesListSortDTO,
-	type ListDashboardViews200,
 } from 'api/generated/services/sigNoz.schemas';
 
 import type { SavedView, SavedViewInput } from '../types';
@@ -72,27 +70,9 @@ export function useSavedViews(): UseSavedViewsResult {
 			},
 		},
 	});
-	// Rename/save-changes returns the updated view, so patch it into the cached
-	// list inline instead of refetching the whole list.
 	const updateMutation = useUpdateDashboardView({
 		mutation: {
-			onSuccess: (response): void => {
-				const updated = response?.data;
-				const key = getListDashboardViewsQueryKey();
-				const prev = queryClient.getQueryData<ListDashboardViews200>(key);
-				if (!updated || !prev) {
-					return;
-				}
-				queryClient.setQueryData<ListDashboardViews200>(key, {
-					...prev,
-					data: {
-						...prev.data,
-						views: (prev.data.views ?? []).map((v) =>
-							v.id === updated.id ? updated : v,
-						),
-					},
-				});
-			},
+			onSuccess: invalidate,
 			onError: (): void => {
 				toast.error('Failed to update view.');
 			},

frontend/src/pages/DashboardsListPageV2/utils/views.ts

@@ -1,7 +1,7 @@
 // Built-in view catalogue + the pure logic that maps a view to how it
-// constrains the list. Views fall into two mechanisms:
-//   - snapshot:  selecting applies a filter snapshot — some seed the search box
-//                with DSL (My dashboards → created_by; Locked → locked = true)
+// constrains the list. Views fall into three mechanisms:
+//   - snapshot:  selecting applies a filter snapshot (All, My dashboards, custom)
+//   - query:     contributes an extra server clause AND-ed with the chips (Locked)
 //   - client:    constrains by a client-side id set (Favorites, Recently viewed)
 import { Clock, Layers, Lock, Pin, User } from '@signozhq/icons';
 
@@ -49,9 +49,9 @@ export const BUILTIN_VIEWS: BuiltinView[] = [
 export const isClientView = (id: string): boolean =>
 	id === BuiltinViewId.Pinned || id === BuiltinViewId.Recent;
 
-// DSL the Locked view seeds into the search box, so the constraint is visible
-// (and editable) rather than applied invisibly behind the scenes.
-export const LOCKED_QUERY = 'locked = true';
+// Extra server query fragment a built-in view contributes (AND-ed with chips).
+export const builtinViewQuery = (id: string): string =>
+	id === BuiltinViewId.Locked ? 'locked = true' : '';
 
 // The canonical filter snapshot a built-in view applies when selected. `null`
 // for ids that aren't built-in (custom views carry their own snapshot).
@@ -65,11 +65,10 @@ export const builtinViewSnapshot = (
 				...DEFAULT_FILTER_STATE,
 				createdBy: userEmail ? [userEmail] : [],
 			};
-		case BuiltinViewId.Locked:
-			return { ...DEFAULT_FILTER_STATE, search: LOCKED_QUERY };
 		case BuiltinViewId.All:
 		case BuiltinViewId.Pinned:
 		case BuiltinViewId.Recent:
+		case BuiltinViewId.Locked:
 			return { ...DEFAULT_FILTER_STATE };
 		default:
 			return null;

frontend/src/pages/LogsExplorer/LogsExplorer.styles.scss

@@ -33,19 +33,15 @@
 	}
 
 	&.filter-visible {
-		// Width is owned by ResizableBox (inline style); this section is the
-		// ResizableBox root, so it stays position: relative for the drag handle.
 		.log-quick-filter-left-section {
+			width: 260px;
 			height: 100%;
 			overflow: visible;
 			min-height: 0;
+			position: relative;
 			z-index: 2;
-
-			.resizable-box__content {
-				display: flex;
-				flex-direction: column;
-				overflow: visible;
-			}
+			display: flex;
+			flex-direction: column;
 
 			.quick-filters-container {
 				flex: 1;
@@ -54,9 +50,7 @@
 		}
 
 		.log-module-right-section {
-			flex: 1;
-			width: auto;
-			min-width: 0;
+			width: calc(100% - 260px);
 		}
 	}
 }

frontend/src/pages/LogsExplorer/index.tsx

@@ -26,8 +26,6 @@ import {
 import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
 import { defaultTo, isEmpty, isNull } from 'lodash-es';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
-import { ResizableBox } from 'periscope/components/ResizableBox';
-import usePanelWidth from 'periscope/components/ResizableBox/usePanelWidth';
 import { EventSourceProvider } from 'providers/EventSource';
 import { Warning } from 'types/api';
 import { DataSource } from 'types/common/queryBuilder';
@@ -46,23 +44,9 @@ import { ExplorerViews } from './utils';
 
 import './LogsExplorer.styles.scss';
 
-const QUICK_FILTERS_DEFAULT_WIDTH = 260;
-const QUICK_FILTERS_MIN_WIDTH = 240;
-const QUICK_FILTERS_MAX_WIDTH = 500;
-
 function LogsExplorer(): JSX.Element {
 	const [showLiveLogs, setShowLiveLogs] = useState<boolean>(false);
 
-	const {
-		initialWidth: quickFiltersInitialWidth,
-		persistWidth: persistQuickFiltersWidth,
-	} = usePanelWidth({
-		storageKey: LOCALSTORAGE.QUICK_FILTERS_WIDTH_LOGS,
-		defaultWidth: QUICK_FILTERS_DEFAULT_WIDTH,
-		minWidth: QUICK_FILTERS_MIN_WIDTH,
-		maxWidth: QUICK_FILTERS_MAX_WIDTH,
-	});
-
 	// Get panel type from URL
 	const panelTypesFromUrl = useGetPanelTypesQueryParam(PANEL_TYPES.LIST);
 
@@ -242,25 +226,14 @@ function LogsExplorer(): JSX.Element {
 					className={cx('logs-module-page', showFilters ? 'filter-visible' : '')}
 				>
 					{showFilters && (
-						<ResizableBox
-							handle="right"
-							defaultWidth={QUICK_FILTERS_DEFAULT_WIDTH}
-							initialWidth={quickFiltersInitialWidth}
-							minWidth={QUICK_FILTERS_MIN_WIDTH}
-							maxWidth={QUICK_FILTERS_MAX_WIDTH}
-							onResize={persistQuickFiltersWidth}
-							resetToDefaultOnDoubleClick
-							withHandle
-							className="log-quick-filter-left-section"
-							handleTestId="quick-filters-resize-handle"
-						>
+						<section className={cx('log-quick-filter-left-section')}>
 							<QuickFilters
 								className="qf-logs-explorer"
 								signal={SignalType.LOGS}
 								source={QuickFiltersSource.LOGS_EXPLORER}
 								handleFilterVisibilityChange={handleFilterVisibilityChange}
 							/>
-						</ResizableBox>
+						</section>
 					)}
 					<section className={cx('log-module-right-section')}>
 						<Toolbar

frontend/src/periscope/components/ResizableBox/ResizableBox.styles.scss

@@ -18,17 +18,6 @@
 		z-index: 10;
 		background: var(--l2-border);
 
-		// Extend the interactive area beyond the 1px visual line so the handle
-		// is easy to grab and double-click, without changing its appearance.
-		&::before {
-			content: '';
-			position: absolute;
-			top: -4px;
-			right: -4px;
-			bottom: -4px;
-			left: -4px;
-		}
-
 		&:hover,
 		&:active {
 			background: var(--primary);
@@ -66,29 +55,4 @@
 			right: 0;
 		}
 	}
-
-	// Visible grip indicator (opt-in via the `withHandle` prop). Purely visual —
-	// pointer events fall through to the handle so it still owns drag + reset.
-	&__grip {
-		position: absolute;
-		top: 50%;
-		left: 50%;
-		transform: translate(-50%, -50%);
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		width: 14px;
-		height: 26px;
-		border: 1px solid var(--l2-border);
-		border-radius: 4px;
-		background: var(--l1-background);
-		color: var(--l2-foreground);
-		pointer-events: none;
-	}
-
-	&__handle:hover &__grip,
-	&__handle:active &__grip {
-		border-color: var(--primary);
-		color: var(--primary);
-	}
 }

frontend/src/periscope/components/ResizableBox/ResizableBox.tsx

@@ -1,4 +1,3 @@
-import { GripVertical } from '@signozhq/icons';
 import { useCallback, useRef, useState } from 'react';
 
 import './ResizableBox.styles.scss';
@@ -12,28 +11,15 @@ export interface ResizableBoxProps {
 	// resize (width). Dragging the handle away from the content grows the box;
 	// dragging it toward the content shrinks it.
 	handle?: ResizableBoxHandle;
-	// Canonical default size, and the target that double-click reset restores to.
 	defaultHeight?: number;
 	minHeight?: number;
 	maxHeight?: number;
 	defaultWidth?: number;
 	minWidth?: number;
 	maxWidth?: number;
-	// Starting size when different from the default (e.g. a persisted value).
-	// Falls back to defaultWidth/defaultHeight when omitted, preserving the
-	// behavior of callers that don't opt in.
-	initialWidth?: number;
-	initialHeight?: number;
-	// When true, double-clicking the handle resets the size to
-	// defaultWidth/defaultHeight and fires onResize with that value.
-	resetToDefaultOnDoubleClick?: boolean;
-	// When true, renders a visible grip indicator on the handle so it is
-	// discoverable as a draggable affordance.
-	withHandle?: boolean;
 	onResize?: (size: number) => void;
 	disabled?: boolean;
 	className?: string;
-	handleTestId?: string;
 }
 
 function ResizableBox({
@@ -45,22 +31,13 @@ function ResizableBox({
 	defaultWidth = 200,
 	minWidth = 50,
 	maxWidth = Infinity,
-	initialWidth,
-	initialHeight,
-	resetToDefaultOnDoubleClick = false,
-	withHandle = false,
 	onResize,
 	disabled = false,
 	className,
-	handleTestId,
 }: ResizableBoxProps): JSX.Element {
 	const isHorizontal = handle === 'left' || handle === 'right';
 	const isStartHandle = handle === 'top' || handle === 'left';
-	const [size, setSize] = useState(
-		isHorizontal
-			? (initialWidth ?? defaultWidth)
-			: (initialHeight ?? defaultHeight),
-	);
+	const [size, setSize] = useState(isHorizontal ? defaultWidth : defaultHeight);
 	const containerRef = useRef<HTMLDivElement>(null);
 
 	const handleMouseDown = useCallback(
@@ -106,21 +83,6 @@ function ResizableBox({
 		],
 	);
 
-	const handleDoubleClick = useCallback((): void => {
-		if (!resetToDefaultOnDoubleClick) {
-			return;
-		}
-		const nextSize = isHorizontal ? defaultWidth : defaultHeight;
-		setSize(nextSize);
-		onResize?.(nextSize);
-	}, [
-		resetToDefaultOnDoubleClick,
-		isHorizontal,
-		defaultWidth,
-		defaultHeight,
-		onResize,
-	]);
-
 	const containerStyle = disabled
 		? undefined
 		: isHorizontal
@@ -137,22 +99,7 @@ function ResizableBox({
 			style={containerStyle}
 		>
 			<div className="resizable-box__content">{children}</div>
-			{!disabled && (
-				<div
-					role="separator"
-					aria-orientation={isHorizontal ? 'vertical' : 'horizontal'}
-					className={handleClass}
-					onMouseDown={handleMouseDown}
-					onDoubleClick={handleDoubleClick}
-					data-testid={handleTestId}
-				>
-					{withHandle && (
-						<span className="resizable-box__grip">
-							<GripVertical size={12} />
-						</span>
-					)}
-				</div>
-			)}
+			{!disabled && <div className={handleClass} onMouseDown={handleMouseDown} />}
 		</div>
 	);
 }

frontend/src/periscope/components/ResizableBox/__tests__/ResizableBox.test.tsx

@@ -1,137 +0,0 @@
-import { fireEvent, render, screen } from '@testing-library/react';
-
-import ResizableBox from '../ResizableBox';
-
-const HANDLE_TEST_ID = 'resize-handle';
-
-describe('ResizableBox', () => {
-	it('starts at defaultWidth when initialWidth is omitted', () => {
-		render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-
-		const box = screen.getByTestId(HANDLE_TEST_ID).parentElement as HTMLElement;
-		expect(box.style.width).toBe('260px');
-	});
-
-	it('starts at initialWidth when provided', () => {
-		render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				initialWidth={340}
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-
-		const box = screen.getByTestId(HANDLE_TEST_ID).parentElement as HTMLElement;
-		expect(box.style.width).toBe('340px');
-	});
-
-	it('resets to defaultWidth and fires onResize on double-click when enabled', () => {
-		const onResize = jest.fn();
-		render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				initialWidth={480}
-				onResize={onResize}
-				resetToDefaultOnDoubleClick
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-
-		const handle = screen.getByTestId(HANDLE_TEST_ID);
-		const box = handle.parentElement as HTMLElement;
-		expect(box.style.width).toBe('480px');
-
-		fireEvent.doubleClick(handle);
-
-		expect(box.style.width).toBe('260px');
-		expect(onResize).toHaveBeenCalledWith(260);
-	});
-
-	it('does nothing on double-click when reset is not enabled', () => {
-		const onResize = jest.fn();
-		render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				initialWidth={480}
-				onResize={onResize}
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-
-		const handle = screen.getByTestId(HANDLE_TEST_ID);
-		const box = handle.parentElement as HTMLElement;
-
-		fireEvent.doubleClick(handle);
-
-		expect(box.style.width).toBe('480px');
-		expect(onResize).not.toHaveBeenCalled();
-	});
-
-	it('renders a visible grip only when withHandle is set', () => {
-		const { rerender, container } = render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-		expect(container.querySelector('.resizable-box__grip')).toBeNull();
-
-		rerender(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				withHandle
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-		expect(container.querySelector('.resizable-box__grip')).not.toBeNull();
-	});
-
-	it('clamps drag to maxWidth and reports the clamped size via onResize', () => {
-		const onResize = jest.fn();
-		render(
-			<ResizableBox
-				handle="right"
-				defaultWidth={260}
-				minWidth={240}
-				maxWidth={500}
-				onResize={onResize}
-				handleTestId={HANDLE_TEST_ID}
-			>
-				<div>content</div>
-			</ResizableBox>,
-		);
-
-		const handle = screen.getByTestId(HANDLE_TEST_ID);
-		const box = handle.parentElement as HTMLElement;
-
-		fireEvent.mouseDown(handle, { clientX: 0 });
-		fireEvent.mouseMove(document, { clientX: 1000 });
-		fireEvent.mouseUp(document);
-
-		expect(box.style.width).toBe('500px');
-		expect(onResize).toHaveBeenLastCalledWith(500);
-	});
-});

frontend/src/periscope/components/ResizableBox/__tests__/usePanelWidth.test.ts

@@ -1,89 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import getLocalStorageKey from 'api/browser/localstorage/get';
-import setLocalStorageKey from 'api/browser/localstorage/set';
-import { LOCALSTORAGE } from 'constants/localStorage';
-
-import usePanelWidth from '../usePanelWidth';
-
-jest.mock('api/browser/localstorage/get');
-jest.mock('api/browser/localstorage/set');
-
-const mockedGet = getLocalStorageKey as jest.MockedFunction<
-	typeof getLocalStorageKey
->;
-const mockedSet = setLocalStorageKey as jest.MockedFunction<
-	typeof setLocalStorageKey
->;
-
-const ARGS = {
-	storageKey: LOCALSTORAGE.QUICK_FILTERS_WIDTH_LOGS,
-	defaultWidth: 260,
-	minWidth: 240,
-	maxWidth: 500,
-};
-
-describe('usePanelWidth', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		jest.useFakeTimers();
-	});
-
-	afterEach(() => {
-		jest.runOnlyPendingTimers();
-		jest.useRealTimers();
-	});
-
-	it('returns defaultWidth when nothing is persisted', () => {
-		mockedGet.mockReturnValue(null);
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-		expect(result.current.initialWidth).toBe(260);
-	});
-
-	it('returns the persisted width when present', () => {
-		mockedGet.mockReturnValue('340');
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-		expect(result.current.initialWidth).toBe(340);
-	});
-
-	it('clamps an out-of-bounds persisted width on read', () => {
-		mockedGet.mockReturnValue('9999');
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-		expect(result.current.initialWidth).toBe(500);
-	});
-
-	it('falls back to defaultWidth for an invalid persisted value', () => {
-		mockedGet.mockReturnValue('not-a-number');
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-		expect(result.current.initialWidth).toBe(260);
-	});
-
-	it('persists a clamped width (debounced)', () => {
-		mockedGet.mockReturnValue(null);
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-
-		act(() => {
-			result.current.persistWidth(320);
-			jest.advanceTimersByTime(200);
-		});
-
-		expect(mockedSet).toHaveBeenCalledWith(
-			LOCALSTORAGE.QUICK_FILTERS_WIDTH_LOGS,
-			'320',
-		);
-	});
-
-	it('clamps below-min widths before persisting', () => {
-		mockedGet.mockReturnValue(null);
-		const { result } = renderHook(() => usePanelWidth(ARGS));
-
-		act(() => {
-			result.current.persistWidth(10);
-			jest.advanceTimersByTime(200);
-		});
-
-		expect(mockedSet).toHaveBeenCalledWith(
-			LOCALSTORAGE.QUICK_FILTERS_WIDTH_LOGS,
-			'240',
-		);
-	});
-});

frontend/src/periscope/components/ResizableBox/usePanelWidth.ts

@@ -1,68 +0,0 @@
-import getLocalStorageKey from 'api/browser/localstorage/get';
-import setLocalStorageKey from 'api/browser/localstorage/set';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import debounce from 'lodash-es/debounce';
-import { useCallback, useMemo, useRef } from 'react';
-
-const PERSIST_DEBOUNCE_MS = 150;
-
-interface UsePanelWidthArgs {
-	/** Per-page localStorage key the width is persisted under. */
-	storageKey: LOCALSTORAGE;
-	/** Canonical default width, used when nothing is persisted. */
-	defaultWidth: number;
-	minWidth: number;
-	maxWidth: number;
-}
-
-interface UsePanelWidthReturn {
-	/** Width to start from: the persisted value (clamped) or the default. */
-	initialWidth: number;
-	/** Clamp and persist a width. Debounced to avoid a write per mousemove. */
-	persistWidth: (width: number) => void;
-}
-
-const clamp = (value: number, min: number, max: number): number =>
-	Math.min(max, Math.max(min, value));
-
-/**
- * Per-page localStorage persistence for a resizable panel width. Mirrors the
- * getLocalStorageKey/setLocalStorageKey idiom used for the trace span-details
- * panel position. Pairs with ResizableBox: feed initialWidth into its
- * initialWidth prop and persistWidth into its onResize.
- */
-function usePanelWidth({
-	storageKey,
-	defaultWidth,
-	minWidth,
-	maxWidth,
-}: UsePanelWidthArgs): UsePanelWidthReturn {
-	// Read once on mount. Kept in a ref so a re-render doesn't re-read storage.
-	const initialWidthRef = useRef<number | null>(null);
-	if (initialWidthRef.current === null) {
-		const stored = getLocalStorageKey(storageKey);
-		const parsed = stored !== null && stored !== '' ? Number(stored) : NaN;
-		initialWidthRef.current = Number.isFinite(parsed)
-			? clamp(parsed, minWidth, maxWidth)
-			: defaultWidth;
-	}
-
-	const debouncedWrite = useMemo(
-		() =>
-			debounce((width: number): void => {
-				setLocalStorageKey(storageKey, String(width));
-			}, PERSIST_DEBOUNCE_MS),
-		[storageKey],
-	);
-
-	const persistWidth = useCallback(
-		(width: number): void => {
-			debouncedWrite(clamp(width, minWidth, maxWidth));
-		},
-		[debouncedWrite, minWidth, maxWidth],
-	);
-
-	return { initialWidth: initialWidthRef.current, persistWidth };
-}
-
-export default usePanelWidth;

frontend/src/utils/__tests__/linkifyText.test.tsx

@@ -1,66 +0,0 @@
-import { render, screen } from '@testing-library/react';
-
-import { linkifyText } from '../linkifyText';
-
-describe('linkifyText', () => {
-	it('returns plain text unchanged when there are no links', () => {
-		render(<div>{linkifyText('just a plain description')}</div>);
-
-		expect(screen.getByText('just a plain description')).toBeInTheDocument();
-		expect(screen.queryByRole('link')).not.toBeInTheDocument();
-	});
-
-	it('wraps an http(s) URL in an anchor that opens in a new tab', () => {
-		render(<div>{linkifyText('see https://signoz.io/docs for more')}</div>);
-
-		const link = screen.getByRole('link', { name: 'https://signoz.io/docs' });
-		expect(link).toHaveAttribute('href', 'https://signoz.io/docs');
-		expect(link).toHaveAttribute('target', '_blank');
-		expect(link).toHaveAttribute('rel', 'noopener noreferrer');
-	});
-
-	it('prefixes bare www. links with https://', () => {
-		render(<div>{linkifyText('visit www.signoz.io')}</div>);
-
-		const link = screen.getByRole('link', { name: 'www.signoz.io' });
-		expect(link).toHaveAttribute('href', 'https://www.signoz.io');
-	});
-
-	it('keeps trailing punctuation outside the link', () => {
-		render(<div>{linkifyText('read https://signoz.io.')}</div>);
-
-		const link = screen.getByRole('link', { name: 'https://signoz.io' });
-		expect(link).toHaveAttribute('href', 'https://signoz.io');
-	});
-
-	it('linkifies multiple URLs in the same string', () => {
-		render(
-			<div>{linkifyText('a https://one.com and b https://two.com end')}</div>,
-		);
-
-		expect(screen.getAllByRole('link')).toHaveLength(2);
-		expect(
-			screen.getByRole('link', { name: 'https://one.com' }),
-		).toBeInTheDocument();
-		expect(
-			screen.getByRole('link', { name: 'https://two.com' }),
-		).toBeInTheDocument();
-	});
-
-	it('preserves newlines around a link', () => {
-		const { container } = render(
-			<div>{linkifyText('line one\nsee https://signoz.io\nline three')}</div>,
-		);
-
-		expect(container.textContent).toBe(
-			'line one\nsee https://signoz.io\nline three',
-		);
-		expect(
-			screen.getByRole('link', { name: 'https://signoz.io' }),
-		).toHaveAttribute('href', 'https://signoz.io');
-	});
-
-	it('returns an empty string unchanged', () => {
-		expect(linkifyText('')).toBe('');
-	});
-});

frontend/src/utils/linkifyText.tsx

@@ -1,71 +0,0 @@
-import { Fragment, MouseEvent, ReactNode } from 'react';
-
-/** Matches http(s) URLs and bare www. links up to the next whitespace. */
-const URL_REGEX = /((?:https?:\/\/|www\.)[^\s]+)/gi;
-/** Trailing punctuation that is almost never part of the intended URL. */
-const TRAILING_PUNCTUATION = /[.,;:!?)\]}'"]+$/;
-
-const stopPropagation = (
-	event: MouseEvent<HTMLAnchorElement, globalThis.MouseEvent>,
-): void => {
-	// Prevent parent click listeners (e.g. title edit) from firing.
-	event.stopPropagation();
-};
-
-/**
- * Splits `text` into plain-text and anchor segments, wrapping any detected
- * URL in an anchor that opens in a new tab. Trailing punctuation is kept
- * outside the link so sentences like "see https://signoz.io." stay clean.
- */
-export function linkifyText(text: string): ReactNode {
-	if (!text) {
-		return text;
-	}
-
-	const segments: ReactNode[] = [];
-	let lastIndex = 0;
-	let key = 0;
-
-	const matches = text.matchAll(URL_REGEX);
-	for (const match of matches) {
-		const matchStart = match.index ?? 0;
-		const rawUrl = match[0];
-
-		const trailing = rawUrl.match(TRAILING_PUNCTUATION)?.[0] ?? '';
-		const url = trailing ? rawUrl.slice(0, -trailing.length) : rawUrl;
-		const href = url.startsWith('www.') ? `https://${url}` : url;
-
-		if (matchStart > lastIndex) {
-			segments.push(
-				<Fragment key={key}>{text.slice(lastIndex, matchStart)}</Fragment>,
-			);
-			key += 1;
-		}
-
-		segments.push(
-			<a
-				key={key}
-				href={href}
-				rel="noopener noreferrer"
-				target="_blank"
-				onClick={stopPropagation}
-			>
-				{url}
-			</a>,
-		);
-		key += 1;
-
-		if (trailing) {
-			segments.push(<Fragment key={key}>{trailing}</Fragment>);
-			key += 1;
-		}
-
-		lastIndex = matchStart + rawUrl.length;
-	}
-
-	if (lastIndex < text.length) {
-		segments.push(<Fragment key={key}>{text.slice(lastIndex)}</Fragment>);
-	}
-
-	return segments;
-}

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -17,7 +17,6 @@ import (
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"golang.org/x/sync/errgroup"
 )
 
 type module struct {
@@ -214,37 +213,23 @@ func (m *module) ListHosts(ctx context.Context, orgID valuer.UUID, req *inframon
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, hostsFilterExpr, req.GroupBy, pageGroups, m.newListHostsQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
 	// Compute per-group active/inactive host counts.
 	// When host.name is in groupBy, each row = one host, so counts are derived
 	// directly from activeHostsMap in buildHostRecords (no extra query needed).
 	// When host.name is not in groupBy, we need to run an additional query to get the counts per group for the current page,
 	// using the same filter expression as the main query (including user filters + page groups IN clause).
+	hostCounts := make(map[string]groupHostStatusCounts)
 	isHostNameInGroupBy := isKeyInGroupByAttrs(req.GroupBy, inframonitoringtypes.HostNameAttrKey)
-
-	var (
-		queryResp  *qbtypes.QueryRangeResponse
-		hostCounts = make(map[string]groupHostStatusCounts)
-	)
-
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-
 	if !isHostNameInGroupBy {
-		g.Go(func() error {
-			var err error
-			hostCounts, err = m.getPerGroupHostStatusCounts(gCtx, orgID, req, hostsTableMetricNamesList, pageGroups, sinceUnixMilli)
-			return err
-		})
-	}
-
-	if err := g.Wait(); err != nil {
-		return nil, err
+		hostCounts, err = m.getPerGroupHostStatusCounts(ctx, orgID, req, hostsTableMetricNamesList, pageGroups, sinceUnixMilli)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	resp.Records = buildHostRecords(isHostNameInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, activeHostsMap, hostCounts)
@@ -314,39 +299,23 @@ func (m *module) ListPods(ctx context.Context, orgID valuer.UUID, req *inframoni
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newPodsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
-	var (
-		queryResp     *qbtypes.QueryRangeResponse
-		phaseCounts   map[string]podPhaseCounts
-		statusCounts  map[string]podStatusCounts
-		statusWarning *qbtypes.QueryWarnData
-		restartCounts map[string]int64
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
+	statusCounts, statusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		statusCounts, statusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		restartCounts, err = m.getPerGroupPodRestartCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	restartCounts, err := m.getPerGroupPodRestartCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -418,39 +387,23 @@ func (m *module) ListNodes(ctx context.Context, orgID valuer.UUID, req *inframon
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newNodesTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
-	var (
-		queryResp           *qbtypes.QueryRangeResponse
-		nodeConditionCounts map[string]nodeConditionCounts
-		podPhaseCounts      map[string]podPhaseCounts
-		podStatusCounts     map[string]podStatusCounts
-		podStatusWarning    *qbtypes.QueryWarnData
-	)
+	nodeConditionCounts, err := m.getPerGroupNodeConditionCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
+	podPhaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		nodeConditionCounts, err = m.getPerGroupNodeConditionCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podPhaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -522,33 +475,18 @@ func (m *module) ListNamespaces(ctx context.Context, orgID valuer.UUID, req *inf
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newNamespacesTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
-	var (
-		queryResp        *qbtypes.QueryRangeResponse
-		phaseCounts      map[string]podPhaseCounts
-		podStatusCounts  map[string]podStatusCounts
-		podStatusWarning *qbtypes.QueryWarnData
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -619,41 +557,25 @@ func (m *module) ListClusters(ctx context.Context, orgID valuer.UUID, req *infra
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newClustersTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
 	// With default groupBy [k8s.cluster.name], counts are bucketed per cluster;
 	// with a custom groupBy, they aggregate across clusters in that group.
-	var (
-		queryResp              *qbtypes.QueryRangeResponse
-		nodeConditionCountsMap map[string]nodeConditionCounts
-		podPhaseCountsMap      map[string]podPhaseCounts
-		podStatusCounts        map[string]podStatusCounts
-		podStatusWarning       *qbtypes.QueryWarnData
-	)
+	nodeConditionCountsMap, err := m.getPerGroupNodeConditionCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
+	podPhaseCountsMap, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		nodeConditionCountsMap, err = m.getPerGroupNodeConditionCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podPhaseCountsMap, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -808,33 +730,18 @@ func (m *module) ListDeployments(ctx context.Context, orgID valuer.UUID, req *in
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newDeploymentsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
-	var (
-		queryResp        *qbtypes.QueryRangeResponse
-		phaseCounts      map[string]podPhaseCounts
-		podStatusCounts  map[string]podStatusCounts
-		podStatusWarning *qbtypes.QueryWarnData
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -911,35 +818,20 @@ func (m *module) ListStatefulSets(ctx context.Context, orgID valuer.UUID, req *i
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newStatefulSetsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
 	// Pods owned by a StatefulSet carry k8s.statefulset.name as a resource attribute,
 	// so default-groupBy gives per-statefulset phase counts automatically.
-	var (
-		queryResp        *qbtypes.QueryRangeResponse
-		phaseCounts      map[string]podPhaseCounts
-		podStatusCounts  map[string]podStatusCounts
-		podStatusWarning *qbtypes.QueryWarnData
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -1016,35 +908,20 @@ func (m *module) ListJobs(ctx context.Context, orgID valuer.UUID, req *inframoni
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newJobsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
 	// Pods owned by a Job carry k8s.job.name as a resource attribute, so default-groupBy
 	// gives per-job phase counts automatically.
-	var (
-		queryResp        *qbtypes.QueryRangeResponse
-		phaseCounts      map[string]podPhaseCounts
-		podStatusCounts  map[string]podStatusCounts
-		podStatusWarning *qbtypes.QueryWarnData
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 
@@ -1121,35 +998,20 @@ func (m *module) ListDaemonSets(ctx context.Context, orgID valuer.UUID, req *inf
 	}
 
 	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newDaemonSetsTableListQuery())
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
 
 	// Pods owned by a DaemonSet carry k8s.daemonset.name as a resource attribute,
 	// so default-groupBy gives per-daemonset phase counts automatically.
-	var (
-		queryResp        *qbtypes.QueryRangeResponse
-		phaseCounts      map[string]podPhaseCounts
-		podStatusCounts  map[string]podStatusCounts
-		podStatusWarning *qbtypes.QueryWarnData
-	)
+	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
+		return nil, err
+	}
 
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(func() error {
-		var err error
-		queryResp, err = m.querier.QueryRange(gCtx, orgID, fullQueryReq)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		phaseCounts, err = m.getPerGroupPodPhaseCounts(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-	g.Go(func() error {
-		var err error
-		podStatusCounts, podStatusWarning, err = m.getPerGroupPodStatusCountsWithReqMetricChecks(gCtx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
+	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
+	if err != nil {
 		return nil, err
 	}
 

pkg/querier/config.go

@@ -7,8 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 )
 
-const DefaultMaxConcurrentQueries = 8
-
 type SkipResourceFingerprint struct {
 	Enabled bool `yaml:"enabled" mapstructure:"enabled"`
 	// If count of fingerprint is above threshold, skip the fingerprint subquery and filter on main table instead.
@@ -39,7 +37,7 @@ func newConfig() factory.Config {
 		// Default values
 		CacheTTL:             168 * time.Hour,
 		FluxInterval:         5 * time.Minute,
-		MaxConcurrentQueries: DefaultMaxConcurrentQueries,
+		MaxConcurrentQueries: 4,
 		SkipResourceFingerprint: SkipResourceFingerprint{
 			Enabled:   false,
 			Threshold: 100000,

pkg/querier/querier.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/dustin/go-humanize"
 	"golang.org/x/exp/maps"
-	"golang.org/x/sync/errgroup"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
@@ -36,21 +35,20 @@ var (
 )
 
 type querier struct {
-	logger                   *slog.Logger
-	fl                       flagger.Flagger
-	telemetryStore           telemetrystore.TelemetryStore
-	metadataStore            telemetrytypes.MetadataStore
-	promEngine               prometheus.Prometheus
-	traceStmtBuilder         qbtypes.StatementBuilder[qbtypes.TraceAggregation]
-	logStmtBuilder           qbtypes.StatementBuilder[qbtypes.LogAggregation]
-	auditStmtBuilder         qbtypes.StatementBuilder[qbtypes.LogAggregation]
-	metricStmtBuilder        qbtypes.StatementBuilder[qbtypes.MetricAggregation]
-	meterStmtBuilder         qbtypes.StatementBuilder[qbtypes.MetricAggregation]
-	traceOperatorStmtBuilder qbtypes.TraceOperatorStatementBuilder
-	bucketCache              BucketCache
-	liveDataRefresh          time.Duration
-	builderConfig            builderConfig
-	maxConcurrentQueries     int
+	logger                    *slog.Logger
+	fl                        flagger.Flagger
+	telemetryStore            telemetrystore.TelemetryStore
+	metadataStore             telemetrytypes.MetadataStore
+	promEngine                prometheus.Prometheus
+	traceStmtBuilder          qbtypes.StatementBuilder[qbtypes.TraceAggregation]
+	logStmtBuilder            qbtypes.StatementBuilder[qbtypes.LogAggregation]
+	auditStmtBuilder          qbtypes.StatementBuilder[qbtypes.LogAggregation]
+	metricStmtBuilder         qbtypes.StatementBuilder[qbtypes.MetricAggregation]
+	meterStmtBuilder          qbtypes.StatementBuilder[qbtypes.MetricAggregation]
+	traceOperatorStmtBuilder  qbtypes.TraceOperatorStatementBuilder
+	bucketCache               BucketCache
+	liveDataRefresh           time.Duration
+	builderConfig             builderConfig
 }
 
 var _ Querier = (*querier)(nil)
@@ -69,30 +67,25 @@ func New(
 	bucketCache BucketCache,
 	flagger flagger.Flagger,
 	logTraceIDWindowPadding time.Duration,
-	maxConcurrentQueries int,
 ) *querier {
 	querierSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/querier")
-	if maxConcurrentQueries <= 0 {
-		maxConcurrentQueries = DefaultMaxConcurrentQueries
-	}
 	return &querier{
-		logger:                   querierSettings.Logger(),
-		fl:                       flagger,
-		telemetryStore:           telemetryStore,
-		metadataStore:            metadataStore,
-		promEngine:               promEngine,
-		traceStmtBuilder:         traceStmtBuilder,
-		logStmtBuilder:           logStmtBuilder,
-		auditStmtBuilder:         auditStmtBuilder,
-		metricStmtBuilder:        metricStmtBuilder,
-		meterStmtBuilder:         meterStmtBuilder,
-		traceOperatorStmtBuilder: traceOperatorStmtBuilder,
-		bucketCache:              bucketCache,
-		liveDataRefresh:          5 * time.Second,
+		logger:                    querierSettings.Logger(),
+		fl:                        flagger,
+		telemetryStore:            telemetryStore,
+		metadataStore:             metadataStore,
+		promEngine:                promEngine,
+		traceStmtBuilder:          traceStmtBuilder,
+		logStmtBuilder:            logStmtBuilder,
+		auditStmtBuilder:          auditStmtBuilder,
+		metricStmtBuilder:         metricStmtBuilder,
+		meterStmtBuilder:          meterStmtBuilder,
+		traceOperatorStmtBuilder:  traceOperatorStmtBuilder,
+		bucketCache:               bucketCache,
+		liveDataRefresh:           5 * time.Second,
 		builderConfig: builderConfig{
 			logTraceIDWindowPaddingMS: uint64(logTraceIDWindowPadding.Milliseconds()),
 		},
-		maxConcurrentQueries: maxConcurrentQueries,
 	}
 }
 
@@ -614,40 +607,30 @@ func (q *querier) run(
 		return false
 	}
 
-	names := maps.Keys(qs)
-	slices.Sort(names)
-	queryResults := make([]*qbtypes.Result, len(names))
-
-	// sem limits how many queries run at once for this request. The same
-	// limit covers the missing-range queries in executeWithCache. sem is held
-	// only while a query is running, never while waiting for other
-	// goroutines, so the two levels cannot deadlock.
-	sem := make(chan struct{}, q.maxConcurrentQueries)
-
-	eg, egCtx := errgroup.WithContext(ctx)
-	for i, name := range names {
-		query := qs[name]
-		eg.Go(func() error {
-			// Skip cache if NoCache is set, or if cache is not available
-			if req.NoCache || q.bucketCache == nil || query.Fingerprint() == "" {
-				if req.NoCache {
-					q.logger.DebugContext(egCtx, "NoCache flag set, bypassing cache", slog.String("query", name))
-				} else {
-					q.logger.InfoContext(egCtx, "no bucket cache or fingerprint, executing query", slog.String("fingerprint", query.Fingerprint()))
-				}
-				sem <- struct{}{}
-				result, err := query.Execute(egCtx)
-				<-sem
-				if err != nil {
-					return err
-				}
-				queryResults[i] = result
-				return nil
+	for name, query := range qs {
+		// Skip cache if NoCache is set, or if cache is not available
+		if req.NoCache || q.bucketCache == nil || query.Fingerprint() == "" {
+			if req.NoCache {
+				q.logger.DebugContext(ctx, "NoCache flag set, bypassing cache", slog.String("query", name))
+			} else {
+				q.logger.InfoContext(ctx, "no bucket cache or fingerprint, executing query", slog.String("fingerprint", query.Fingerprint()))
 			}
-
-			result, err := q.executeWithCache(egCtx, orgID, query, steps[name], sem)
+			result, err := query.Execute(ctx)
+			qbEvent.HasData = qbEvent.HasData || hasData(result)
 			if err != nil {
-				return err
+				return nil, err
+			}
+			results[name] = result.Value
+			warnings = append(warnings, result.Warnings...)
+			warningsDocURL = result.WarningsDocURL
+			stats.RowsScanned += result.Stats.RowsScanned
+			stats.BytesScanned += result.Stats.BytesScanned
+			stats.DurationMS += result.Stats.DurationMS
+		} else {
+			result, err := q.executeWithCache(ctx, orgID, query, steps[name], req.NoCache)
+			qbEvent.HasData = qbEvent.HasData || hasData(result)
+			if err != nil {
+				return nil, err
 			}
 			switch v := result.Value.(type) {
 			case *qbtypes.TimeSeriesData:
@@ -657,23 +640,14 @@ func (q *querier) run(
 			case *qbtypes.RawData:
 				v.QueryName = name
 			}
-			queryResults[i] = result
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return nil, err
-	}
 
-	for i, name := range names {
-		result := queryResults[i]
-		qbEvent.HasData = qbEvent.HasData || hasData(result)
-		results[name] = result.Value
-		warnings = append(warnings, result.Warnings...)
-		warningsDocURL = result.WarningsDocURL
-		stats.RowsScanned += result.Stats.RowsScanned
-		stats.BytesScanned += result.Stats.BytesScanned
-		stats.DurationMS += result.Stats.DurationMS
+			results[name] = result.Value
+			warnings = append(warnings, result.Warnings...)
+			warningsDocURL = result.WarningsDocURL
+			stats.RowsScanned += result.Stats.RowsScanned
+			stats.BytesScanned += result.Stats.BytesScanned
+			stats.DurationMS += result.Stats.DurationMS
+		}
 	}
 
 	gomaps.Copy(results, preseededResults)
@@ -733,9 +707,8 @@ func (q *querier) run(
 	return resp, nil
 }
 
-// executeWithCache executes a query using the bucket cache. sem limits how
-// many queries run at once for the whole request.
-func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query qbtypes.Query, step qbtypes.Step, sem chan struct{}) (*qbtypes.Result, error) {
+// executeWithCache executes a query using the bucket cache.
+func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query qbtypes.Query, step qbtypes.Step, _ bool) (*qbtypes.Result, error) {
 	// Get cached data and missing ranges
 	cachedResult, missingRanges := q.bucketCache.GetMissRanges(ctx, orgID, query, step)
 
@@ -748,9 +721,7 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 	if cachedResult == nil && len(missingRanges) == 1 {
 		startMs, endMs := query.Window()
 		if missingRanges[0].From == startMs && missingRanges[0].To == endMs {
-			sem <- struct{}{}
 			result, err := query.Execute(ctx)
-			<-sem
 			if err != nil {
 				return nil, err
 			}
@@ -769,6 +740,7 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 		slog.Int("missing_ranges_count", len(missingRanges)),
 		slog.Any("ranges", missingRanges))
 
+	sem := make(chan struct{}, 4)
 	var wg sync.WaitGroup
 
 	for i, timeRange := range missingRanges {
@@ -805,9 +777,7 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 		if err != nil {
 			// If any query failed, fall back to full execution
 			q.logger.ErrorContext(ctx, "parallel query execution failed", errors.Attr(err))
-			sem <- struct{}{}
 			result, err := query.Execute(ctx)
-			<-sem
 			if err != nil {
 				return nil, err
 			}

pkg/querier/querier_test.go

@@ -2,13 +2,11 @@ package querier
 
 import (
 	"context"
-	"sync/atomic"
 	"testing"
 	"time"
 
 	cmock "github.com/SigNoz/clickhouse-go-mock"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
@@ -56,8 +54,7 @@ func TestQueryRange_MetricTypeMissing(t *testing.T) {
 		nil,                // traceOperatorStmtBuilder
 		nil,                // bucketCache
 		flaggertest.New(t), // flagger
-		0,                  // logTraceIDWindowPadding
-		0,                  // maxConcurrentQueries
+		0,
 	)
 
 	req := &qbtypes.QueryRangeRequest{
@@ -128,8 +125,7 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {
 		nil,                      // traceOperatorStmtBuilder
 		nil,                      // bucketCache
 		flaggertest.New(t),       // flagger
-		0,                        // logTraceIDWindowPadding
-		0,                        // maxConcurrentQueries
+		0,
 	)
 
 	req := &qbtypes.QueryRangeRequest{
@@ -159,149 +155,3 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, resp)
 }
-
-type fakeQuery struct {
-	execute func(ctx context.Context) (*qbtypes.Result, error)
-}
-
-func (f *fakeQuery) Fingerprint() string                                  { return "" }
-func (f *fakeQuery) Window() (uint64, uint64)                             { return 0, 0 }
-func (f *fakeQuery) Execute(ctx context.Context) (*qbtypes.Result, error) { return f.execute(ctx) }
-
-func chQueryEnvelopes(names []string) []qbtypes.QueryEnvelope {
-	envelopes := make([]qbtypes.QueryEnvelope, 0, len(names))
-	for _, name := range names {
-		envelopes = append(envelopes, qbtypes.QueryEnvelope{
-			Type: qbtypes.QueryTypeClickHouseSQL,
-			Spec: qbtypes.ClickHouseQuery{Name: name},
-		})
-	}
-	return envelopes
-}
-
-func TestRunExecutesQueriesConcurrently(t *testing.T) {
-	names := []string{"A", "B", "C", "D", "E"}
-	numQueries := len(names)
-
-	q := &querier{
-		logger:               instrumentationtest.New().Logger(),
-		maxConcurrentQueries: numQueries,
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	var started atomic.Int32
-	allStarted := make(chan struct{})
-
-	qs := make(map[string]qbtypes.Query, numQueries)
-	for _, name := range names {
-		qs[name] = &fakeQuery{execute: func(ctx context.Context) (*qbtypes.Result, error) {
-			if int(started.Add(1)) == numQueries {
-				close(allStarted)
-			}
-			select {
-			case <-allStarted:
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			}
-			return &qbtypes.Result{
-				Type:  qbtypes.RequestTypeScalar,
-				Value: &qbtypes.ScalarData{QueryName: name},
-				Stats: qbtypes.ExecStats{RowsScanned: 1, BytesScanned: 2, DurationMS: 3},
-			}, nil
-		}}
-	}
-
-	req := &qbtypes.QueryRangeRequest{
-		RequestType:    qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{Queries: chQueryEnvelopes(names)},
-	}
-	resp, err := q.run(ctx, valuer.GenerateUUID(), qs, req, nil, &qbtypes.QBEvent{}, nil)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Len(t, resp.Data.Results, numQueries)
-	assert.Equal(t, uint64(numQueries), resp.Meta.RowsScanned)
-	assert.Equal(t, uint64(2*numQueries), resp.Meta.BytesScanned)
-	assert.Equal(t, uint64(3*numQueries), resp.Meta.DurationMS)
-}
-
-func TestRunRespectsMaxConcurrentQueries(t *testing.T) {
-	const limit = 2
-	names := []string{"A", "B", "C", "D", "E", "F", "G", "H"}
-
-	q := &querier{
-		logger:               instrumentationtest.New().Logger(),
-		maxConcurrentQueries: limit,
-	}
-
-	var running, maxRunning atomic.Int32
-	qs := make(map[string]qbtypes.Query, len(names))
-	for _, name := range names {
-		qs[name] = &fakeQuery{execute: func(ctx context.Context) (*qbtypes.Result, error) {
-			cur := running.Add(1)
-			defer running.Add(-1)
-			for {
-				m := maxRunning.Load()
-				if cur <= m || maxRunning.CompareAndSwap(m, cur) {
-					break
-				}
-			}
-			time.Sleep(20 * time.Millisecond)
-			return &qbtypes.Result{
-				Type:  qbtypes.RequestTypeScalar,
-				Value: &qbtypes.ScalarData{QueryName: name},
-			}, nil
-		}}
-	}
-
-	req := &qbtypes.QueryRangeRequest{
-		RequestType:    qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{Queries: chQueryEnvelopes(names)},
-	}
-	resp, err := q.run(context.Background(), valuer.GenerateUUID(), qs, req, nil, &qbtypes.QBEvent{}, nil)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Len(t, resp.Data.Results, len(names))
-	assert.LessOrEqual(t, maxRunning.Load(), int32(limit), "running queries must not exceed maxConcurrentQueries")
-}
-
-func TestRunQueryErrorCancelsSiblings(t *testing.T) {
-	q := &querier{
-		logger:               instrumentationtest.New().Logger(),
-		maxConcurrentQueries: 4,
-	}
-
-	bStarted := make(chan struct{})
-	var bCanceled atomic.Bool
-
-	qs := map[string]qbtypes.Query{
-		// fails once B is running.
-		"A": &fakeQuery{execute: func(ctx context.Context) (*qbtypes.Result, error) {
-			select {
-			case <-bStarted:
-			case <-ctx.Done():
-			}
-			return nil, errors.NewInternalf(errors.CodeInternal, "query A failed")
-		}},
-		// blocks until its context is canceled by A's failure.
-		"B": &fakeQuery{execute: func(ctx context.Context) (*qbtypes.Result, error) {
-			close(bStarted)
-			select {
-			case <-ctx.Done():
-				bCanceled.Store(true)
-				return nil, ctx.Err()
-			case <-time.After(10 * time.Second):
-				return nil, errors.NewInternalf(errors.CodeInternal, "query B was never canceled")
-			}
-		}},
-	}
-
-	req := &qbtypes.QueryRangeRequest{
-		RequestType:    qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{Queries: chQueryEnvelopes([]string{"A", "B"})},
-	}
-	_, err := q.run(context.Background(), valuer.GenerateUUID(), qs, req, nil, &qbtypes.QBEvent{}, nil)
-	require.ErrorContains(t, err, "query A failed")
-	assert.True(t, bCanceled.Load(), "query B should be canceled once query A fails")
-}

pkg/querier/signozquerier/provider.go

@@ -193,6 +193,5 @@ func newProvider(
 		bucketCache,
 		flagger,
 		cfg.LogTraceIDWindowPadding,
-		cfg.MaxConcurrentQueries,
 	), nil
 }

pkg/query-service/rules/setups_test.go

@@ -56,7 +56,6 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Teleme
 		nil, // bucketCache
 		flagger,
 		0,
-		0, // maxConcurrentQueries (0 means default)
 	), metadataStore
 }
 
@@ -111,7 +110,6 @@ func prepareQuerierForLogs(t *testing.T, telemetryStore telemetrystore.Telemetry
 		nil,            // bucketCache
 		fl,
 		5*time.Minute, // logTraceIDWindowPadding
-		0,             // maxConcurrentQueries (0 means default)
 	)
 }
 
@@ -160,6 +158,5 @@ func prepareQuerierForTraces(t *testing.T, telemetryStore telemetrystore.Telemet
 		nil,              // bucketCache
 		fl,
 		0,
-		0, // maxConcurrentQueries (0 means default)
 	)
 }

pkg/transition/migrate_common.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 )
 
 type migrateCommon struct {
@@ -23,119 +24,10 @@ func NewMigrateCommon(logger *slog.Logger) *migrateCommon {
 	}
 }
 
+// WrapInV5Envelope delegates to querybuildertypesv5.WrapInV5Envelope; the
+// transform is stateless and shared with the v1→v2 dashboard conversion.
 func (migration *migrateCommon) WrapInV5Envelope(name string, queryMap map[string]any, queryType string) map[string]any {
-	// Create a properly structured v5 query
-	v5Query := map[string]any{
-		"name":     name,
-		"disabled": queryMap["disabled"],
-		"legend":   queryMap["legend"],
-	}
-
-	if name != queryMap["expression"] {
-		// formula
-		queryType = "builder_formula"
-		v5Query["expression"] = queryMap["expression"]
-		if functions, ok := queryMap["functions"]; ok {
-			v5Query["functions"] = functions
-		}
-		return map[string]any{
-			"type": queryType,
-			"spec": v5Query,
-		}
-	}
-
-	// Add signal based on data source
-	if dataSource, ok := queryMap["dataSource"].(string); ok {
-		switch dataSource {
-		case "traces":
-			v5Query["signal"] = "traces"
-		case "logs":
-			v5Query["signal"] = "logs"
-		case "metrics":
-			v5Query["signal"] = "metrics"
-		}
-	}
-
-	if stepInterval, ok := queryMap["stepInterval"]; ok {
-		v5Query["stepInterval"] = stepInterval
-	}
-
-	if aggregations, ok := queryMap["aggregations"]; ok {
-		v5Query["aggregations"] = aggregations
-	}
-
-	if filter, ok := queryMap["filter"]; ok {
-		v5Query["filter"] = filter
-	}
-
-	// Copy groupBy with proper structure
-	if groupBy, ok := queryMap["groupBy"].([]any); ok {
-		v5GroupBy := make([]any, len(groupBy))
-		for i, gb := range groupBy {
-			if gbMap, ok := gb.(map[string]any); ok {
-				v5GroupBy[i] = map[string]any{
-					"name":          gbMap["key"],
-					"fieldDataType": gbMap["dataType"],
-					"fieldContext":  gbMap["type"],
-				}
-			}
-		}
-		v5Query["groupBy"] = v5GroupBy
-	}
-
-	// Copy orderBy with proper structure
-	if orderBy, ok := queryMap["orderBy"].([]any); ok {
-		v5OrderBy := make([]any, len(orderBy))
-		for i, ob := range orderBy {
-			if obMap, ok := ob.(map[string]any); ok {
-				v5OrderBy[i] = map[string]any{
-					"key": map[string]any{
-						"name":          obMap["columnName"],
-						"fieldDataType": obMap["dataType"],
-						"fieldContext":  obMap["type"],
-					},
-					"direction": obMap["order"],
-				}
-			}
-		}
-		v5Query["order"] = v5OrderBy
-	}
-
-	// Copy selectColumns as selectFields
-	if selectColumns, ok := queryMap["selectColumns"].([]any); ok {
-		v5SelectFields := make([]any, len(selectColumns))
-		for i, col := range selectColumns {
-			if colMap, ok := col.(map[string]any); ok {
-				v5SelectFields[i] = map[string]any{
-					"name":          colMap["key"],
-					"fieldDataType": colMap["dataType"],
-					"fieldContext":  colMap["type"],
-				}
-			}
-		}
-		v5Query["selectFields"] = v5SelectFields
-	}
-
-	// Copy limit and offset
-	if limit, ok := queryMap["limit"]; ok {
-		v5Query["limit"] = limit
-	}
-	if offset, ok := queryMap["offset"]; ok {
-		v5Query["offset"] = offset
-	}
-
-	if having, ok := queryMap["having"]; ok {
-		v5Query["having"] = having
-	}
-
-	if functions, ok := queryMap["functions"]; ok {
-		v5Query["functions"] = functions
-	}
-
-	return map[string]any{
-		"type": queryType,
-		"spec": v5Query,
-	}
+	return querybuildertypesv5.WrapInV5Envelope(name, queryMap, queryType)
 }
 
 func (mc *migrateCommon) updateQueryData(ctx context.Context, queryData map[string]any, version, widgetType string) bool {

pkg/transition/migrate_shape_safe.go

@@ -0,0 +1,353 @@
+// nolint
+package transition
+
+import (
+	"context"
+	"log/slog"
+)
+
+// ══════════════════════════════════════════════
+// Shape-safe (idempotent) migration
+// ══════════════════════════════════════════════
+//
+// A copy of the Migrate → updateWidget → updateQueryData chain with the
+// "uniformly v4 input" assumption removed, so it is safe on a dashboard whose
+// `version` tag lies (a "v5"-labelled dashboard with un-upgraded, possibly mixed,
+// bodies — the v1→v2 converter's case). Versus the original: no version gate, and
+// each step acts only on the pre-v5 shape (leaving a v5 field alone), so it is
+// idempotent. The original Migrate is left unchanged (battle-tested, no test net).
+// The *ShapeSafe methods below each note the original they copy; the reused steps
+// (createFilterExpression, fixGroupBy, buildAggregationExpression, orderByExpr) are
+// already v5-safe.
+
+// MigrateQueryDataShapeSafe is the per-query entry point (the core of
+// updateQueryDataShapeSafe) for callers that process queries one at a time (the
+// v1→v2 converter). widgetType is the v1 panelTypes (metric reduceTo on tables);
+// "" is safe.
+func (m *dashboardMigrateV5) MigrateQueryDataShapeSafe(ctx context.Context, queryData map[string]any, widgetType string) bool {
+	return m.updateQueryDataShapeSafe(ctx, queryData, widgetType)
+}
+
+// updateQueryDataShapeSafe copies updateQueryData, with each destructive step
+// guarded to act only on the pre-v5 shape (see the file header).
+func (mc *migrateCommon) updateQueryDataShapeSafe(ctx context.Context, queryData map[string]any, widgetType string) bool {
+	updated := false
+
+	aggregateOp, _ := queryData["aggregateOperator"].(string)
+	hasAggregation := aggregateOp != "" && aggregateOp != "noop"
+
+	if mc.createAggregationsShapeSafe(ctx, queryData, widgetType) {
+		updated = true
+	}
+
+	// createFilterExpression only touches v4 `filters`; skip if a v5 `filter` exists.
+	if _, hasFilter := queryData["filter"]; !hasFilter {
+		if mc.createFilterExpression(ctx, queryData) {
+			updated = true
+		}
+	}
+
+	if mc.fixGroupBy(queryData) {
+		updated = true
+	}
+
+	if mc.createHavingExpressionShapeSafe(queryData) {
+		updated = true
+	}
+
+	if hasAggregation {
+		if orderBy, ok := queryData["orderBy"].([]any); ok && orderByIsPreV5(orderBy) {
+			newOrderBy := make([]any, 0)
+			for _, order := range orderBy {
+				if orderMap, ok := order.(map[string]any); ok {
+					columnName, _ := orderMap["columnName"].(string)
+					// skip timestamp, id (logs, traces), samples(metrics) ordering for aggregation queries
+					if columnName != "timestamp" && columnName != "samples" && columnName != "id" {
+						if columnName == "#SIGNOZ_VALUE" {
+							if expr, has := mc.orderByExpr(queryData); has {
+								orderMap["columnName"] = expr
+							}
+						} else {
+							// if the order by key is not part of the group by keys, remove it
+							present := false
+
+							groupBy, ok := queryData["groupBy"].([]any)
+							if !ok {
+								return false
+							}
+
+							for idx := range groupBy {
+								item, ok := groupBy[idx].(map[string]any)
+								if !ok {
+									continue
+								}
+								key, ok := item["key"].(string)
+								if !ok {
+									continue
+								}
+								if key == columnName {
+									present = true
+								}
+							}
+
+							if !present {
+								mc.logger.WarnContext(ctx, "found a order by without group by, skipping", slog.String("order_col_name", columnName))
+								continue
+							}
+						}
+						newOrderBy = append(newOrderBy, orderMap)
+					}
+				}
+			}
+			queryData["orderBy"] = newOrderBy
+			updated = true
+		}
+	} else {
+		dataSource, _ := queryData["dataSource"].(string)
+
+		if orderBy, ok := queryData["orderBy"].([]any); ok && orderByIsPreV5(orderBy) {
+			newOrderBy := make([]any, 0)
+			for _, order := range orderBy {
+				if orderMap, ok := order.(map[string]any); ok {
+					columnName, _ := orderMap["columnName"].(string)
+					// skip id and timestamp for (traces)
+					if (columnName == "id" || columnName == "timestamp") && dataSource == "traces" {
+						mc.logger.InfoContext(ctx, "skipping `id` order by for traces")
+						continue
+					}
+
+					// skip id for (logs)
+					if (columnName == "id" || columnName == "timestamp") && dataSource == "logs" {
+						mc.logger.InfoContext(ctx, "skipping `id`/`timestamp` order by for logs")
+						continue
+					}
+
+					newOrderBy = append(newOrderBy, orderMap)
+				}
+			}
+			queryData["orderBy"] = newOrderBy
+			updated = true
+		}
+	}
+
+	// Only the `&& functionsArePreV5(functions)` guard differs from updateQueryData.
+	if functions, ok := queryData["functions"].([]any); ok && functionsArePreV5(functions) {
+		v5Functions := make([]any, len(functions))
+		for i, fn := range functions {
+			if fnMap, ok := fn.(map[string]any); ok {
+				v5Function := map[string]any{
+					"name": fnMap["name"],
+				}
+
+				// Convert args from v4 format to v5 FunctionArg format
+				if args, ok := fnMap["args"].([]any); ok {
+					v5Args := make([]any, len(args))
+					for j, arg := range args {
+						// In v4, args were just values. In v5, they are FunctionArg objects
+						v5Args[j] = map[string]any{
+							"name":  "", // v4 didn't have named args
+							"value": arg,
+						}
+					}
+					v5Function["args"] = v5Args
+				}
+
+				// Handle namedArgs if present (some functions might have used this)
+				if namedArgs, ok := fnMap["namedArgs"].(map[string]any); ok {
+					// Convert named args to the new format
+					existingArgs, _ := v5Function["args"].([]any)
+					if existingArgs == nil {
+						existingArgs = []any{}
+					}
+
+					for name, value := range namedArgs {
+						existingArgs = append(existingArgs, map[string]any{
+							"name":  name,
+							"value": value,
+						})
+					}
+					v5Function["args"] = existingArgs
+				}
+
+				v5Functions[i] = v5Function
+			}
+		}
+		queryData["functions"] = v5Functions
+		updated = true
+	}
+
+	delete(queryData, "aggregateOperator")
+	delete(queryData, "aggregateAttribute")
+	delete(queryData, "temporality")
+	delete(queryData, "timeAggregation")
+	delete(queryData, "spaceAggregation")
+	delete(queryData, "reduceTo")
+	delete(queryData, "filters")
+	delete(queryData, "ShiftBy")
+	delete(queryData, "IsAnomaly")
+	delete(queryData, "QueriesUsedInFormula")
+	delete(queryData, "seriesAggregation")
+
+	return updated
+}
+
+// createHavingExpressionShapeSafe copies createHavingExpression but leaves an
+// already-v5 having:{expression} alone instead of wiping it.
+func (mc *migrateCommon) createHavingExpressionShapeSafe(queryData map[string]any) bool {
+	if _, ok := queryData["having"].(map[string]any); ok {
+		return false // already v5-shaped
+	}
+	having, ok := queryData["having"].([]any)
+	if !ok || len(having) == 0 {
+		queryData["having"] = map[string]any{"expression": ""}
+		return true
+	}
+
+	dataSource, _ := queryData["dataSource"].(string)
+
+	for idx := range having {
+		if havingItem, ok := having[idx].(map[string]any); ok {
+			havingCol, has := mc.orderByExpr(queryData)
+			if has {
+				havingItem["columnName"] = havingCol
+				havingItem["key"] = map[string]any{"key": havingCol}
+			}
+			having[idx] = havingItem
+		}
+	}
+	queryData["having"] = map[string]any{"expression": mc.buildExpression(context.Background(), having, "AND", dataSource)}
+	return true
+}
+
+// createAggregationsShapeSafe copies createAggregations but skips a query that
+// already has a v5 aggregations[], and picks the metric time/space aggregation
+// from the body's shape (has timeAggregation/spaceAggregation?) rather than the
+// version tag.
+func (mc *migrateCommon) createAggregationsShapeSafe(ctx context.Context, queryData map[string]any, widgetType string) bool {
+	if aggs, ok := queryData["aggregations"].([]any); ok && len(aggs) > 0 {
+		return false // already v5-shaped
+	}
+
+	aggregateOp, hasOp := queryData["aggregateOperator"].(string)
+	aggregateAttr, hasAttr := queryData["aggregateAttribute"].(map[string]any)
+	dataSource, _ := queryData["dataSource"].(string)
+
+	if aggregateOp == "noop" && dataSource != "metrics" {
+		return false
+	}
+	if !hasOp || !hasAttr {
+		return false
+	}
+
+	var aggregation map[string]any
+
+	switch dataSource {
+	case "metrics":
+		_, hasTime := queryData["timeAggregation"]
+		_, hasSpace := queryData["spaceAggregation"]
+		if hasTime || hasSpace { // acts as a check for v4 shape: the body carries its own time/space aggregation.
+			if _, ok := queryData["spaceAggregation"]; !ok {
+				queryData["spaceAggregation"] = aggregateOp
+			}
+			aggregation = map[string]any{
+				"metricName":       aggregateAttr["key"],
+				"temporality":      queryData["temporality"],
+				"timeAggregation":  queryData["timeAggregation"],
+				"spaceAggregation": queryData["spaceAggregation"],
+			}
+			if reduceTo, ok := queryData["reduceTo"].(string); ok {
+				aggregation["reduceTo"] = reduceTo
+			}
+		} else {
+			// v3 shape: derive time/space from the compound operator.
+			var timeAgg, spaceAgg, reduceTo string
+			switch aggregateOp {
+			case "sum_rate", "rate_sum":
+				timeAgg, spaceAgg, reduceTo = "rate", "sum", "sum"
+			case "avg_rate", "rate_avg":
+				timeAgg, spaceAgg, reduceTo = "rate", "avg", "avg"
+			case "min_rate", "rate_min":
+				timeAgg, spaceAgg, reduceTo = "rate", "min", "min"
+			case "max_rate", "rate_max":
+				timeAgg, spaceAgg, reduceTo = "rate", "max", "max"
+			case "hist_quantile_50":
+				timeAgg, spaceAgg, reduceTo = "", "p50", "avg"
+			case "hist_quantile_75":
+				timeAgg, spaceAgg, reduceTo = "", "p75", "avg"
+			case "hist_quantile_90":
+				timeAgg, spaceAgg, reduceTo = "", "p90", "avg"
+			case "hist_quantile_95":
+				timeAgg, spaceAgg, reduceTo = "", "p95", "avg"
+			case "hist_quantile_99":
+				timeAgg, spaceAgg, reduceTo = "", "p99", "avg"
+			case "rate":
+				timeAgg, spaceAgg, reduceTo = "rate", "sum", "sum"
+			case "p99", "p90", "p75", "p50", "p25", "p20", "p10", "p05":
+				mc.logger.InfoContext(ctx, "found invalid config")
+				timeAgg, spaceAgg, reduceTo = "avg", "avg", "avg"
+			case "min":
+				timeAgg, spaceAgg, reduceTo = "min", "min", "min"
+			case "max":
+				timeAgg, spaceAgg, reduceTo = "max", "max", "max"
+			case "avg":
+				timeAgg, spaceAgg, reduceTo = "avg", "avg", "avg"
+			case "sum":
+				timeAgg, spaceAgg, reduceTo = "sum", "sum", "sum"
+			case "count":
+				timeAgg, spaceAgg, reduceTo = "count", "sum", "sum"
+			case "count_distinct":
+				timeAgg, spaceAgg, reduceTo = "count_distinct", "sum", "sum"
+			case "noop":
+				mc.logger.WarnContext(ctx, "noop found in the aggregation data")
+				timeAgg, spaceAgg, reduceTo = "max", "max", "max"
+			}
+			aggregation = map[string]any{
+				"metricName":       aggregateAttr["key"],
+				"temporality":      queryData["temporality"],
+				"timeAggregation":  timeAgg,
+				"spaceAggregation": spaceAgg,
+			}
+			if widgetType == "table" {
+				aggregation["reduceTo"] = reduceTo
+			} else if reduceTo, ok := queryData["reduceTo"].(string); ok {
+				aggregation["reduceTo"] = reduceTo
+			}
+		}
+	case "logs", "traces":
+		aggregation = map[string]any{"expression": mc.buildAggregationExpression(aggregateOp, aggregateAttr)}
+	default:
+		return false
+	}
+
+	queryData["aggregations"] = []any{aggregation}
+	return true
+}
+
+// orderByIsPreV5 reports whether an orderBy slice is still in the v4 shape (an
+// entry carries "columnName"); a v5 orderBy uses {key:{name}, direction}.
+func orderByIsPreV5(orderBy []any) bool {
+	for _, o := range orderBy {
+		if m, ok := o.(map[string]any); ok {
+			if _, has := m["columnName"]; has {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// functionsArePreV5 reports whether a functions slice is still in the v4 shape
+// (args are raw values); a v5 function's args are {name,value} objects.
+func functionsArePreV5(functions []any) bool {
+	for _, f := range functions {
+		if m, ok := f.(map[string]any); ok {
+			args, ok := m["args"].([]any)
+			if !ok || len(args) == 0 {
+				continue
+			}
+			_, argIsObject := args[0].(map[string]any)
+			return !argIsObject
+		}
+	}
+	return false
+}

pkg/types/dashboardtypes/dashboard.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -22,6 +21,7 @@ var (
 	ErrCodeDashboardInvalidSource      = errors.MustNewCode("dashboard_invalid_source")
 	ErrCodeDashboardImmutable          = errors.MustNewCode("dashboard_immutable")
 	ErrCodeDashboardInvalidPatch       = errors.MustNewCode("dashboard_invalid_patch")
+	ErrCodeDashboardMigrationFailed    = errors.MustNewCode("dashboard_migration_failed")
 )
 
 type StorableDashboard struct {
@@ -406,27 +406,26 @@ func (dashboard *Dashboard) GetWidgetQuery(startTime, endTime, widgetIndex uint6
 	widgetData := data.Widgets[widgetIndex]
 	switch widgetData.Query.QueryType {
 	case "builder":
-		migrate := transition.NewMigrateCommon(logger)
 		for _, query := range widgetData.Query.Builder.QueryData {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_query"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_query"))
 		}
 		for _, query := range widgetData.Query.Builder.QueryFormulas {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_formula"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_formula"))
 		}
 		for _, query := range widgetData.Query.Builder.QueryTraceOperator {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
 		}
 	case "clickhouse_sql":
 		for _, query := range widgetData.Query.ClickhouseSQL {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1060,6 +1060,34 @@ func TestValidateRequiredFields(t *testing.T) {
 	}
 }
 
+// TestThresholdZeroValueAcceptedMissingRejected documents the *float64 Value:
+// a threshold at 0 (or 0.0) is valid, because the pointer lets validate:"required"
+// tell a present zero (non-nil) from an absent value (nil) — while a genuinely
+// missing value is still rejected.
+func TestThresholdZeroValueAcceptedMissingRejected(t *testing.T) {
+	numberPanel := func(thresholdSpec string) string {
+		return `{
+			"panels": {"p1": {"kind": "Panel", "spec": {
+				"plugin": {"kind": "signoz/NumberPanel", "spec": {"thresholds": [` + thresholdSpec + `]}},
+				"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+			}}},
+			"layouts": []
+		}`
+	}
+
+	_, errZero := unmarshalDashboard([]byte(numberPanel(`{"value": 0, "operator": "above", "format": "text", "color": "Red"}`)))
+	require.NoError(t, errZero, `a threshold "value": 0 is valid`)
+
+	// "value": 0.0 is the same float64 zero as "value": 0 — JSON has one number
+	// type — and is accepted identically.
+	_, errZeroFloat := unmarshalDashboard([]byte(numberPanel(`{"value": 0.0, "operator": "above", "format": "text", "color": "Red"}`)))
+	require.NoError(t, errZeroFloat, `"value": 0.0 is the same valid zero`)
+
+	_, errMissing := unmarshalDashboard([]byte(numberPanel(`{"operator": "above", "format": "text", "color": "Red"}`)))
+	require.Error(t, errMissing, "a genuinely missing value is still rejected")
+	require.Contains(t, errMissing.Error(), "Value")
+}
+
 func TestTimeSeriesPanelDefaults(t *testing.T) {
 	data := []byte(`{
 		"panels": {

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -251,14 +251,20 @@ type Legend struct {
 }
 
 type ThresholdWithLabel struct {
-	Value float64 `json:"value" validate:"required" required:"true"`
-	Unit  string  `json:"unit"`
-	Color string  `json:"color" validate:"required" required:"true"`
-	Label string  `json:"label"`
+	// Value is a pointer so a threshold at 0 is valid: validate:"required" treats
+	// the float64 zero as "missing", but a non-nil *float64 to 0 passes (and nil
+	// still fails, so a genuinely absent value is still rejected). nullable:"false"
+	// keeps it a plain required number in the schema — it is never null in valid
+	// data (validation rejects nil), so the pointer must not leak as `number|null`.
+	Value *float64 `json:"value" validate:"required" required:"true" nullable:"false"`
+	Unit  string   `json:"unit"`
+	Color string   `json:"color" validate:"required" required:"true"`
+	Label string   `json:"label"`
 }
 
 type ComparisonThreshold struct {
-	Value    float64            `json:"value" validate:"required" required:"true"`
+	// Value is a pointer so a threshold at 0 is valid (see ThresholdWithLabel.Value).
+	Value    *float64           `json:"value" validate:"required" required:"true" nullable:"false"`
 	Operator ComparisonOperator `json:"operator"`
 	Unit     string             `json:"unit"`
 	Color    string             `json:"color" validate:"required" required:"true"`

pkg/types/dashboardtypes/perses_v1_to_v2.go

@@ -0,0 +1,94 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// V1 → V2 migration. The v1 storable shape is the frontend's `DashboardData`
+// (see frontend/src/types/api/dashboard/getAll.ts); v2 is DashboardV2 /
+// DashboardSpec.
+//
+// Assumes the v1 widget query data has already been migrated to v5 shape
+// (transition.dashboardMigrateV5). Pre-v5 builder queries will produce
+// invalid v2 envelopes — run the v4→v5 migration first.
+//
+// The conversion is split across sibling files by concern:
+//   - perses_v1_to_v2_tags.go      tags
+//   - perses_v1_to_v2_panels.go    widgets → panels (+ panel field mappers)
+//   - perses_v1_to_v2_queries.go   widget queries
+//   - perses_v1_to_v2_layouts.go   grid layouts and sections
+//   - perses_v1_to_v2_variables.go variables
+//   - perses_v1_to_v2_decoder.go   v1Decoder: typed field reads + malformed-field detection
+
+// ══════════════════════════════════════════════
+// Entry point
+// ══════════════════════════════════════════════
+
+func (storable StorableDashboard) IsV2() bool {
+	metadata, _ := storable.Data["metadata"].(map[string]any)
+	if metadata == nil {
+		return false
+	}
+	version, _ := metadata["schemaVersion"].(string)
+	return version == SchemaVersion
+}
+
+func (storable StorableDashboard) ConvertV1ToV2() (result *DashboardV2, err error) {
+	// Legacy v1 data can be arbitrarily malformed. The accessors degrade
+	// gracefully, but recover from any unforeseen panic so one bad dashboard
+	// surfaces as an error (to be logged and skipped) rather than crashing the run.
+	defer func() {
+		if r := recover(); r != nil {
+			result, err = nil, errors.Newf(errors.TypeInternal, ErrCodeDashboardMigrationFailed, "panic converting dashboard %s: %v", storable.ID, r)
+		}
+	}()
+
+	if storable.IsV2() {
+		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardMigrationFailed, "dashboard %s is already in %s schema", storable.ID, SchemaVersion)
+	}
+
+	d := &v1Decoder{}
+	title := d.readString(storable.Data, "title")
+	description := d.readString(storable.Data, "description")
+	image := d.readString(storable.Data, "image")
+
+	panels := d.convertV1Panels(storable.Data["widgets"])
+	spec := DashboardSpec{
+		Display:   Display{Name: title, Description: description},
+		Variables: d.convertV1Variables(storable.Data["variables"]),
+		Panels:    panels,
+		Layouts:   d.convertV1Layouts(storable.Data, panels),
+	}
+
+	// marshal and unmarshal cycle to confirm full validation
+	raw, marshalErr := json.Marshal(spec)
+	if marshalErr != nil {
+		return nil, errors.WrapInternalf(marshalErr, errors.CodeInternal, "marshal converted dashboard %s", storable.ID)
+	}
+	if err := json.Unmarshal(raw, new(DashboardSpec)); err != nil {
+		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardMigrationFailed, "converted dashboard %s is invalid", storable.ID)
+	}
+	tags := d.convertV1TagsForOrg(storable.OrgID, storable.Data["tags"])
+
+	if err := d.errIfHasMalformedFields(); err != nil {
+		return nil, err
+	}
+
+	return &DashboardV2{
+		Identifiable:  storable.Identifiable,
+		TimeAuditable: storable.TimeAuditable,
+		UserAuditable: storable.UserAuditable,
+		OrgID:         storable.OrgID,
+		Locked:        storable.Locked,
+		Source:        storable.Source,
+		DashboardV2MetadataBase: DashboardV2MetadataBase{
+			SchemaVersion: SchemaVersion,
+			Image:         image,
+		},
+		Name: generateDashboardName(title),
+		Tags: tags,
+		Spec: spec,
+	}, nil
+}

pkg/types/dashboardtypes/perses_v1_to_v2_decoder.go

@@ -0,0 +1,168 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// ══════════════════════════════════════════════
+// v1 decoder
+// ══════════════════════════════════════════════
+
+// v1Decoder reads fields out of the untyped v1 dashboard blob. Every read*
+// method follows the same contract: a field that is absent or null yields the
+// zero value; a field present with the wrong type yields zero AND records a
+// malformed-field error. Conversion proceeds (so one bad field doesn't abort
+// the rest) and ConvertV1ToV2 returns d.malformedFieldsErr() at the end so the
+// dashboard is logged and skipped.
+//
+// Polymorphic v1 fields (spanGaps bool|number, selectedValue string|array, …)
+// are read with a type switch on the already-extracted value, never through
+// these accessors, so they stay lenient by construction.
+type v1Decoder struct {
+	bad  []string
+	seen map[string]struct{}
+}
+
+// note records a decoding problem (malformed field, unknown value, swallowed
+// sub-parse error), deduping identical messages. ConvertV1ToV2 surfaces these
+// via errIfHasMalformedFields.
+func (d *v1Decoder) note(format string, args ...any) {
+	msg := fmt.Sprintf(format, args...)
+	if _, dup := d.seen[msg]; dup {
+		return
+	}
+	if d.seen == nil {
+		d.seen = make(map[string]struct{})
+	}
+	d.seen[msg] = struct{}{}
+	d.bad = append(d.bad, msg)
+}
+
+// noteMalformedField records a v1 field present with the wrong Go type.
+func (d *v1Decoder) noteMalformedField(field string, raw any) {
+	d.note("%q has unexpected type %T", field, raw)
+}
+
+// detailErr renders an error for a diagnostic note, unfolding the structured
+// detail our JSON binding attaches via WithAdditional. A plain %v on these
+// errors prints only the innermost message ("request body contains invalid
+// field value") and drops the field/type context that says which field was
+// wrong — the part that actually tells you what to fix.
+func detailErr(err error) string {
+	if err == nil {
+		return ""
+	}
+	j := errors.AsJSON(err)
+	if len(j.Errors) == 0 {
+		return err.Error()
+	}
+	details := make([]string, 0, len(j.Errors))
+	for _, e := range j.Errors {
+		details = append(details, e.Message)
+	}
+	return j.Message + ": " + strings.Join(details, "; ")
+}
+
+func (d *v1Decoder) errIfHasMalformedFields() error {
+	if len(d.bad) == 0 {
+		return nil
+	}
+	// One field per line: these lists run long (a bad widget query is reported
+	// once per widget), and a single "; "-joined line is an unscannable wall.
+	return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidData, "malformed v1 dashboard fields:\n  %s", strings.Join(d.bad, "\n  "))
+}
+
+func readField[T any](d *v1Decoder, m map[string]any, key string) T {
+	var zero T
+	v, present := m[key]
+	if !present || v == nil {
+		return zero
+	}
+	t, ok := v.(T)
+	if !ok {
+		d.noteMalformedField(key, v)
+		return zero
+	}
+	return t
+}
+
+func (d *v1Decoder) readString(m map[string]any, key string) string {
+	return readField[string](d, m, key)
+}
+func (d *v1Decoder) readFloat(m map[string]any, key string) float64 {
+	return readField[float64](d, m, key)
+}
+func (d *v1Decoder) readBool(m map[string]any, key string) bool   { return readField[bool](d, m, key) }
+func (d *v1Decoder) readArray(m map[string]any, key string) []any { return readField[[]any](d, m, key) }
+func (d *v1Decoder) readObject(m map[string]any, key string) map[string]any {
+	return readField[map[string]any](d, m, key)
+}
+
+// readInt narrows a numeric field to int (JSON numbers decode as float64).
+func (d *v1Decoder) readInt(m map[string]any, key string) int { return int(d.readFloat(m, key)) }
+
+func (d *v1Decoder) readFloatPtr(m map[string]any, key string) *float64 {
+	v, present := m[key]
+	if !present || v == nil {
+		return nil
+	}
+	f, ok := v.(float64)
+	if !ok {
+		d.noteMalformedField(key, v)
+		return nil
+	}
+	return &f
+}
+
+func (d *v1Decoder) readStringMap(m map[string]any, key string) map[string]string {
+	raw := d.readObject(m, key)
+	if len(raw) == 0 {
+		return nil
+	}
+	out := make(map[string]string, len(raw))
+	for k, v := range raw {
+		s, ok := v.(string)
+		if !ok {
+			d.noteMalformedField(key+"."+k, v)
+			continue
+		}
+		out[k] = s
+	}
+	return out
+}
+
+func (d *v1Decoder) readObjects(m map[string]any, key string) []map[string]any {
+	raw := d.readArray(m, key)
+	if len(raw) == 0 {
+		return nil
+	}
+	out := make([]map[string]any, 0, len(raw))
+	for i, item := range raw {
+		obj, ok := item.(map[string]any)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("%s[%d]", key, i), item)
+			continue
+		}
+		out = append(out, obj)
+	}
+	return out
+}
+
+// decodeMapInto converts an untyped map[string]any into a typed T by
+// round-tripping through JSON, letting encoding/json (struct tags, custom
+// UnmarshalJSON) do the field mapping instead of hand-copying out of the map.
+func decodeMapInto[T any](src map[string]any) (T, error) {
+	var dst T
+	bytes, err := json.Marshal(src)
+	if err != nil {
+		return dst, err
+	}
+	if err := json.Unmarshal(bytes, &dst); err != nil {
+		return dst, err
+	}
+	return dst, nil
+}

pkg/types/dashboardtypes/perses_v1_to_v2_layouts.go

@@ -0,0 +1,230 @@
+package dashboardtypes
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/perses/spec/go/common"
+	"github.com/perses/spec/go/dashboard"
+)
+
+// ══════════════════════════════════════════════
+// Layouts (data.layout + data.panelMap)
+// ══════════════════════════════════════════════
+
+// convertV1Layouts groups v1 react-grid-layout entries into v2 grid layouts.
+// Membership is positional (as the frontend renders): each row widget owns the
+// panels below it until the next row; panels above the first row form an unnamed
+// grid with no section header. Collapsed rows are the exception — their children
+// live in panelMap[rowID].widgets, not `layout`.
+func (d *v1Decoder) convertV1Layouts(data StorableDashboardData, panels map[string]*Panel) []Layout {
+	layout := d.readObjects(data, "layout")
+	if len(layout) == 0 {
+		return nil
+	}
+
+	// react-grid-layout can persist the same widget id more than once. Drop the
+	// duplicates, mirroring the frontend's getUpdatedLayout: keep the first
+	// occurrence in stored order and discard the rest (the losing entry's
+	// geometry is thrown away, not merged). Dedupe here, before sortByPosition,
+	// so "first" means first-in-stored-order as the frontend sees it — not
+	// topmost. Entries with no id are left for the main loop to drop.
+	seenWidgetIds := make(map[string]bool, len(layout))
+	dedupedLayouts := layout[:0]
+	for _, item := range layout {
+		if id := d.readString(item, "i"); id != "" {
+			if seenWidgetIds[id] {
+				continue
+			}
+			seenWidgetIds[id] = true
+		}
+		dedupedLayouts = append(dedupedLayouts, item)
+	}
+	layout = dedupedLayouts
+
+	rows := d.extractRowsAndCollapsedWidgets(data)
+
+	// Skip collapsed-row children a malformed dashboard lists in `layout` too.
+	isWidgetCollapsed := make(map[string]bool)
+	for _, row := range rows {
+		for _, child := range row.collapsedWidgets {
+			if id := d.readString(child, "i"); id != "" {
+				isWidgetCollapsed[id] = true
+				break
+			}
+		}
+	}
+
+	d.sortByPosition(layout)
+
+	type section struct {
+		row   *rowInfo // nil for the unnamed grid of ungrouped panels
+		items []map[string]any
+	}
+	topSectionWithoutHeader := &section{}
+	sectionsWithHeader := make([]*section, 0, len(rows))
+	currentRowHeader := topSectionWithoutHeader
+	for _, item := range layout {
+		id := d.readString(item, "i")
+		if id == "" || isWidgetCollapsed[id] {
+			// widgets in collapsed sectinos will be added when those sections' row widgets are handled.
+			continue
+		}
+		if row, ok := rows[id]; ok {
+			newRowHeader := &section{row: row, items: d.extractValidLayoutItemsForCollapsedSection(row.collapsedWidgets, panels)}
+			sectionsWithHeader = append(sectionsWithHeader, newRowHeader)
+			// A collapsed row owns only its stashed children; later panels → ungrouped.
+			if row.collapsed {
+				currentRowHeader = topSectionWithoutHeader
+			} else {
+				currentRowHeader = newRowHeader
+			}
+			continue
+		}
+		// Keep a layout entry only if its widget became a panel; otherwise (skipped
+		// widget, deleted id, or the "__dropping-elem__" drag placeholder) it would
+		// reference a panel that does not exist. Rows are handled above.
+		if _, ok := panels[id]; !ok {
+			continue
+		}
+		currentRowHeader.items = append(currentRowHeader.items, item)
+	}
+
+	out := make([]Layout, 0, len(sectionsWithHeader)+1)
+	if len(topSectionWithoutHeader.items) > 0 {
+		out = append(out, d.buildV2GridLayout(nil, topSectionWithoutHeader.items))
+	}
+	for _, sec := range sectionsWithHeader {
+		out = append(out, d.buildV2GridLayout(sec.row, sec.items))
+	}
+	return out
+}
+
+// extractValidLayoutItemsForCollapsedSection keeps only the collapsed-row children
+// backed by a real panel, dropping ghosts. These come from panelMap and skip the
+// main loop's per-item panel check, so a grid never references a missing panel.
+func (d *v1Decoder) extractValidLayoutItemsForCollapsedSection(items []map[string]any, panels map[string]*Panel) []map[string]any {
+	out := make([]map[string]any, 0, len(items))
+	for _, item := range items {
+		if id := d.readString(item, "i"); id != "" {
+			if _, ok := panels[id]; ok {
+				out = append(out, item)
+			}
+		}
+	}
+	return out
+}
+
+type rowInfo struct {
+	title            string
+	collapsed        bool
+	collapsedWidgets []map[string]any
+}
+
+// extractRowsAndCollapsedWidgets returns the row widgets keyed by id; collapsed
+// rows also carry their children stashed under panelMap[id].widgets.
+func (d *v1Decoder) extractRowsAndCollapsedWidgets(data StorableDashboardData) map[string]*rowInfo {
+	panelMap := d.readObject(data, "panelMap")
+	rows := make(map[string]*rowInfo)
+	for _, w := range d.readObjects(data, "widgets") {
+		id := d.readString(w, "id")
+		if d.readString(w, "panelTypes") != "row" || id == "" {
+			continue
+		}
+		row := &rowInfo{title: d.readString(w, "title")}
+		// Some templates store panelMap[id] as a bare []widgetID instead of the
+		// canonical {widgets, collapsed}. The frontend treats such a non-object
+		// entry as "not collapsed" (see GridCardLayout), so read it leniently: a
+		// non-map yields nil, which reads as not collapsed.
+		pm, _ := panelMap[id].(map[string]any)
+		if d.readBool(pm, "collapsed") {
+			row.collapsed = true
+			row.collapsedWidgets = d.readObjects(pm, "widgets")
+		}
+		rows[id] = row
+	}
+	return rows
+}
+
+// buildV2GridLayout builds one v2 grid. row is nil for the unnamed grid (no
+// display); otherwise the grid takes the row's title and collapse state. Items are
+// sorted by (y, x) then vertically compacted (see compactGridItemsVertically).
+func (d *v1Decoder) buildV2GridLayout(row *rowInfo, items []map[string]any) Layout {
+	d.sortByPosition(items)
+
+	spec := dashboard.GridLayoutSpec{Items: make([]dashboard.GridItem, 0, len(items))}
+	if row != nil {
+		spec.Display = &dashboard.GridLayoutDisplay{
+			Title:    row.title,
+			Collapse: &dashboard.GridLayoutCollapse{Open: !row.collapsed},
+		}
+	}
+
+	for _, item := range items {
+		spec.Items = append(spec.Items, dashboard.GridItem{
+			X:       d.readInt(item, "x"),
+			Y:       d.readInt(item, "y"),
+			Width:   d.readInt(item, "w"),
+			Height:  d.readInt(item, "h"),
+			Content: &common.JSONRef{Ref: fmt.Sprintf("#/spec/panels/%s", d.readString(item, "i"))},
+		})
+	}
+	compactGridItemsVertically(spec.Items)
+	return Layout{Kind: dashboard.KindGridLayout, Spec: &spec}
+}
+
+// compactGridItemsVertically mirrors react-grid-layout's correctBounds+compact
+// (compactType "vertical", allowOverlap false): clamp each item into the grid (x,y>=0;
+// x+width<=cols by shifting left), then move sorted-first items up to fill space and
+// down past collisions. Fixes overlaps, gaps, and out-of-bounds coords so the migrated
+// grid matches the v1 UI and passes v2 validation.
+func compactGridItemsVertically(items []dashboard.GridItem) {
+	collides := func(a, b dashboard.GridItem) bool {
+		return a.X < b.X+b.Width && b.X < a.X+a.Width && a.Y < b.Y+b.Height && b.Y < a.Y+a.Height
+	}
+	firstCollision := func(l dashboard.GridItem, placed []dashboard.GridItem) (dashboard.GridItem, bool) {
+		for _, p := range placed {
+			if collides(l, p) {
+				return p, true
+			}
+		}
+		return dashboard.GridItem{}, false
+	}
+	for i := range items {
+		l := items[i]
+		if l.X+l.Width > gridColumnCount { // overflows right → shift left to fit
+			l.X = gridColumnCount - l.Width
+		}
+		if l.X < 0 {
+			l.X = 0
+		}
+		if l.Y < 0 {
+			l.Y = 0
+		}
+		for l.Y > 0 { // move up to fill space above
+			up := l
+			up.Y--
+			if _, hit := firstCollision(up, items[:i]); hit {
+				break
+			}
+			l.Y--
+		}
+		for { // then down past any collision with an already-placed item
+			c, hit := firstCollision(l, items[:i])
+			if !hit {
+				break
+			}
+			l.Y = c.Y + c.Height
+		}
+		items[i] = l
+	}
+}
+
+func (d *v1Decoder) sortByPosition(items []map[string]any) {
+	sort.SliceStable(items, func(i, j int) bool {
+		if yi, yj := d.readInt(items[i], "y"), d.readInt(items[j], "y"); yi != yj {
+			return yi < yj
+		}
+		return d.readInt(items[i], "x") < d.readInt(items[j], "x")
+	})
+}

pkg/types/dashboardtypes/perses_v1_to_v2_panels.go

@@ -0,0 +1,473 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// ══════════════════════════════════════════════
+// Widgets → Panels
+// ══════════════════════════════════════════════
+
+// convertV1Panels walks the v1 `widgets` array and produces v2 panels keyed by
+// the v1 widget id. WidgetRow entries (panelTypes == "row") are dropped here
+// and consumed by convertV1Layouts as section headers.
+func (d *v1Decoder) convertV1Panels(raw any) map[string]*Panel {
+	if raw == nil {
+		return nil
+	}
+	widgetsRaw, ok := raw.([]any)
+	if !ok {
+		d.noteMalformedField("widgets", raw)
+		return nil
+	}
+	panels := make(map[string]*Panel, len(widgetsRaw))
+	for i, widgetRaw := range widgetsRaw {
+		widget, ok := widgetRaw.(map[string]any)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("widgets[%d]", i), widgetRaw)
+			continue
+		}
+		id := d.readString(widget, "id")
+		if id == "" {
+			// dead widget that can't be referenced anywhere, skipping.
+			continue
+		}
+		var panel *Panel
+		panelType := d.readString(widget, "panelTypes")
+		switch panelType {
+		case "graph":
+			panel = d.convertGraphWidget(widget)
+		case "bar":
+			panel = d.convertBarWidget(widget)
+		case "value":
+			panel = d.convertValueWidget(widget)
+		case "pie":
+			panel = d.convertPieWidget(widget)
+		case "table":
+			panel = d.convertTableWidget(widget)
+		case "histogram":
+			panel = d.convertHistogramWidget(widget)
+		case "list":
+			panel = d.convertListWidget(widget)
+		case "row":
+			// "row" (section header) is handled by the layout pass;
+			continue
+		default:
+			d.note("widgets[%d] has unknown panel type %q", i, panelType)
+		}
+		if panel == nil {
+			continue
+		}
+		panels[id] = panel
+	}
+	return panels
+}
+
+func (d *v1Decoder) convertGraphWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindTimeSeries,
+				Spec: &TimeSeriesPanelSpec{
+					Visualization: TimeSeriesVisualization{
+						BasicVisualization: d.basicVisualization(w),
+						FillSpans:          d.readBool(w, "fillSpans"),
+					},
+					Formatting: d.panelFormatting(w),
+					ChartAppearance: TimeSeriesChartAppearance{
+						LineInterpolation: mapV1Enum(d.readString(w, "lineInterpolation"), LineInterpolationSpline,
+							LineInterpolationLinear, LineInterpolationSpline, LineInterpolationStepAfter, LineInterpolationStepBefore),
+						ShowPoints: d.readBool(w, "showPoints"),
+						LineStyle:  mapV1Enum(d.readString(w, "lineStyle"), LineStyleSolid, LineStyleSolid, LineStyleDashed),
+						FillMode:   mapV1Enum(d.readString(w, "fillMode"), FillModeNone, FillModeSolid, FillModeGradient, FillModeNone),
+						SpanGaps:   mapV1SpanGaps(w["spanGaps"]),
+					},
+					Axes:       d.axesFromWidget(w),
+					Legend:     d.legendFromWidget(w),
+					Thresholds: d.mapV1ThresholdsWithLabel(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindTimeSeries),
+		},
+	}
+}
+
+func (d *v1Decoder) convertBarWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindBarChart,
+				Spec: &BarChartPanelSpec{
+					Visualization: BarChartVisualization{
+						BasicVisualization: d.basicVisualization(w),
+						FillSpans:          d.readBool(w, "fillSpans"),
+						StackedBarChart:    d.readBool(w, "stackedBarChart"),
+					},
+					Formatting: d.panelFormatting(w),
+					Axes:       d.axesFromWidget(w),
+					Legend:     d.legendFromWidget(w),
+					Thresholds: d.mapV1ThresholdsWithLabel(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindBarChart),
+		},
+	}
+}
+
+func (d *v1Decoder) convertValueWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindNumber,
+				Spec: &NumberPanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting:    d.panelFormatting(w),
+					Thresholds:    d.mapV1ComparisonThresholds(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindNumber),
+		},
+	}
+}
+
+func (d *v1Decoder) convertPieWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindPieChart,
+				Spec: &PieChartPanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting:    d.panelFormatting(w),
+					Legend:        d.legendFromWidget(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindPieChart),
+		},
+	}
+}
+
+func (d *v1Decoder) convertTableWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindTable,
+				Spec: &TablePanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting: TableFormatting{
+						ColumnUnits:      d.readStringMap(w, "columnUnits"),
+						DecimalPrecision: mapV1Precision(w["decimalPrecision"]),
+					},
+					Thresholds: d.mapV1TableThresholds(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindTable),
+		},
+	}
+}
+
+func (d *v1Decoder) convertHistogramWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindHistogram,
+				Spec: &HistogramPanelSpec{
+					HistogramBuckets: HistogramBuckets{
+						BucketCount:           d.readFloatPtr(w, "bucketCount"),
+						BucketWidth:           d.readFloatPtr(w, "bucketWidth"),
+						MergeAllActiveQueries: d.readBool(w, "mergeAllActiveQueries"),
+					},
+					Legend: d.legendFromWidget(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindHistogram),
+		},
+	}
+}
+
+func (d *v1Decoder) convertListWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindList,
+				Spec: &ListPanelSpec{
+					SelectFields: d.mapV1SelectFields(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindList),
+		},
+	}
+}
+
+// ══════════════════════════════════════════════
+// Panel-spec shared helpers
+// ══════════════════════════════════════════════
+
+func (d *v1Decoder) widgetDisplay(w map[string]any) Display {
+	return Display{Name: d.readString(w, "title"), Description: d.readString(w, "description")}
+}
+
+func (d *v1Decoder) basicVisualization(w map[string]any) BasicVisualization {
+	return BasicVisualization{TimePreference: mapV1TimePreference(d.readString(w, "timePreferance"))}
+}
+
+func (d *v1Decoder) panelFormatting(w map[string]any) PanelFormatting {
+	return PanelFormatting{Unit: d.readString(w, "yAxisUnit"), DecimalPrecision: mapV1Precision(w["decimalPrecision"])}
+}
+
+func (d *v1Decoder) axesFromWidget(w map[string]any) Axes {
+	return Axes{
+		SoftMin:    d.readFloatPtr(w, "softMin"),
+		SoftMax:    d.readFloatPtr(w, "softMax"),
+		IsLogScale: d.readBool(w, "isLogScale"),
+	}
+}
+
+func (d *v1Decoder) legendFromWidget(w map[string]any) Legend {
+	return Legend{
+		Position:     mapV1Enum(d.readString(w, "legendPosition"), LegendPositionBottom, LegendPositionBottom, LegendPositionRight),
+		CustomColors: d.readStringMap(w, "customLegendColors"),
+	}
+}
+
+func (d *v1Decoder) mapV1SelectFields(w map[string]any) []telemetrytypes.TelemetryFieldKey {
+	field := "selectedLogFields"
+	raw := d.readArray(w, field)
+	if len(raw) == 0 {
+		field = "selectedTracesFields"
+		raw = d.readArray(w, field)
+	}
+	if len(raw) == 0 {
+		return nil
+	}
+	normalizePreV5FieldKeys(raw)
+	fields, err := decodeTelemetryFields(raw)
+	if err != nil {
+		d.note("widget %q has malformed %s: %v", d.readString(w, "id"), field, err)
+		return nil
+	}
+	// Drop nameless entries (blank column rows) — v2 requires a name, and the v1
+	// UI renders nothing for them anyway.
+	out := fields[:0]
+	for _, f := range fields {
+		if f.Name != "" {
+			out = append(out, f)
+		}
+	}
+	return out
+}
+
+func decodeTelemetryFields(raw []any) ([]telemetrytypes.TelemetryFieldKey, error) {
+	bytes, err := json.Marshal(raw)
+	if err != nil {
+		return nil, err
+	}
+	var fields []telemetrytypes.TelemetryFieldKey
+	if err := json.Unmarshal(bytes, &fields); err != nil {
+		return nil, err
+	}
+	return fields, nil
+}
+
+// ══════════════════════════════════════════════
+// Panel field mappers
+// ══════════════════════════════════════════════
+
+// v1 stores timePreferance as `GLOBAL_TIME`, `LAST_5_MIN`, … (see
+// frontend/src/container/NewWidget/RightContainer/timeItems.ts). v2 uses the
+// lowercase form, so the translation is just downcase.
+func mapV1TimePreference(s string) TimePreference {
+	if s == "" {
+		return TimePreferenceGlobalTime
+	}
+	candidate := TimePreference{valuer.NewString(strings.ToLower(s))}
+	for _, allowed := range candidate.Enum() {
+		if allowed == candidate {
+			return candidate
+		}
+	}
+	return TimePreferenceGlobalTime
+}
+
+// mapV1Precision is polymorphic (string|number), so it type-switches the raw
+// value rather than reading through a typed accessor.
+func mapV1Precision(raw any) PrecisionOption {
+	switch v := raw.(type) {
+	case string:
+		candidate := PrecisionOption{valuer.NewString(v)}
+		for _, allowed := range candidate.Enum() {
+			if allowed == candidate {
+				return candidate
+			}
+		}
+	case float64:
+		n := int(v)
+		if n >= 0 && n <= 4 {
+			return PrecisionOption{valuer.NewString(strconv.Itoa(n))}
+		}
+	}
+	return PrecisionOption2
+}
+
+// mapV1Enum picks the v1 string value if it matches one of the allowed v2
+// values, otherwise returns the fallback. v1 frontend enums (lineInterpolation,
+// lineStyle, fillMode, legendPosition) already use the v2 lowercase form.
+func mapV1Enum[T interface{ StringValue() string }](s string, fallback T, allowed ...T) T {
+	if s == "" {
+		return fallback
+	}
+	for _, a := range allowed {
+		if a.StringValue() == s {
+			return a
+		}
+	}
+	return fallback
+}
+
+// v1 spanGaps is `boolean | number`. true → span every gap; false → never span;
+// a number is interpreted (per frontend SeriesProps.spanGaps docs) as an
+// X-axis threshold in seconds. Polymorphic, so it type-switches the raw value.
+func mapV1SpanGaps(raw any) SpanGaps {
+	switch v := raw.(type) {
+	case bool:
+		if v {
+			return SpanGaps{FillOnlyBelow: false}
+		}
+		return SpanGaps{FillOnlyBelow: true}
+	case float64:
+		dur, err := valuer.ParseTextDuration(time.Duration(v * float64(time.Second)).String())
+		if err != nil {
+			return SpanGaps{FillOnlyBelow: false}
+		}
+		return SpanGaps{FillOnlyBelow: true, FillLessThan: dur}
+	}
+	return SpanGaps{FillOnlyBelow: false}
+}
+
+func (d *v1Decoder) mapV1ThresholdsWithLabel(w map[string]any) []ThresholdWithLabel {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]ThresholdWithLabel, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		label := d.readString(t, "thresholdLabel")
+		if color == "" || label == "" {
+			// v2 ThresholdWithLabel requires both; drop entries that wouldn't validate.
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, ThresholdWithLabel{Value: &value, Unit: d.readString(t, "thresholdUnit"), Color: color, Label: label})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1ComparisonThresholds(w map[string]any) []ComparisonThreshold {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]ComparisonThreshold, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		if color == "" {
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, ComparisonThreshold{
+			Value:    &value,
+			Operator: d.mapV1ComparisonOperator(d.readString(t, "thresholdOperator")),
+			Unit:     d.readString(t, "thresholdUnit"),
+			Color:    color,
+			Format:   mapV1ThresholdFormat(d.readString(t, "thresholdFormat")),
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1TableThresholds(w map[string]any) []TableThreshold {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]TableThreshold, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		columnName := d.readString(t, "thresholdTableOptions")
+		if color == "" || columnName == "" {
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, TableThreshold{
+			ComparisonThreshold: ComparisonThreshold{
+				Value:    &value,
+				Operator: d.mapV1ComparisonOperator(d.readString(t, "thresholdOperator")),
+				Unit:     d.readString(t, "thresholdUnit"),
+				Color:    color,
+				Format:   mapV1ThresholdFormat(d.readString(t, "thresholdFormat")),
+			},
+			ColumnName: columnName,
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1ComparisonOperator(s string) ComparisonOperator {
+	switch s {
+	case ">":
+		return ComparisonOperatorAbove
+	case ">=":
+		return ComparisonOperatorAboveOrEqual
+	case "<":
+		return ComparisonOperatorBelow
+	case "<=":
+		return ComparisonOperatorBelowOrEqual
+	case "=":
+		return ComparisonOperatorEqual
+	case "!=":
+		return ComparisonOperatorNotEqual
+	default:
+		d.note("threshold has unknown comparison operator %q", s)
+		return ComparisonOperatorAbove
+	}
+}
+
+func mapV1ThresholdFormat(s string) ThresholdFormat {
+	switch strings.ToLower(s) {
+	case "background":
+		return ThresholdFormatBackground
+	case "text":
+		return ThresholdFormatText
+	}
+	return ThresholdFormatText
+}

pkg/types/dashboardtypes/perses_v1_to_v2_queries.go

@@ -0,0 +1,258 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// ══════════════════════════════════════════════
+// Queries
+// ══════════════════════════════════════════════
+
+// convertV1WidgetQuery returns exactly one Query (per Spec.Validate). The kind
+// chosen depends on the v1 widget query shape:
+//   - a single query (promql / clickhouse_sql / builder) → its native kind
+//   - multiple queries                                   → signoz/CompositeQuery
+//
+// A single query is never wrapped in a CompositeQuery; in particular List
+// panels accept only a bare signoz/BuilderQuery. Builder queries are routed
+// through qb.WrapInV5Envelope (in collectV1QueryEnvelopes), which translates v4
+// builder-field names (orderBy/selectColumns/dataSource) into their v5
+// equivalents and adds the `signal` field required by BuilderQuerySpec's
+// per-signal dispatch.
+func (d *v1Decoder) convertV1WidgetQuery(widget map[string]any, panelKind PanelPluginKind) []Query {
+	envelopes, signal := d.collectV1QueryEnvelopes(widget, panelKind)
+	if len(envelopes) == 0 {
+		return nil
+	}
+	requestType := requestTypeForPanel(panelKind)
+
+	// A single query keeps its native kind — never wrapped in a CompositeQuery.
+	if len(envelopes) == 1 {
+		if q := singleQueryFromEnvelope(envelopes[0], requestType, signal); q != nil {
+			return []Query{*q}
+		}
+	}
+
+	// Default: wrap in CompositeQuery.
+	composite, err := parseCompositeFromEnvelopes(envelopes)
+	if err != nil || composite == nil {
+		d.note("widget %q: could not build query from %d envelope(s): %s", d.readString(widget, "id"), len(envelopes), detailErr(err))
+		return nil
+	}
+	return []Query{{
+		Kind: requestType,
+		Spec: QuerySpec{
+			Plugin: QueryPlugin{Kind: QueryKindComposite, Spec: composite},
+		},
+	}}
+}
+
+// requestTypeForPanel maps a v2 panel plugin kind to the request type (result
+// shape) its queries produce. Mirrors the frontend's panelTypeToRequestType
+// (buildQueryRangeRequest.ts): time series for line/bar/histogram (histogram
+// bins client-side from raw time series, V1 parity), scalar for
+// number/pie/table, raw rows for list.
+func requestTypeForPanel(panelKind PanelPluginKind) qb.RequestType {
+	switch panelKind {
+	case PanelKindTimeSeries, PanelKindBarChart, PanelKindHistogram:
+		return qb.RequestTypeTimeSeries
+	case PanelKindNumber, PanelKindPieChart, PanelKindTable:
+		return qb.RequestTypeScalar
+	case PanelKindList:
+		return qb.RequestTypeRaw
+	}
+	return qb.RequestTypeTimeSeries
+}
+
+// collectV1QueryEnvelopes inspects widget.query.queryType and produces a
+// flattened list of v5-shaped envelopes. The returned signal is the dominant
+// builder signal (if any), used for typed builder-query dispatch.
+func (d *v1Decoder) collectV1QueryEnvelopes(widget map[string]any, panelKind PanelPluginKind) ([]map[string]any, telemetrytypes.Signal) {
+	queryMap := d.readObject(widget, "query")
+	if queryMap == nil {
+		return nil, telemetrytypes.Signal{}
+	}
+	rowLimitPanel := panelKind == PanelKindList || panelKind == PanelKindTable
+	// Raw (list) panels legitimately have no aggregation; every other panel needs one.
+	needsAggregation := requestTypeForPanel(panelKind) != qb.RequestTypeRaw
+
+	queryType := d.readString(queryMap, "queryType")
+	switch queryType {
+	case "promql":
+		var out []map[string]any
+		for _, q := range d.readObjects(queryMap, "promql") {
+			out = append(out, promQLEnvelope(q))
+		}
+		return out, telemetrytypes.Signal{}
+
+	case "clickhouse_sql":
+		var out []map[string]any
+		for _, q := range d.readObjects(queryMap, "clickhouse_sql") {
+			out = append(out, clickhouseEnvelope(q))
+		}
+		return out, telemetrytypes.Signal{}
+
+	case "builder":
+		builder := d.readObject(queryMap, "builder")
+		if builder == nil {
+			return nil, telemetrytypes.Signal{}
+		}
+		var out []map[string]any
+		var signal telemetrytypes.Signal
+		widgetType := d.readString(widget, "panelTypes")
+		for _, q := range d.readObjects(builder, "queryData") {
+			normalizePreV5QueryData(q, widgetType)
+			normalizePreV5SelectColumns(q)
+			normalizePreV5PageSize(q, rowLimitPanel)
+			if needsAggregation {
+				ensureDefaultAggregation(q)
+			}
+			name := d.readString(q, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, q, string(qb.QueryTypeBuilder.StringValue())))
+			if signal.IsZero() {
+				signal = signalFromDataSource(q["dataSource"])
+			}
+		}
+		for _, f := range d.readObjects(builder, "queryFormulas") {
+			normalizePreV5QueryData(f, widgetType)
+			name := d.readString(f, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, f, string(qb.QueryTypeFormula.StringValue())))
+		}
+		for _, op := range d.readObjects(builder, "queryTraceOperator") {
+			normalizePreV5QueryData(op, widgetType)
+			name := d.readString(op, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, op, string(qb.QueryTypeTraceOperator.StringValue())))
+		}
+		return out, signal
+	default:
+		d.note("widget %q has unknown queryType %q", d.readString(widget, "id"), queryType)
+	}
+	return nil, telemetrytypes.Signal{}
+}
+
+func promQLEnvelope(q map[string]any) map[string]any {
+	return map[string]any{
+		"type": qb.QueryTypePromQL.StringValue(),
+		"spec": map[string]any{
+			"name":     q["name"],
+			"query":    q["query"],
+			"disabled": q["disabled"],
+			"legend":   q["legend"],
+		},
+	}
+}
+
+func clickhouseEnvelope(q map[string]any) map[string]any {
+	return map[string]any{
+		"type": qb.QueryTypeClickHouseSQL.StringValue(),
+		"spec": map[string]any{
+			"name":     q["name"],
+			"query":    q["query"],
+			"disabled": q["disabled"],
+			"legend":   q["legend"],
+		},
+	}
+}
+
+// singleQueryFromEnvelope returns a typed Query for one envelope, using its
+// native query kind (promql/clickhouse_sql/builder) rather than wrapping it in
+// a CompositeQuery. A bare signoz/BuilderQuery is valid for every panel kind
+// and is the only kind List panels accept.
+func singleQueryFromEnvelope(envelope map[string]any, requestType qb.RequestType, signal telemetrytypes.Signal) *Query {
+	t, _ := envelope["type"].(string)
+	spec, _ := envelope["spec"].(map[string]any)
+	switch t {
+	case qb.QueryTypePromQL.StringValue():
+		prom, err := decodeMapInto[qb.PromQuery](spec)
+		if err != nil {
+			return nil
+		}
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   prom.Name,
+				Plugin: QueryPlugin{Kind: QueryKindPromQL, Spec: &prom},
+			},
+		}
+	case qb.QueryTypeClickHouseSQL.StringValue():
+		ch, err := decodeMapInto[qb.ClickHouseQuery](spec)
+		if err != nil {
+			return nil
+		}
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   ch.Name,
+				Plugin: QueryPlugin{Kind: QueryKindClickHouseSQL, Spec: &ch},
+			},
+		}
+	case qb.QueryTypeBuilder.StringValue():
+		builderSpec := parseBuilderQuerySpec(spec, signal)
+		if builderSpec == nil {
+			return nil
+		}
+		name, _ := spec["name"].(string)
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   name,
+				Plugin: QueryPlugin{Kind: QueryKindBuilder, Spec: &BuilderQuerySpec{Spec: builderSpec}},
+			},
+		}
+	}
+	return nil
+}
+
+func parseCompositeFromEnvelopes(envelopes []map[string]any) (*CompositeQuerySpec, error) {
+	bytes, err := json.Marshal(envelopes)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal v1 query envelopes")
+	}
+	var parsed []qb.QueryEnvelope
+	if err := json.Unmarshal(bytes, &parsed); err != nil {
+		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidWidgetQuery, "decode v5 query envelopes")
+	}
+	return &CompositeQuerySpec{Queries: parsed}, nil
+}
+
+func parseBuilderQuerySpec(rawSpec any, signal telemetrytypes.Signal) any {
+	spec, ok := rawSpec.(map[string]any)
+	if !ok {
+		return nil
+	}
+	if !signal.IsZero() {
+		spec["signal"] = signal.StringValue()
+	}
+	bytes, err := json.Marshal(spec)
+	if err != nil {
+		return nil
+	}
+	parsed, err := qb.UnmarshalBuilderQueryBySignal(bytes)
+	if err != nil {
+		return nil
+	}
+	return parsed
+}
+
+// signalFromDataSource maps a v1 data-source string to a v5 signal. Casing
+// varies by source: builder queries store lowercase ("traces"), while variable
+// `dynamicVariablesSource` stores capitalized ("Traces"), so match
+// case-insensitively. Unknown values (e.g. "All telemetry") map to the zero
+// Signal.
+func signalFromDataSource(raw any) telemetrytypes.Signal {
+	s, _ := raw.(string)
+	switch strings.ToLower(s) {
+	case "traces":
+		return telemetrytypes.SignalTraces
+	case "logs":
+		return telemetrytypes.SignalLogs
+	case "metrics":
+		return telemetrytypes.SignalMetrics
+	}
+	return telemetrytypes.Signal{}
+}

pkg/types/dashboardtypes/perses_v1_to_v2_queries_malformed.go

@@ -0,0 +1,182 @@
+package dashboardtypes
+
+import (
+	"context"
+	"log/slog"
+	"regexp"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/transition"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// ══════════════════════════════════════════════
+// Malformed-field normalization
+// ══════════════════════════════════════════════
+//
+// Pre-v5 query-body reshapes for dashboards whose bodies aren't actually v5-shaped
+// (e.g. stamped version:"v5" but never upgraded). The bulk of the upgrade is
+// delegated to transition.MigrateQueryDataShapeSafe (see normalizePreV5QueryData);
+// this file keeps only the reshapes it doesn't cover.
+
+// preV5Migrator runs transition's shape-safe (idempotent) v4→v5 upgrade. Stateless
+// after construction, so a shared instance with a discard logger / no ambiguity
+// keys is fine.
+var preV5Migrator = transition.NewDashboardMigrateV5(slog.New(slog.DiscardHandler), nil, nil)
+
+// normalizePreV5QueryData upgrades one builder queryData/formula in place: the
+// shared migrator, then a reshape of any existing aggregations[] it leaves alone.
+func normalizePreV5QueryData(query map[string]any, widgetType string) {
+	preV5Migrator.MigrateQueryDataShapeSafe(context.Background(), query, widgetType)
+	normalizePreV5LogTraceAggregations(query)
+}
+
+// aggExprRe matches one "func(args)" with an optional "as alias". Mirrors the
+// frontend's parseAggregations regex; matching only well-formed func(args)
+// discards trailing junk ("sum(x) ) )" → "sum(x)").
+var aggExprRe = regexp.MustCompile(`([a-zA-Z0-9_]+\([^)]*\))(?:\s*as\s+('[^']*'|"[^"]*"|[a-zA-Z0-9_-]+))?`)
+
+// normalizePreV5LogTraceAggregations reshapes an existing logs/traces aggregations[]
+// via parseAggregations (extract func(args), lift inline "as alias", split
+// multi-part, drop metric-only fields; empty → count()). Covers the case the
+// migrator skips: it builds from flat fields but leaves a present-but-malformed
+// aggregations[] alone. A query with none is left as-is.
+func normalizePreV5LogTraceAggregations(query map[string]any) {
+	switch signalFromDataSource(query["dataSource"]) {
+	case telemetrytypes.SignalLogs, telemetrytypes.SignalTraces:
+	default:
+		return
+	}
+	aggs, ok := query["aggregations"].([]any)
+	if !ok || len(aggs) == 0 {
+		return
+	}
+	out := make([]any, 0, len(aggs))
+	for _, a := range aggs {
+		agg, ok := a.(map[string]any)
+		if !ok {
+			continue
+		}
+		expr, _ := agg["expression"].(string)
+		alias, _ := agg["alias"].(string)
+		parsed := parseAggregations(expr, alias)
+		if len(parsed) == 0 {
+			parsed = []any{map[string]any{"expression": "count()"}}
+		}
+		out = append(out, parsed...)
+	}
+	query["aggregations"] = out
+}
+
+// ensureDefaultAggregation defaults an empty logs/traces aggregations[] to count(),
+// mirroring the frontend. Callers gate this to aggregation panels. Metrics are skipped:
+// count() can't stand in for a missing metricName.
+func ensureDefaultAggregation(query map[string]any) {
+	switch signalFromDataSource(query["dataSource"]) {
+	case telemetrytypes.SignalLogs, telemetrytypes.SignalTraces:
+	default:
+		return
+	}
+	if aggs, ok := query["aggregations"].([]any); ok && len(aggs) > 0 {
+		return
+	}
+	query["aggregations"] = []any{map[string]any{"expression": "count()"}}
+}
+
+// parseAggregations pulls every func(args) (with inline or passed-through alias,
+// quotes stripped) out of a v1 expression. Mirrors the frontend's
+// parseAggregations; empty result if none.
+func parseAggregations(expression, availableAlias string) []any {
+	matches := aggExprRe.FindAllStringSubmatch(expression, -1)
+	out := make([]any, 0, len(matches))
+	for _, m := range matches {
+		alias := m[2]
+		if alias == "" {
+			alias = availableAlias
+		}
+		agg := map[string]any{"expression": m[1]}
+		if alias != "" {
+			agg["alias"] = strings.Trim(alias, `'"`)
+		}
+		out = append(out, agg)
+	}
+	return out
+}
+
+// normalizePreV5SelectColumns lets WrapInV5Envelope (which reads the old
+// {key,dataType,type}) handle selectColumns stored the v5 way ({name,…}): backfill
+// key/dataType/type from name/fieldDataType/fieldContext, drop columns with no
+// resolvable key. Inverse of normalizePreV5FieldKeys (the two consumers want
+// opposite shapes).
+func normalizePreV5SelectColumns(query map[string]any) {
+	cols, ok := query["selectColumns"].([]any)
+	if !ok {
+		return
+	}
+	out := make([]any, 0, len(cols))
+	for _, c := range cols {
+		col, ok := c.(map[string]any)
+		if !ok {
+			continue
+		}
+		if _, ok := col["key"]; !ok {
+			if name, ok := col["name"]; ok {
+				col["key"] = name
+			}
+		}
+		if _, ok := col["dataType"]; !ok {
+			if fdt, ok := col["fieldDataType"]; ok {
+				col["dataType"] = fdt
+			}
+		}
+		if _, ok := col["type"]; !ok {
+			if fc, ok := col["fieldContext"]; ok {
+				col["type"] = fc
+			}
+		}
+		if key, _ := col["key"].(string); key == "" {
+			continue
+		}
+		out = append(out, col)
+	}
+	query["selectColumns"] = out
+}
+
+// normalizePreV5FieldKeys renames list-panel field keys {key,dataType,type} →
+// {name,fieldDataType,fieldContext} in place (as WrapInV5Envelope does for
+// groupBy/orderBy). Entries already carrying "name" are left as-is.
+func normalizePreV5FieldKeys(fields []any) {
+	for _, f := range fields {
+		field, ok := f.(map[string]any)
+		if !ok {
+			continue
+		}
+		if _, hasName := field["name"]; hasName {
+			continue
+		}
+		if key, ok := field["key"]; ok {
+			field["name"] = key
+		}
+		if dataType, ok := field["dataType"]; ok {
+			field["fieldDataType"] = dataType
+		}
+		if typ, ok := field["type"]; ok {
+			field["fieldContext"] = typ
+		}
+	}
+}
+
+// normalizePreV5PageSize backfills limit from the legacy pageSize (frontend's
+// `limit || pageSize`), for row-limited panels (list/table) only. Leaves a query
+// that already has limit, or a non-row-limited panel, untouched.
+func normalizePreV5PageSize(query map[string]any, rowLimitPanel bool) {
+	if !rowLimitPanel {
+		return
+	}
+	if limit, ok := query["limit"]; ok && limit != nil {
+		return
+	}
+	if ps, ok := query["pageSize"]; ok {
+		query["limit"] = ps
+	}
+}

pkg/types/dashboardtypes/perses_v1_to_v2_tags.go

@@ -0,0 +1,122 @@
+package dashboardtypes
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
+	"github.com/SigNoz/signoz/pkg/types/tagtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// ══════════════════════════════════════════════
+// Tags
+// ══════════════════════════════════════════════
+
+// v1 carries tags as a flat []string; v2 tags are (key, value) pairs. Each v1
+// string is normalized into a pair (separator split, empty-side fallback,
+// reserved-key prefix, `/` scrub). Tags that normalize to the same
+// (lower(key), lower(value)) within a dashboard are collapsed, first occurrence
+// winning the display casing.
+//
+// Characters still illegal after normalization (spaces, punctuation) are molded
+// to fit the tag validators: disallowed runs collapse to "_" (see moldTagField).
+
+// defaultV1TagKey is the key assigned when a v1 tag string has no usable
+// separator (or one side of the split is empty).
+const defaultV1TagKey = "tag"
+
+func (d *v1Decoder) convertV1TagsForOrg(orgID valuer.UUID, raw any) []*tagtypes.Tag {
+	if raw == nil {
+		return nil
+	}
+	rawTagsList, ok := raw.([]any)
+	if !ok {
+		d.noteMalformedField("tags", raw)
+		return nil
+	}
+	seen := make(map[string]struct{}, len(rawTagsList))
+	tagsV2 := make([]*tagtypes.Tag, 0, len(rawTagsList))
+	for i, rawTag := range rawTagsList {
+		s, ok := rawTag.(string)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("tags[%d]", i), rawTag)
+			continue
+		}
+		key, value, ok := normalizeV1Tag(s)
+		if !ok {
+			continue
+		}
+		dedupKey := strings.ToLower(key) + "\x00" + strings.ToLower(value)
+		if _, dup := seen[dedupKey]; dup {
+			continue
+		}
+		seen[dedupKey] = struct{}{}
+		tagsV2 = append(tagsV2, tagtypes.NewTag(orgID, coretypes.KindDashboard, key, value))
+	}
+	return tagsV2
+}
+
+// normalizeV1Tag derives a (key, value) pair from one v1 tag string. After
+// splitting and molding both sides, a lone survivor becomes a value under the
+// default key; ok is false if neither survives.
+func normalizeV1Tag(s string) (string, string, bool) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return "", "", false
+	}
+
+	var rawKey, rawValue string
+	switch {
+	case strings.Contains(s, ":"):
+		rawKey, rawValue, _ = strings.Cut(s, ":")
+		// Only the first ":" separates key from value; collapse the rest.
+		rawValue = strings.ReplaceAll(rawValue, ":", "_")
+	case strings.Contains(s, "/"):
+		rawKey, rawValue, _ = strings.Cut(s, "/")
+	default:
+		rawValue = s
+	}
+	rawKey = strings.TrimSpace(rawKey)
+	rawValue = strings.TrimSpace(rawValue)
+
+	// Reserved-key collision: prefix "_" so the list-query DSL stays unambiguous.
+	if _, reserved := reservedDSLKeys[DSLKey(strings.ToLower(rawKey))]; rawKey != "" && reserved {
+		rawKey = "_" + rawKey
+	}
+
+	key := moldTagField(rawKey, tagKeyDisallowed, tagKeyNotLead, tagtypes.MAX_LEN_TAG_KEY)
+	value := moldTagField(rawValue, tagValueDisallowed, nil, tagtypes.MAX_LEN_TAG_VALUE)
+	switch {
+	case key == "" && value == "":
+		return "", "", false
+	case key == "":
+		return defaultV1TagKey, value, true
+	case value == "":
+		return defaultV1TagKey, key, true
+	default:
+		return key, value, true
+	}
+}
+
+// Inverse of tagKeyRegex/tagValueRegex ("/" always rejected); tagKeyNotLead
+// matches a bad first char for a key. TestMoldedV1TagsPassValidation guards drift.
+var (
+	tagKeyDisallowed   = regexp.MustCompile(`[^a-zA-Z0-9$_@#{}:-]+`)
+	tagValueDisallowed = regexp.MustCompile(`[^a-zA-Z0-9$_@#{}:.+=-]+`)
+	tagKeyNotLead      = regexp.MustCompile(`^[^a-zA-Z$_@{#]`)
+)
+
+// moldTagField collapses disallowed runs to "_", prefixes "_" if notLead hits
+// the first char, and caps at max. Keeps a leading "_", trims a trailing one.
+func moldTagField(s string, disallowed, notLead *regexp.Regexp, max int) string {
+	s = strings.TrimRight(disallowed.ReplaceAllString(s, "_"), "_")
+	if s != "" && notLead != nil && notLead.MatchString(s) {
+		s = "_" + s
+	}
+	if len(s) > max {
+		s = strings.TrimRight(s[:max], "_")
+	}
+	return s
+}

pkg/types/dashboardtypes/perses_v1_to_v2_variables.go

@@ -0,0 +1,173 @@
+package dashboardtypes
+
+import (
+	"sort"
+
+	"github.com/perses/spec/go/dashboard/variable"
+)
+
+// ══════════════════════════════════════════════
+// Variables
+// ══════════════════════════════════════════════
+
+// convertV1Variables walks the v1 `variables` map (UUID-keyed) and produces an
+// ordered []Variable. Variables sort by `order` first, then by id for stable
+// output. v1 variable types map as follows:
+//
+//	QUERY    → ListVariable + signoz/QueryVariable
+//	CUSTOM   → ListVariable + signoz/CustomVariable
+//	DYNAMIC  → ListVariable + signoz/DynamicVariable
+//	TEXTBOX  → TextVariable
+func (d *v1Decoder) convertV1Variables(raw any) []Variable {
+	if raw == nil {
+		return nil
+	}
+	rawVariablesMap, ok := raw.(map[string]any)
+	if !ok {
+		d.noteMalformedField("variables", raw)
+		return nil
+	}
+	type ordered struct {
+		variableID      string
+		variableContent map[string]any
+		order           float64
+	}
+	entries := make([]ordered, 0, len(rawVariablesMap))
+	for variableID, variableContentRaw := range rawVariablesMap {
+		variableContent, ok := variableContentRaw.(map[string]any)
+		if !ok {
+			d.noteMalformedField("variables."+variableID, variableContentRaw)
+			continue
+		}
+		entries = append(entries, ordered{variableID: variableID, variableContent: variableContent, order: d.readFloat(variableContent, "order")})
+	}
+	sort.SliceStable(entries, func(i, j int) bool {
+		if entries[i].order != entries[j].order {
+			return entries[i].order < entries[j].order
+		}
+		return entries[i].variableID < entries[j].variableID
+	})
+
+	variablesV2 := make([]Variable, 0, len(entries))
+	for _, e := range entries {
+		v, ok := d.convertV1Variable(e.variableContent)
+		if !ok {
+			continue
+		}
+		variablesV2 = append(variablesV2, v)
+	}
+	return variablesV2
+}
+
+func (d *v1Decoder) convertV1Variable(v map[string]any) (Variable, bool) {
+	name := d.readString(v, "name")
+	if name == "" {
+		return Variable{}, false
+	}
+	description := d.readString(v, "description")
+	kind := d.readString(v, "type")
+
+	switch kind {
+	case "TEXTBOX":
+		spec := &TextVariableSpec{
+			Display: Display{Name: name, Description: description},
+			Value:   d.readString(v, "textboxValue"),
+			Name:    name,
+		}
+		return Variable{Kind: variable.KindText, Spec: spec}, true
+
+	case "QUERY", "CUSTOM", "DYNAMIC":
+		// Drop (don't fail on) a dynamic variable with no attribute — it can't resolve.
+		if kind == "DYNAMIC" && d.readString(v, "dynamicVariablesAttribute") == "" {
+			return Variable{}, false
+		}
+		listSpec := &ListVariableSpec{
+			Display:         Display{Name: name, Description: description},
+			AllowAllValue:   d.readBool(v, "showALLOption"),
+			AllowMultiple:   d.readBool(v, "multiSelect"),
+			CustomAllValue:  d.readString(v, "customAllValue"),
+			CapturingRegexp: d.readString(v, "capturingRegexp"),
+			Sort:            mapV1Sort(d.readString(v, "sort")),
+			Plugin:          d.variablePluginFor(kind, v),
+			Name:            name,
+		}
+		if dv := mapV1VariableDefault(v); dv != nil {
+			listSpec.DefaultValue = dv
+		}
+		return Variable{Kind: variable.KindList, Spec: listSpec}, true
+
+	default:
+		d.note("variable %q has unknown type %q", name, kind)
+		return Variable{}, false
+	}
+}
+
+func (d *v1Decoder) variablePluginFor(kind string, v map[string]any) VariablePlugin {
+	switch kind {
+	case "QUERY":
+		return VariablePlugin{
+			Kind: VariableKindQuery,
+			Spec: &QueryVariableSpec{QueryValue: d.readString(v, "queryValue")},
+		}
+	case "CUSTOM":
+		return VariablePlugin{
+			Kind: VariableKindCustom,
+			Spec: &CustomVariableSpec{CustomValue: d.readString(v, "customValue")},
+		}
+	case "DYNAMIC":
+		spec := &DynamicVariableSpec{Name: d.readString(v, "dynamicVariablesAttribute")}
+		if signal := signalFromDataSource(v["dynamicVariablesSource"]); !signal.IsZero() {
+			spec.Signal = signal
+		}
+		return VariablePlugin{Kind: VariableKindDynamic, Spec: spec}
+	}
+	return VariablePlugin{}
+}
+
+// mapV1VariableDefault reads selectedValue/defaultValue, both polymorphic
+// (string|array), so it indexes the raw value and lets defaultValueFromAny
+// type-switch — no typed accessor, intentionally lenient.
+func mapV1VariableDefault(v map[string]any) *VariableDefaultValue {
+	if raw, ok := v["selectedValue"]; ok {
+		return defaultValueFromAny(raw)
+	}
+	if raw, ok := v["defaultValue"]; ok {
+		return defaultValueFromAny(raw)
+	}
+	return nil
+}
+
+func defaultValueFromAny(raw any) *VariableDefaultValue {
+	switch v := raw.(type) {
+	case string:
+		if v == "" {
+			return nil
+		}
+		return &VariableDefaultValue{variable.DefaultValue{SingleValue: v}}
+	case []any:
+		if len(v) == 0 {
+			return nil
+		}
+		values := make([]string, 0, len(v))
+		for _, item := range v {
+			if s, ok := item.(string); ok && s != "" {
+				values = append(values, s)
+			}
+		}
+		if len(values) == 0 {
+			return nil
+		}
+		return &VariableDefaultValue{variable.DefaultValue{SliceValues: values}}
+	}
+	return nil
+}
+
+func mapV1Sort(s string) ListVariableSpecSort {
+	switch s {
+	case "ASC":
+		return SortAlphabeticalAsc
+	case "DESC":
+		return SortAlphabeticalDesc
+	}
+	return ListVariableSpecSort{} // zero (omitzero) — SortNone is the implicit default
+}

pkg/types/querybuildertypes/querybuildertypesv5/migrate_envelope.go

@@ -0,0 +1,127 @@
+package querybuildertypesv5
+
+// WrapInV5Envelope translates a single v4 builder query/formula map into a
+// v5 query envelope ({"type": ..., "spec": ...}). It is a pure shape transform
+// over untyped maps: v4 builder field names (groupBy/orderBy/selectColumns/
+// dataSource) are rewritten to their v5 equivalents and a `signal` is derived
+// from the data source. queryType selects the envelope type, except a formula
+// (detected when name != queryMap["expression"]) is always emitted as
+// "builder_formula".
+//
+// Migration code (pkg/transition) and the v1→v2 dashboard conversion both
+// produce v5 envelopes, so this lives here with the v5 query types rather than
+// in an infra-level package.
+func WrapInV5Envelope(name string, queryMap map[string]any, queryType string) map[string]any {
+	// Create a properly structured v5 query
+	v5Query := map[string]any{
+		"name":     name,
+		"disabled": queryMap["disabled"],
+		"legend":   queryMap["legend"],
+	}
+
+	if name != queryMap["expression"] {
+		// formula
+		queryType = "builder_formula"
+		v5Query["expression"] = queryMap["expression"]
+		if functions, ok := queryMap["functions"]; ok {
+			v5Query["functions"] = functions
+		}
+		return map[string]any{
+			"type": queryType,
+			"spec": v5Query,
+		}
+	}
+
+	// Add signal based on data source
+	if dataSource, ok := queryMap["dataSource"].(string); ok {
+		switch dataSource {
+		case "traces":
+			v5Query["signal"] = "traces"
+		case "logs":
+			v5Query["signal"] = "logs"
+		case "metrics":
+			v5Query["signal"] = "metrics"
+		}
+	}
+
+	if stepInterval, ok := queryMap["stepInterval"]; ok {
+		v5Query["stepInterval"] = stepInterval
+	}
+
+	if aggregations, ok := queryMap["aggregations"]; ok {
+		v5Query["aggregations"] = aggregations
+	}
+
+	if filter, ok := queryMap["filter"]; ok {
+		v5Query["filter"] = filter
+	}
+
+	// Copy groupBy with proper structure
+	if groupBy, ok := queryMap["groupBy"].([]any); ok {
+		v5GroupBy := make([]any, len(groupBy))
+		for i, gb := range groupBy {
+			if gbMap, ok := gb.(map[string]any); ok {
+				v5GroupBy[i] = map[string]any{
+					"name":          gbMap["key"],
+					"fieldDataType": gbMap["dataType"],
+					"fieldContext":  gbMap["type"],
+				}
+			}
+		}
+		v5Query["groupBy"] = v5GroupBy
+	}
+
+	// Copy orderBy with proper structure
+	if orderBy, ok := queryMap["orderBy"].([]any); ok {
+		v5OrderBy := make([]any, len(orderBy))
+		for i, ob := range orderBy {
+			if obMap, ok := ob.(map[string]any); ok {
+				v5OrderBy[i] = map[string]any{
+					"key": map[string]any{
+						"name":          obMap["columnName"],
+						"fieldDataType": obMap["dataType"],
+						"fieldContext":  obMap["type"],
+					},
+					"direction": obMap["order"],
+				}
+			}
+		}
+		v5Query["order"] = v5OrderBy
+	}
+
+	// Copy selectColumns as selectFields
+	if selectColumns, ok := queryMap["selectColumns"].([]any); ok {
+		v5SelectFields := make([]any, len(selectColumns))
+		for i, col := range selectColumns {
+			if colMap, ok := col.(map[string]any); ok {
+				v5SelectFields[i] = map[string]any{
+					"name":          colMap["key"],
+					"fieldDataType": colMap["dataType"],
+					"fieldContext":  colMap["type"],
+				}
+			}
+		}
+		v5Query["selectFields"] = v5SelectFields
+	}
+
+	// Copy limit and offset
+	if limit, ok := queryMap["limit"]; ok {
+		v5Query["limit"] = limit
+	}
+	if offset, ok := queryMap["offset"]; ok {
+		v5Query["offset"] = offset
+	}
+
+	if having, ok := queryMap["having"]; ok {
+		v5Query["having"] = having
+	}
+
+	if functions, ok := queryMap["functions"]; ok {
+		v5Query["functions"] = functions
+	}
+
+	return map[string]any{
+		"type": queryType,
+		"spec": v5Query,
+	}
+}