feat(dashboard-v2): batch initial variable auto-selections into one fetch

Auto-selection now flows through a dedicated onAutoSelect path, separate from
user changes. The initial load burst of fills (each selector picks a value as
its options resolve, at different times) is coalesced across one animation frame
into a single store write plus one enqueueDescendantsBatch, so dependent
variables re-fetch once with the settled parent values instead of once per fill.

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 concurrent queries for missing ranges.
-  max_concurrent_queries: 4
+  # The maximum number of queries a single query range request runs at once.
+  max_concurrent_queries: 8
   # 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,6 +2682,7 @@ components:
         unit:
           type: string
         value:
+          format: double
           type: number
       required:
       - value
@@ -3648,6 +3649,7 @@ components:
         unit:
           type: string
         value:
+          format: double
           type: number
       required:
       - value
@@ -3684,6 +3686,7 @@ components:
         unit:
           type: string
         value:
+          format: double
           type: number
       required:
       - value

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

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

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

@@ -2,6 +2,7 @@ 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;
@@ -46,9 +47,11 @@ function CheckboxValueRow({
 				{customRendererForValue ? (
 					customRendererForValue(value)
 				) : (
-					<Typography.Text className="value-string" truncate={1}>
-						{String(value)}
-					</Typography.Text>
+					<TooltipSimple title={value} side="top" align="center" arrow>
+						<Typography.Text className="value-string" truncate={1}>
+							{String(value)}
+						</Typography.Text>
+					</TooltipSimple>
 				)}
 				<Button type="text" className="only-btn">
 					{onlyButtonLabel}

frontend/src/constants/localStorage.ts

@@ -31,6 +31,7 @@ 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,6 +149,18 @@
 		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,6 +43,7 @@ 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';
 
@@ -515,7 +516,9 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 				</div>
 			)}
 			{!isEmpty(description) && (
-				<section className="dashboard-description-section">{description}</section>
+				<section className="dashboard-description-section">
+					{linkifyText(description ?? '')}
+				</section>
 			)}
 
 			{!isEmpty(dashboardVariables) && (

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

@@ -32,6 +32,22 @@
 	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,6 +14,7 @@ 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';
@@ -143,7 +144,14 @@ function DashboardInfo({
 			)}
 
 			{hasDescription && (
-				<TooltipSimple title={description} disableHoverableContent>
+				<TooltipSimple
+					side="bottom"
+					title={
+						<span className={styles.descriptionTooltip}>
+							{linkifyText(description)}
+						</span>
+					}
+				>
 					<SolidInfoCircle
 						className={styles.descriptionIcon}
 						size={14}

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

@@ -48,6 +48,13 @@
 	gap: 12px;
 }
 
+.footerStatus {
+	display: flex;
+	min-width: 0;
+	flex-direction: column;
+	gap: 2px;
+}
+
 .validation {
 	min-width: 0;
 	overflow: hidden;
@@ -57,6 +64,32 @@
 	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,6 +1,8 @@
 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';
@@ -26,8 +28,18 @@ function JsonEditorDrawer({
 }: JsonEditorDrawerProps): JSX.Element {
 	const [, copyToClipboard] = useCopyToClipboard();
 
-	const { draft, setDraft, validity, isDirty, isSaving, format, reset, apply } =
-		useJsonEditor({ dashboard, isOpen, onApplied: onClose });
+	const {
+		draft,
+		setDraft,
+		validity,
+		isDirty,
+		isSaving,
+		danglingPanelIds,
+		missingPanelRefs,
+		format,
+		reset,
+		apply,
+	} = useJsonEditor({ dashboard, isOpen, onApplied: onClose });
 
 	const onCopy = useCallback((): void => {
 		copyToClipboard(draft);
@@ -48,6 +60,7 @@ function JsonEditorDrawer({
 
 	const onKeyDown = useCallback(
 		(event: KeyboardEvent<HTMLDivElement>): void => {
+			event.stopPropagation();
 			if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
 				event.preventDefault();
 				void apply();
@@ -60,6 +73,19 @@ 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
@@ -71,15 +97,49 @@ function JsonEditorDrawer({
 			rootClassName={styles.root}
 			footer={
 				<div className={styles.footer}>
-					<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.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>
 					<div className={styles.footerActions}>
 						<Button
 							variant="outlined"

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

@@ -1,4 +1,5 @@
 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';
@@ -48,11 +49,13 @@ 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', () => {
@@ -81,6 +84,42 @@ 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

@@ -0,0 +1,69 @@
+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,4 +203,47 @@ 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

@@ -0,0 +1,47 @@
+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,11 +1,15 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { toast } from '@signozhq/ui/sonner';
 import { updateDashboardV2 } from 'api/generated/services/dashboard';
-import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
+import type {
+	DashboardtypesDashboardSpecDTO,
+	DashboardtypesGettableDashboardV2DTO,
+} from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
+import { toAPIError } from 'utils/errorUtils';
 
 import { dashboardToUpdatable } from './dashboardToUpdatable';
+import { findPanelLayoutIssues } from './danglingPanels';
 import { useDashboardStore } from '../../store/useDashboardStore';
 
 export interface JsonValidity {
@@ -28,6 +32,10 @@ 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>;
@@ -109,6 +117,23 @@ 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));
@@ -138,7 +163,7 @@ export function useJsonEditor({
 			refetch();
 			onApplied();
 		} catch (error) {
-			showErrorModal(error as APIError);
+			showErrorModal(toAPIError(error as Parameters<typeof toAPIError>[0]));
 		} finally {
 			setIsSaving(false);
 		}
@@ -159,6 +184,8 @@ export function useJsonEditor({
 		validity,
 		isDirty,
 		isSaving,
+		danglingPanelIds,
+		missingPanelRefs,
 		format,
 		reset,
 		apply,

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

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
+import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
 import type {
 	DashboardtypesGettableDashboardV2DTO,
 	DashboardtypesJSONPatchOperationDTO,
@@ -54,20 +55,32 @@ 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: 'replace' as DashboardtypesJSONPatchOperationDTO['op'],
-			path,
-			value,
-		});
+		): DashboardtypesJSONPatchOperationDTO =>
+			op(DashboardtypesPatchOpDTO.replace, path, value);
 
 		if (updatedTitle !== title && updatedTitle !== '') {
 			ops.push(replace('/spec/display/name', updatedTitle));
 		}
 		if (updatedDescription !== description) {
-			ops.push(replace('/spec/display/description', updatedDescription));
+			// `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,
+				),
+			);
 		}
 		if (updatedImage !== image) {
 			ops.push(replace('/image', updatedImage));

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

@@ -46,8 +46,12 @@ export interface UseVariableForm {
 	handleSave: () => void;
 }
 
-const readDefaultValue = (model: VariableFormModel): string =>
-	((model.defaultValue as { value?: string })?.value ?? '') as string;
+// `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 ?? '');
+};
 
 /** 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,6 +75,7 @@ function VariableSelector({
 						selections={selections}
 						selection={selection}
 						onChange={onChange}
+						onAutoSelect={onAutoSelect}
 					/>
 				);
 			case 'CUSTOM':

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

@@ -112,3 +112,13 @@
 		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,14 +1,33 @@
 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;
 }
@@ -23,7 +42,7 @@ interface VariablesBarProps {
  * either way so auto-selection and option fetching keep driving the panels.
  */
 function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
-	const { variables, dependencyData, selection, setSelection } =
+	const { variables, selection, setSelection, autoSelect } =
 		useVariableSelection(dashboard);
 	const [expanded, setExpanded] = useState(false);
 	const { containerRef, visibleCount, overflowCount } = useInlineOverflowCount({
@@ -38,6 +57,22 @@ 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">
@@ -57,7 +92,6 @@ function VariablesBar({ dashboard }: VariablesBarProps): JSX.Element | null {
 						<VariableSelector
 							variable={variable}
 							variables={variables}
-							parents={dependencyData.parentGraph[variable.name] ?? []}
 							selections={selection}
 							selection={
 								selection[variable.name] ?? {
@@ -66,23 +100,32 @@ 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}>
-						<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>
+						{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>
+						)}
 					</span>
 				)}
 			</div>

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

@@ -1,7 +1,8 @@
 import { useMemo } from 'react';
+import { useQuery } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
-import { useGetFieldValues } from 'hooks/dynamicVariables/useGetFieldValues';
+import { getFieldValues } from 'api/dynamicVariables/getFieldValues';
 import type { AppState } from 'store/reducers';
 import type { GlobalReducer } from 'types/reducer/globalTime';
 
@@ -10,12 +11,14 @@ 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 {
@@ -25,12 +28,16 @@ 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`).
+ * (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.
  */
 function DynamicSelector({
 	variable,
@@ -38,6 +45,7 @@ function DynamicSelector({
 	selections,
 	selection,
 	onChange,
+	onAutoSelect,
 }: DynamicSelectorProps): JSX.Element {
 	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
@@ -48,14 +56,51 @@ function DynamicSelector({
 		[variables, selections, variable.name],
 	);
 
-	const { data, isFetching } = useGetFieldValues({
-		signal: signalForApi(variable.dynamicSignal),
-		name: variable.dynamicAttribute,
-		startUnixMilli: minTime,
-		endUnixMilli: maxTime,
-		existingQuery: existingQuery || undefined,
-		enabled: !!variable.dynamicAttribute,
-	});
+	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 options = useMemo(() => {
 		const payload = data?.data;
@@ -64,14 +109,14 @@ function DynamicSelector({
 		return sortValuesByOrder(values, variable.sort).map(String);
 	}, [data, variable.sort]);
 
-	useAutoSelect(variable, options, selection, onChange);
+	useAutoSelect(variable, options, selection, onAutoSelect);
 
 	return (
 		<ValueSelector
 			options={options}
 			multiSelect={variable.multiSelect}
 			showAllOption={variable.showAllOption}
-			loading={isFetching}
+			loading={isFetching || isVariableWaiting}
 			selection={selection}
 			onChange={onChange}
 			testId={`variable-select-${variable.name}`}

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

@@ -8,58 +8,82 @@ 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 { isResolved, selectionToPayload } from '../selectionUtils';
+import { 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. 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).
+ * 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).
  */
 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 enabled = parents.every((parent) => isResolved(selections[parent]));
+
+	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',
 			variable.name,
 			variable.queryValue,
-			payload,
 			minTime,
 			maxTime,
+			variableFetchCycleId,
 		],
 		() =>
 			dashboardVariablesQuery({
 				query: variable.queryValue,
 				variables: payload,
 			}),
-		{ enabled, refetchOnWindowFocus: false },
+		{
+			enabled: isVariableFetching || (isVariableSettled && hasVariableFetchedOnce),
+			refetchOnWindowFocus: false,
+			onSettled: (_, error) =>
+				error
+					? onVariableFetchFailure(variable.name)
+					: onVariableFetchComplete(variable.name),
+		},
 	);
 
 	const options = useMemo(() => {
@@ -72,14 +96,14 @@ function QuerySelector({
 		).map(String);
 	}, [data, variable.sort]);
 
-	useAutoSelect(variable, options, selection, onChange);
+	useAutoSelect(variable, options, selection, onAutoSelect);
 
 	return (
 		<ValueSelector
 			options={options}
 			multiSelect={variable.multiSelect}
 			showAllOption={variable.showAllOption}
-			loading={isFetching}
+			loading={isFetching || isVariableWaiting}
 			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,
-	onChange: (selection: VariableSelection) => void,
+	onAutoSelect: (selection: VariableSelection) => void,
 ): void {
 	useEffect(() => {
 		if (options.length === 0 || selection.allSelected) {
@@ -28,11 +28,11 @@ export function useAutoSelect(
 		if (isValid) {
 			return;
 		}
-		const fallback = (variable.defaultValue as { value?: string } | undefined)
-			?.value;
+		const dv = variable.defaultValue;
+		const fallback = Array.isArray(dv) ? dv[0] : dv;
 		const initial =
 			fallback && options.includes(fallback) ? fallback : options[0];
-		onChange({
+		onAutoSelect({
 			value: variable.multiSelect ? [initial] : initial,
 			allSelected: false,
 		});

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

@@ -0,0 +1,44 @@
+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,6 +1,10 @@
-import { useCallback, useEffect, useMemo } from 'react';
+import { useCallback, useEffect, useMemo, useRef } 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';
@@ -12,8 +16,8 @@ import type {
 	VariableSelectionMap,
 } from './selectionTypes';
 import {
-	computeVariableDependencies,
-	type VariableDependencyData,
+	deriveFetchContext,
+	doAllQueryVariablesHaveValues,
 } from './variableDependencies';
 
 /** URL sentinel for an "ALL values selected" state (matches V1). */
@@ -29,12 +33,14 @@ export const variablesUrlParser = parseAsJson<
 );
 
 function defaultSelection(model: VariableFormModel): VariableSelection {
-	const def = (
-		model.defaultValue as { value?: SelectedVariableValue } | undefined
-	)?.value;
-	if (def !== undefined && def !== null && def !== '') {
+	// `defaultValue` is a string | string[] on the wire.
+	const def = model.defaultValue;
+	if (Array.isArray(def) && def.length > 0) {
 		return { value: def, allSelected: false };
 	}
+	if (typeof def === 'string' && def !== '') {
+		return { value: model.multiSelect ? [def] : def, allSelected: false };
+	}
 	return { value: model.multiSelect ? [] : '', allSelected: false };
 }
 
@@ -46,9 +52,14 @@ 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;
 }
 
 /**
@@ -65,27 +76,37 @@ export function useVariableSelection(
 		() => (dashboard.spec?.variables ?? []).map(dtoToFormModel),
 		[dashboard.spec?.variables],
 	);
-	const dependencyData = useMemo(
-		() => computeVariableDependencies(variables),
-		[variables],
-	);
+	const fetchContext = useMemo(() => deriveFetchContext(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 for this dashboard: URL wins, then persisted store, then default.
+	// Seed selections: 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) => {
@@ -102,16 +123,83 @@ 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, setUrlValues],
+		[dashboardId, setVariableValue, enqueueDescendants, setUrlValues],
 	);
 
-	return { variables, dependencyData, selection, setSelection };
+	// 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 };
 }

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

@@ -1,6 +1,11 @@
 import { textContainsVariableReference } from 'lib/dashboardVariables/variableReference';
 
-import type { VariableFormModel } from '../DashboardSettings/Variables/variableFormModel';
+import type {
+	VariableFormModel,
+	VariableType,
+} from '../DashboardSettings/Variables/variableFormModel';
+import type { VariableSelectionMap } from './selectionTypes';
+import { isResolved } from './selectionUtils';
 
 /**
  * Inter-variable dependency graph for runtime selection. A QUERY variable
@@ -197,3 +202,57 @@ 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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,261 @@
+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

@@ -0,0 +1,51 @@
+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,10 +13,15 @@ import {
 	createVariableSelectionSlice,
 	type VariableSelectionSlice,
 } from './slices/variableSelectionSlice';
+import {
+	createVariableFetchSlice,
+	type VariableFetchSlice,
+} from './slices/variableFetchSlice';
 
 export type DashboardStore = EditContextSlice &
 	CollapseSlice &
-	VariableSelectionSlice;
+	VariableSelectionSlice &
+	VariableFetchSlice;
 
 /**
  * V2 dashboard session store. Holds cross-cutting client state only — never the
@@ -31,6 +36,7 @@ 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,6 +7,7 @@ import styles from './DashboardsList.module.scss';
 interface Props {
 	label: string;
 	count: number;
+	isModified: boolean;
 	canCreate: boolean;
 	onCreate: () => void;
 }
@@ -14,6 +15,7 @@ interface Props {
 function CommandHeader({
 	label,
 	count,
+	isModified,
 	canCreate,
 	onCreate,
 }: Props): JSX.Element {
@@ -21,6 +23,7 @@ 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,6 +93,14 @@
 	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,7 +25,6 @@ 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';
@@ -72,13 +71,13 @@ function DashboardsList(): JSX.Element {
 		customViewsLoading,
 		isCustomActive,
 		isModified,
-		viewQuery,
 		clientView,
 		selectView,
 		saveView,
 		saveActiveView,
 		resetView,
 		removeView,
+		renameView,
 	} = useActiveView({
 		filters,
 		applyFilters,
@@ -153,13 +152,13 @@ function DashboardsList(): JSX.Element {
 
 	const listParams = useMemo(
 		() => ({
-			query: combineQueries(viewQuery, query) || undefined,
+			query: query || undefined,
 			sort: sortColumn,
 			order: sortOrder,
 			limit: clientView ? CLIENT_VIEW_LIMIT : PAGE_SIZE,
 			offset: clientView ? 0 : (page - 1) * PAGE_SIZE,
 		}),
-		[viewQuery, query, sortColumn, sortOrder, page, clientView],
+		[query, sortColumn, sortOrder, page, clientView],
 	);
 
 	const {
@@ -195,24 +194,19 @@ function DashboardsList(): JSX.Element {
 	);
 	const total = clientView ? dashboards.length : (response?.data?.total ?? 0);
 
-	// 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]);
+	// 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,
+	});
 
 	// 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
@@ -289,8 +283,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}>
@@ -305,6 +299,7 @@ function DashboardsList(): JSX.Element {
 								<CommandHeader
 									label={activeLabel}
 									count={total}
+									isModified={isModified}
 									canCreate={canCreateNewDashboard}
 									onCreate={openCreate}
 								/>

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

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

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

@@ -145,30 +145,40 @@
 	flex: none;
 }
 
-.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.
+// 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 {
 	position: absolute;
 	right: 6px;
 	top: 50%;
 	transform: translateY(-50%);
-	--button-height: 20px;
-	--button-padding: 0;
-	--button-border-radius: 4px;
-	--button-variant-ghost-color: var(--l3-foreground);
-	--button-variant-ghost-hover-background-color: var(--danger-background);
-	--button-variant-ghost-hover-color: var(--danger-color, #fff);
-	width: 20px;
-	height: 20px;
+	display: flex;
+	align-items: center;
+	gap: 2px;
 	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 .itemAction {
+.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);
+}
+
+.row:hover .itemActions {
 	opacity: 1;
 	pointer-events: auto;
 }

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

@@ -3,12 +3,19 @@ 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, Plus, Search, Trash2 } from '@signozhq/icons';
+import {
+	Bookmark,
+	CircleAlert,
+	PenLine,
+	Plus,
+	Search,
+	Trash2,
+} from '@signozhq/icons';
 import cx from 'classnames';
 
 import type { SavedView } from '../../types';
 import { type BuiltinView } from '../../utils/views';
-import SaveViewPopover from './SaveViewPopover';
+import ViewNamePopover from './ViewNamePopover';
 
 import styles from './ViewsRail.module.scss';
 
@@ -24,8 +31,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 {
@@ -49,10 +56,11 @@ 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();
 
@@ -122,20 +130,44 @@ function ViewsRail({
 					)}
 				</Button>
 				{row.deletable && (
-					<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 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>
 				)}
 			</div>
 		);
@@ -145,10 +177,13 @@ function ViewsRail({
 		<aside className={cx(styles.rail, { [styles.collapsed]: collapsed })}>
 			<div className={styles.header}>
 				<h4 className={styles.headerTitle}>Views</h4>
-				<SaveViewPopover
+				<ViewNamePopover
 					open={saveOpen}
 					onOpenChange={setSaveOpen}
-					onSave={onSave}
+					onSubmit={onSave}
+					title="Save as view"
+					confirmLabel="Save view"
+					testIdPrefix="save-view"
 					trigger={
 						<Button
 							variant="ghost"
@@ -268,13 +303,8 @@ function ViewsRail({
 						>
 							Save as new view
 						</Button>
-						<Button
-							variant="ghost"
-							color="secondary"
-							size="sm"
-							onClick={onClearFilters}
-						>
-							Clear
+						<Button variant="ghost" color="secondary" size="sm" onClick={onReset}>
+							Reset
 						</Button>
 					</div>
 				</div>

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

@@ -7,7 +7,6 @@ import type {
 
 import {
 	areFilterStatesEqual,
-	combineQueries,
 	DEFAULT_FILTER_STATE,
 	filterStateToQuery,
 } from '../utils/filterQuery';
@@ -15,7 +14,6 @@ import { BuiltinViewId } from '../types';
 import type { DashboardFilterState, SavedView } from '../types';
 import {
 	BUILTIN_VIEWS,
-	builtinViewQuery,
 	builtinViewSnapshot,
 	type BuiltinView,
 	isClientView,
@@ -42,15 +40,14 @@ export interface UseActiveViewResult {
 	isCustomActive: boolean;
 	// Current filters diverge from the active view's canonical snapshot.
 	isModified: boolean;
-	// Extra server-query fragment the active view contributes, and whether it
-	// constrains the list client-side (pinned/recent).
-	viewQuery: string;
+	// Whether the active view constrains the list client-side (pinned/recent).
 	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
@@ -127,11 +124,9 @@ export function useActiveView({
 
 	const saveView = useCallback(
 		(name: string): void => {
-			// Fold the current built-in clause + chips into a single query string.
-			const query = combineQueries(
-				builtinViewQuery(activeViewId),
-				filterStateToQuery(filters),
-			);
+			// 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);
 			void (async (): Promise<void> => {
 				const created = await createView({
 					name,
@@ -147,15 +142,7 @@ export function useActiveView({
 				}
 			})();
 		},
-		[
-			activeViewId,
-			filters,
-			createView,
-			sortColumn,
-			sortOrder,
-			setActiveViewId,
-			applyFilters,
-		],
+		[filters, createView, sortColumn, sortOrder, setActiveViewId, applyFilters],
 	);
 
 	const saveActiveView = useCallback((): void => {
@@ -200,6 +187,23 @@ 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,
@@ -207,12 +211,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

@@ -0,0 +1,43 @@
+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,6 +2,7 @@ import { useCallback, useMemo } from 'react';
 import { useQueryClient } from 'react-query';
 import { toast } from '@signozhq/ui/sonner';
 import {
+	getListDashboardViewsQueryKey,
 	invalidateListDashboardViews,
 	useCreateDashboardView,
 	useDeleteDashboardView,
@@ -12,6 +13,7 @@ import {
 	type DashboardtypesDashboardViewDTO,
 	DashboardtypesListOrderDTO,
 	DashboardtypesListSortDTO,
+	type ListDashboardViews200,
 } from 'api/generated/services/sigNoz.schemas';
 
 import type { SavedView, SavedViewInput } from '../types';
@@ -70,9 +72,27 @@ 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: invalidate,
+			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,
+						),
+					},
+				});
+			},
 			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 three mechanisms:
-//   - snapshot:  selecting applies a filter snapshot (All, My dashboards, custom)
-//   - query:     contributes an extra server clause AND-ed with the chips (Locked)
+// 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)
 //   - 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;
 
-// Extra server query fragment a built-in view contributes (AND-ed with chips).
-export const builtinViewQuery = (id: string): string =>
-	id === BuiltinViewId.Locked ? 'locked = true' : '';
+// 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';
 
 // 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,10 +65,11 @@ 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,15 +33,19 @@
 	}
 
 	&.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;
-			display: flex;
-			flex-direction: column;
+
+			.resizable-box__content {
+				display: flex;
+				flex-direction: column;
+				overflow: visible;
+			}
 
 			.quick-filters-container {
 				flex: 1;
@@ -50,7 +54,9 @@
 		}
 
 		.log-module-right-section {
-			width: calc(100% - 260px);
+			flex: 1;
+			width: auto;
+			min-width: 0;
 		}
 	}
 }

frontend/src/pages/LogsExplorer/index.tsx

@@ -26,6 +26,8 @@ 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';
@@ -44,9 +46,23 @@ 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);
 
@@ -226,14 +242,25 @@ function LogsExplorer(): JSX.Element {
 					className={cx('logs-module-page', showFilters ? 'filter-visible' : '')}
 				>
 					{showFilters && (
-						<section className={cx('log-quick-filter-left-section')}>
+						<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"
+						>
 							<QuickFilters
 								className="qf-logs-explorer"
 								signal={SignalType.LOGS}
 								source={QuickFiltersSource.LOGS_EXPLORER}
 								handleFilterVisibilityChange={handleFilterVisibilityChange}
 							/>
-						</section>
+						</ResizableBox>
 					)}
 					<section className={cx('log-module-right-section')}>
 						<Toolbar

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

@@ -18,6 +18,17 @@
 		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);
@@ -55,4 +66,29 @@
 			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,3 +1,4 @@
+import { GripVertical } from '@signozhq/icons';
 import { useCallback, useRef, useState } from 'react';
 
 import './ResizableBox.styles.scss';
@@ -11,15 +12,28 @@ 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({
@@ -31,13 +45,22 @@ 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 ? defaultWidth : defaultHeight);
+	const [size, setSize] = useState(
+		isHorizontal
+			? (initialWidth ?? defaultWidth)
+			: (initialHeight ?? defaultHeight),
+	);
 	const containerRef = useRef<HTMLDivElement>(null);
 
 	const handleMouseDown = useCallback(
@@ -83,6 +106,21 @@ 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
@@ -99,7 +137,22 @@ function ResizableBox({
 			style={containerStyle}
 		>
 			<div className="resizable-box__content">{children}</div>
-			{!disabled && <div className={handleClass} onMouseDown={handleMouseDown} />}
+			{!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>
+			)}
 		</div>
 	);
 }

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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,71 @@
+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,6 +17,7 @@ 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 {
@@ -213,23 +214,37 @@ 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 {
-		hostCounts, err = m.getPerGroupHostStatusCounts(ctx, orgID, req, hostsTableMetricNamesList, pageGroups, sinceUnixMilli)
-		if err != nil {
-			return nil, err
-		}
+		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
 	}
 
 	resp.Records = buildHostRecords(isHostNameInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, activeHostsMap, hostCounts)
@@ -299,23 +314,39 @@ 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
-	}
 
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	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
+	)
 
-	statusCounts, statusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	g, gCtx := errgroup.WithContext(ctx)
 
-	restartCounts, err := m.getPerGroupPodRestartCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -387,23 +418,39 @@ 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
-	}
 
-	nodeConditionCounts, err := m.getPerGroupNodeConditionCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	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
+	)
 
-	podPhaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	g, gCtx := errgroup.WithContext(ctx)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -475,18 +522,33 @@ 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
-	}
 
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp        *qbtypes.QueryRangeResponse
+		phaseCounts      map[string]podPhaseCounts
+		podStatusCounts  map[string]podStatusCounts
+		podStatusWarning *qbtypes.QueryWarnData
+	)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -557,25 +619,41 @@ 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.
-	nodeConditionCountsMap, err := m.getPerGroupNodeConditionCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp              *qbtypes.QueryRangeResponse
+		nodeConditionCountsMap map[string]nodeConditionCounts
+		podPhaseCountsMap      map[string]podPhaseCounts
+		podStatusCounts        map[string]podStatusCounts
+		podStatusWarning       *qbtypes.QueryWarnData
+	)
 
-	podPhaseCountsMap, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	g, gCtx := errgroup.WithContext(ctx)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -730,18 +808,33 @@ 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
-	}
 
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp        *qbtypes.QueryRangeResponse
+		phaseCounts      map[string]podPhaseCounts
+		podStatusCounts  map[string]podStatusCounts
+		podStatusWarning *qbtypes.QueryWarnData
+	)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -818,20 +911,35 @@ 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.
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp        *qbtypes.QueryRangeResponse
+		phaseCounts      map[string]podPhaseCounts
+		podStatusCounts  map[string]podStatusCounts
+		podStatusWarning *qbtypes.QueryWarnData
+	)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -908,20 +1016,35 @@ 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.
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp        *qbtypes.QueryRangeResponse
+		phaseCounts      map[string]podPhaseCounts
+		podStatusCounts  map[string]podStatusCounts
+		podStatusWarning *qbtypes.QueryWarnData
+	)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 
@@ -998,20 +1121,35 @@ 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.
-	phaseCounts, err := m.getPerGroupPodPhaseCounts(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
-		return nil, err
-	}
+	var (
+		queryResp        *qbtypes.QueryRangeResponse
+		phaseCounts      map[string]podPhaseCounts
+		podStatusCounts  map[string]podStatusCounts
+		podStatusWarning *qbtypes.QueryWarnData
+	)
 
-	podStatusCounts, podStatusWarning, err := m.getPerGroupPodStatusCountsWithReqMetricChecks(ctx, req.Start, req.End, req.Filter, req.GroupBy, pageGroups)
-	if err != nil {
+	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 {
 		return nil, err
 	}
 

pkg/querier/config.go

@@ -7,6 +7,8 @@ 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.
@@ -37,7 +39,7 @@ func newConfig() factory.Config {
 		// Default values
 		CacheTTL:             168 * time.Hour,
 		FluxInterval:         5 * time.Minute,
-		MaxConcurrentQueries: 4,
+		MaxConcurrentQueries: DefaultMaxConcurrentQueries,
 		SkipResourceFingerprint: SkipResourceFingerprint{
 			Enabled:   false,
 			Threshold: 100000,

pkg/querier/querier.go

@@ -13,6 +13,7 @@ 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"
@@ -35,20 +36,21 @@ 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
+	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
 }
 
 var _ Querier = (*querier)(nil)
@@ -67,25 +69,30 @@ 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,
 	}
 }
 
@@ -607,30 +614,40 @@ func (q *querier) run(
 		return false
 	}
 
-	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()))
+	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
 			}
-			result, err := query.Execute(ctx)
-			qbEvent.HasData = qbEvent.HasData || hasData(result)
+
+			result, err := q.executeWithCache(egCtx, orgID, query, steps[name], sem)
 			if err != nil {
-				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
+				return err
 			}
 			switch v := result.Value.(type) {
 			case *qbtypes.TimeSeriesData:
@@ -640,14 +657,23 @@ func (q *querier) run(
 			case *qbtypes.RawData:
 				v.QueryName = name
 			}
+			queryResults[i] = result
+			return nil
+		})
+	}
+	if err := eg.Wait(); err != nil {
+		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
-		}
+	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
 	}
 
 	gomaps.Copy(results, preseededResults)
@@ -707,8 +733,9 @@ func (q *querier) run(
 	return resp, nil
 }
 
-// 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) {
+// 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) {
 	// Get cached data and missing ranges
 	cachedResult, missingRanges := q.bucketCache.GetMissRanges(ctx, orgID, query, step)
 
@@ -721,7 +748,9 @@ 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
 			}
@@ -740,7 +769,6 @@ 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 {
@@ -777,7 +805,9 @@ 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,11 +2,13 @@ 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"
@@ -54,7 +56,8 @@ func TestQueryRange_MetricTypeMissing(t *testing.T) {
 		nil,                // traceOperatorStmtBuilder
 		nil,                // bucketCache
 		flaggertest.New(t), // flagger
-		0,
+		0,                  // logTraceIDWindowPadding
+		0,                  // maxConcurrentQueries
 	)
 
 	req := &qbtypes.QueryRangeRequest{
@@ -125,7 +128,8 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {
 		nil,                      // traceOperatorStmtBuilder
 		nil,                      // bucketCache
 		flaggertest.New(t),       // flagger
-		0,
+		0,                        // logTraceIDWindowPadding
+		0,                        // maxConcurrentQueries
 	)
 
 	req := &qbtypes.QueryRangeRequest{
@@ -155,3 +159,149 @@ 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,5 +193,6 @@ func newProvider(
 		bucketCache,
 		flagger,
 		cfg.LogTraceIDWindowPadding,
+		cfg.MaxConcurrentQueries,
 	), nil
 }

pkg/query-service/rules/setups_test.go

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

pkg/transition/migrate_common.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
-	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 )
 
 type migrateCommon struct {
@@ -24,10 +23,119 @@ 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 {
-	return querybuildertypesv5.WrapInV5Envelope(name, queryMap, queryType)
+	// 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,
+	}
 }
 
 func (mc *migrateCommon) updateQueryData(ctx context.Context, queryData map[string]any, version, widgetType string) bool {

pkg/transition/migrate_shape_safe.go

@@ -1,353 +0,0 @@
-// 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,6 +7,7 @@ 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"
@@ -21,7 +22,6 @@ 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,26 +406,27 @@ 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, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_query"))
+			compositeQueries = append(compositeQueries, migrate.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, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_formula"))
+			compositeQueries = append(compositeQueries, migrate.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, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
+			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
 		}
 	case "clickhouse_sql":
 		for _, query := range widgetData.Query.ClickhouseSQL {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1060,34 +1060,6 @@ 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,20 +251,14 @@ type Legend struct {
 }
 
 type ThresholdWithLabel struct {
-	// 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"`
+	Value float64 `json:"value" validate:"required" required:"true"`
+	Unit  string  `json:"unit"`
+	Color string  `json:"color" validate:"required" required:"true"`
+	Label string  `json:"label"`
 }
 
 type ComparisonThreshold struct {
-	// Value is a pointer so a threshold at 0 is valid (see ThresholdWithLabel.Value).
-	Value    *float64           `json:"value" validate:"required" required:"true" nullable:"false"`
+	Value    float64            `json:"value" validate:"required" required:"true"`
 	Operator ComparisonOperator `json:"operator"`
 	Unit     string             `json:"unit"`
 	Color    string             `json:"color" validate:"required" required:"true"`

pkg/types/dashboardtypes/perses_v1_to_v2.go

@@ -1,94 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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

@@ -1,473 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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,
-	}
-}