Merge remote-tracking branch 'origin/main' into ns/scope

## Summary
- Handle malformed selectedFields in the extradata in the migration and
new migration to fix in the already migrated cases.
- Restructure saved-view create/update/get payloads so
`schemaVersion`/`spec` are top-level (unwrapping the old `data`
nesting), matching how dashboards and rules shape their wire types.
- Publish `schemaVersion` as an `enum: [v2]`
- Make `display` and `selectedFields` optional in the OpenAPI schema
- Declare `409` on `CreateSavedView`
- Require `minItems: 1` on `queries`

New API contract in [below
comment](https://github.com/SigNoz/signoz/pull/12477#issuecomment-5230041074),
follow up on https://github.com/SigNoz/signoz/pull/12342
Closes https://github.com/SigNoz/engineering-pod/issues/4651

Notes to reviewer: 
- Please pay attention to the last case in above linked comment for
partial display field updates.
- Still assuming that [migration
046](6372af75a6/pkg/sqlmigration/046_update_dashboard_alert_and_saved_view_v5.go (L233))
has already migrated all the views to v5 QB format and don't need to do
that now.
- Breaking change: queries are not validated in the v1 APIs as well, so
any incorrect query will be rejected

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

.github/workflows/integrationci.yaml

@@ -61,6 +61,7 @@ jobs:
           - querierauthz
           - role
           - rootuser
+          - savedview
           - serviceaccount
           - spanmapper
           - querier_json_body

docs/api/openapi.yml

@@ -7880,17 +7880,20 @@ components:
       type: string
     SavedviewtypesPostableSavedView:
       properties:
-        data:
-          $ref: '#/components/schemas/SavedviewtypesSavedViewData'
         generateName:
           type: boolean
         name:
           type: string
+        schemaVersion:
+          $ref: '#/components/schemas/SavedviewtypesSchemaVersion'
         source:
           $ref: '#/components/schemas/SavedviewtypesSource'
+        spec:
+          $ref: '#/components/schemas/SavedviewtypesSavedViewSpec'
       required:
       - source
-      - data
+      - schemaVersion
+      - spec
       type: object
     SavedviewtypesSavedView:
       properties:
@@ -7899,14 +7902,16 @@ components:
           type: string
         createdBy:
           type: string
-        data:
-          $ref: '#/components/schemas/SavedviewtypesSavedViewData'
         id:
           type: string
         name:
           type: string
+        schemaVersion:
+          $ref: '#/components/schemas/SavedviewtypesSchemaVersion'
         source:
           $ref: '#/components/schemas/SavedviewtypesSource'
+        spec:
+          $ref: '#/components/schemas/SavedviewtypesSavedViewSpec'
         updatedAt:
           format: date-time
           type: string
@@ -7914,14 +7919,6 @@ components:
           type: string
       required:
       - id
-      type: object
-    SavedviewtypesSavedViewData:
-      properties:
-        schemaVersion:
-          type: string
-        spec:
-          $ref: '#/components/schemas/SavedviewtypesSavedViewSpec'
-      required:
       - schemaVersion
       - spec
       type: object
@@ -7936,7 +7933,10 @@ components:
         queries:
           items:
             $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelope'
+          minItems: 1
           type: array
+        requestType:
+          $ref: '#/components/schemas/Querybuildertypesv5RequestType'
         selectedFields:
           items:
             $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
@@ -7944,10 +7944,13 @@ components:
       required:
       - displayName
       - panelType
+      - requestType
       - queries
-      - selectedFields
-      - display
       type: object
+    SavedviewtypesSchemaVersion:
+      enum:
+      - v2
+      type: string
     SavedviewtypesSource:
       enum:
       - traces
@@ -7957,13 +7960,16 @@ components:
       type: string
     SavedviewtypesUpdatableSavedView:
       properties:
-        data:
-          $ref: '#/components/schemas/SavedviewtypesSavedViewData'
+        schemaVersion:
+          $ref: '#/components/schemas/SavedviewtypesSchemaVersion'
         source:
           $ref: '#/components/schemas/SavedviewtypesSource'
+        spec:
+          $ref: '#/components/schemas/SavedviewtypesSavedViewSpec'
       required:
       - source
-      - data
+      - schemaVersion
+      - spec
       type: object
     ServiceaccounttypesDeprecatedPostableServiceAccountRole:
       properties:
@@ -22776,6 +22782,12 @@ paths:
               schema:
                 $ref: '#/components/schemas/RenderErrorResponse'
           description: Forbidden
+        "409":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Conflict
         "500":
           content:
             application/json:

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

@@ -8991,8 +8991,17 @@ export enum SavedviewtypesPanelTypeDTO {
 	list = 'list',
 	trace = 'trace',
 }
+export enum SavedviewtypesSchemaVersionDTO {
+	v2 = 'v2',
+}
+export enum SavedviewtypesSourceDTO {
+	traces = 'traces',
+	logs = 'logs',
+	metrics = 'metrics',
+	meter = 'meter',
+}
 export interface SavedviewtypesSavedViewSpecDTO {
-	display: SavedviewtypesDisplayDTO;
+	display?: SavedviewtypesDisplayDTO;
 	/**
 	 * @type string
 	 */
@@ -9002,28 +9011,14 @@ export interface SavedviewtypesSavedViewSpecDTO {
 	 * @type array
 	 */
 	queries: Querybuildertypesv5QueryEnvelopeDTO[];
+	requestType: Querybuildertypesv5RequestTypeDTO;
 	/**
 	 * @type array
 	 */
-	selectedFields: TelemetrytypesTelemetryFieldKeyDTO[];
+	selectedFields?: TelemetrytypesTelemetryFieldKeyDTO[];
 }
 
-export interface SavedviewtypesSavedViewDataDTO {
-	/**
-	 * @type string
-	 */
-	schemaVersion: string;
-	spec: SavedviewtypesSavedViewSpecDTO;
-}
-
-export enum SavedviewtypesSourceDTO {
-	traces = 'traces',
-	logs = 'logs',
-	metrics = 'metrics',
-	meter = 'meter',
-}
 export interface SavedviewtypesPostableSavedViewDTO {
-	data: SavedviewtypesSavedViewDataDTO;
 	/**
 	 * @type boolean
 	 */
@@ -9032,7 +9027,9 @@ export interface SavedviewtypesPostableSavedViewDTO {
 	 * @type string
 	 */
 	name?: string;
+	schemaVersion: SavedviewtypesSchemaVersionDTO;
 	source: SavedviewtypesSourceDTO;
+	spec: SavedviewtypesSavedViewSpecDTO;
 }
 
 export interface SavedviewtypesSavedViewDTO {
@@ -9045,7 +9042,6 @@ export interface SavedviewtypesSavedViewDTO {
 	 * @type string
 	 */
 	createdBy?: string;
-	data?: SavedviewtypesSavedViewDataDTO;
 	/**
 	 * @type string
 	 */
@@ -9054,7 +9050,9 @@ export interface SavedviewtypesSavedViewDTO {
 	 * @type string
 	 */
 	name?: string;
+	schemaVersion: SavedviewtypesSchemaVersionDTO;
 	source?: SavedviewtypesSourceDTO;
+	spec: SavedviewtypesSavedViewSpecDTO;
 	/**
 	 * @type string
 	 * @format date-time
@@ -9067,8 +9065,9 @@ export interface SavedviewtypesSavedViewDTO {
 }
 
 export interface SavedviewtypesUpdatableSavedViewDTO {
-	data: SavedviewtypesSavedViewDataDTO;
+	schemaVersion: SavedviewtypesSchemaVersionDTO;
 	source: SavedviewtypesSourceDTO;
+	spec: SavedviewtypesSavedViewSpecDTO;
 }
 
 export interface ServiceaccounttypesDeprecatedPostableServiceAccountRoleDTO {

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/ValueSelector.test.tsx

@@ -182,4 +182,56 @@ describe('ValueSelector', () => {
 			});
 		});
 	});
+
+	describe('opening and closing without touching the list', () => {
+		function renderWith(
+			selection: VariableSelection,
+			options: string[],
+		): jest.Mock {
+			const onChange = jest.fn();
+			render(
+				<TooltipProvider>
+					<ValueSelector
+						options={options}
+						variableType="dynamic"
+						multiSelect
+						showAllOption
+						selection={selection}
+						onChange={onChange}
+						emptyFallback={{ value: [], allSelected: false }}
+						testId="variable-select-env"
+					/>
+				</TooltipProvider>,
+			);
+			return onChange;
+		}
+
+		async function openThenClose(): Promise<void> {
+			const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+			const control = screen.getByTestId('variable-select-env');
+			await user.click(control.querySelector('input') as HTMLInputElement);
+			await user.keyboard('{Escape}');
+		}
+
+		it('does not promote a pick that covers every available option to ALL', async () => {
+			// A narrow time range can leave only the selected value in the list. That is
+			// still an explicit pick, not "everything, always".
+			const onChange = renderWith(
+				{ value: ['checkout-service-prod'], allSelected: false },
+				['checkout-service-prod'],
+			);
+
+			await openThenClose();
+
+			expect(onChange).not.toHaveBeenCalled();
+		});
+
+		it('does not rewrite a dynamic ALL into concrete values', async () => {
+			const onChange = renderWith({ value: null, allSelected: true }, OPTIONS);
+
+			await openThenClose();
+
+			expect(onChange).not.toHaveBeenCalled();
+		});
+	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/resolveVariableSelection.test.ts

@@ -145,6 +145,133 @@ describe('reconcileWithOptions', () => {
 			),
 		).toBeNull();
 	});
+
+	describe('preserveSelection (options moved on their own — time range, reload)', () => {
+		const multi = model({
+			type: 'DYNAMIC',
+			multiSelect: true,
+			showAllOption: true,
+			dynamicAttribute: 'service.name',
+		});
+
+		it('keeps a multi-select pick the new option list no longer offers', () => {
+			expect(
+				reconcileWithOptions(multi, { value: ['frontend'], allSelected: false }, [
+					'backend',
+					'cart',
+				]),
+			).toStrictEqual({ value: null, allSelected: true });
+
+			expect(
+				reconcileWithOptions(
+					multi,
+					{ value: ['frontend'], allSelected: false },
+					['backend', 'cart'],
+					{ preserveSelection: true },
+				),
+			).toBeNull();
+		});
+
+		it('still materializes ALL, which must track the option list', () => {
+			expect(
+				reconcileWithOptions(
+					model({ type: 'QUERY', multiSelect: true, showAllOption: true }),
+					{ value: ['a'], allSelected: true },
+					['a', 'b'],
+					{ preserveSelection: true },
+				),
+			).toStrictEqual({ value: ['a', 'b'], allSelected: true });
+		});
+
+		it('still fills the default when nothing is selected yet', () => {
+			expect(
+				reconcileWithOptions(multi, { value: [], allSelected: false }, ['a', 'b'], {
+					preserveSelection: true,
+				}),
+			).toStrictEqual({ value: null, allSelected: true });
+		});
+	});
+
+	// A typed value is in no option list, so no refetch can invalidate it.
+	describe('customValues (typed in, never offered by the data)', () => {
+		const multi = model({
+			type: 'DYNAMIC',
+			multiSelect: true,
+			showAllOption: true,
+			dynamicAttribute: 'service.name',
+		});
+
+		it('keeps them through a re-scope that drops a fetched value', () => {
+			expect(
+				reconcileWithOptions(
+					multi,
+					{
+						value: ['frontend', 'typed-in'],
+						allSelected: false,
+						customValues: ['typed-in'],
+					},
+					['backend', 'cart'],
+				),
+			).toStrictEqual({
+				value: ['typed-in'],
+				allSelected: false,
+				customValues: ['typed-in'],
+			});
+		});
+
+		it('never re-defaults a selection made only of them', () => {
+			expect(
+				reconcileWithOptions(
+					multi,
+					{ value: ['typed-in'], allSelected: false, customValues: ['typed-in'] },
+					['backend', 'cart'],
+				),
+			).toBeNull();
+		});
+
+		// An inert marker is not worth a store write + dependent refetch to prune.
+		it('leaves a stale marker alone when it drops nothing', () => {
+			expect(
+				reconcileWithOptions(
+					multi,
+					{
+						value: ['frontend', 'typed-in'],
+						allSelected: false,
+						customValues: ['typed-in', 'removed-earlier'],
+					},
+					['frontend'],
+				),
+			).toBeNull();
+		});
+
+		it('prunes markers for values it does drop', () => {
+			expect(
+				reconcileWithOptions(
+					multi,
+					{
+						value: ['stale', 'typed-in'],
+						allSelected: false,
+						customValues: ['typed-in'],
+					},
+					['frontend'],
+				),
+			).toStrictEqual({
+				value: ['typed-in'],
+				allSelected: false,
+				customValues: ['typed-in'],
+			});
+		});
+
+		it('still drops an unmarked value the list no longer offers', () => {
+			expect(
+				reconcileWithOptions(
+					multi,
+					{ value: ['frontend', 'stale'], allSelected: false },
+					['frontend'],
+				),
+			).toStrictEqual({ value: ['frontend'], allSelected: false });
+		});
+	});
 });
 
 describe('configuredDefaultValue', () => {

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/selectionUtils.test.ts

@@ -0,0 +1,91 @@
+import type { VariableSelection } from '../selectionTypes';
+import { selectionFromCommittedValues } from '../utils/selectionUtils';
+
+const OPTIONS = ['checkout', 'payments', 'cart'];
+const FALLBACK: VariableSelection = { value: null, allSelected: true };
+
+function commit(
+	values: string[],
+	overrides: Partial<Parameters<typeof selectionFromCommittedValues>[0]> = {},
+): VariableSelection {
+	return selectionFromCommittedValues({
+		values,
+		options: OPTIONS,
+		showAllOption: true,
+		emptyFallback: FALLBACK,
+		...overrides,
+	});
+}
+
+// What a multi-select commit resolves to. The option list is known only here, so this
+// is the one place a typed value can be recognised.
+describe('selectionFromCommittedValues', () => {
+	it('marks values the option list did not offer as typed in', () => {
+		expect(commit(['checkout', 'typed-in'])).toStrictEqual({
+			value: ['checkout', 'typed-in'],
+			allSelected: false,
+			customValues: ['typed-in'],
+		});
+	});
+
+	it('marks a selection made only of typed-in values', () => {
+		expect(commit(['a', 'b'])).toStrictEqual({
+			value: ['a', 'b'],
+			allSelected: false,
+			customValues: ['a', 'b'],
+		});
+	});
+
+	it('records no marker when every pick came from the list', () => {
+		expect(commit(['checkout', 'cart'])).toStrictEqual({
+			value: ['checkout', 'cart'],
+			allSelected: false,
+		});
+	});
+
+	it('reads a set covering every option as ALL', () => {
+		expect(commit(OPTIONS)).toStrictEqual({
+			value: OPTIONS,
+			allSelected: true,
+		});
+	});
+
+	// ALL re-materializes to the option set, so recording this as ALL would drop the
+	// typed value on the next refetch.
+	it('does not read every option PLUS a typed value as ALL', () => {
+		expect(commit([...OPTIONS, 'typed-in'])).toStrictEqual({
+			value: [...OPTIONS, 'typed-in'],
+			allSelected: false,
+			customValues: ['typed-in'],
+		});
+	});
+
+	// Derived from the values + options at commit time, never from the old selection.
+	it('recomputes the marker: a typed value the data now offers is a normal pick', () => {
+		expect(
+			commit(['checkout', 'was-typed'], {
+				options: [...OPTIONS, 'was-typed'],
+			}),
+		).toStrictEqual({ value: ['checkout', 'was-typed'], allSelected: false });
+	});
+
+	it('does not read it as ALL when the variable offers no ALL', () => {
+		expect(commit(OPTIONS, { showAllOption: false })).toStrictEqual({
+			value: OPTIONS,
+			allSelected: false,
+		});
+	});
+
+	it('resolves an empty commit to the variable fallback', () => {
+		expect(commit([])).toBe(FALLBACK);
+	});
+
+	it('marks everything while the options have not arrived', () => {
+		// Nothing to judge against yet; erring this way keeps a value rather than dropping it.
+		expect(commit(['typed-in'], { options: [] })).toStrictEqual({
+			value: ['typed-in'],
+			allSelected: false,
+			customValues: ['typed-in'],
+		});
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/useAutoSelect.test.tsx

@@ -4,6 +4,8 @@ import {
 	emptyVariableFormModel,
 	type VariableFormModel,
 } from '../../DashboardSettings/Variables/variableFormModel';
+import { VariableCycleReason } from '../../store/slices/variableFetchSlice';
+import { useDashboardStore } from '../../store/useDashboardStore';
 import type { VariableSelection } from '../selectionTypes';
 import { useAutoSelect } from '../hooks/useAutoSelect';
 
@@ -15,7 +17,11 @@ function run(
 	variable: VariableFormModel,
 	options: string[],
 	selection: VariableSelection,
+	cycleReason?: VariableCycleReason,
 ): VariableSelection | undefined {
+	useDashboardStore.setState({
+		variableCycleReasons: cycleReason ? { [variable.name]: cycleReason } : {},
+	});
 	const onAutoSelect = jest.fn();
 	renderHook(() => useAutoSelect(variable, options, selection, onAutoSelect));
 	return onAutoSelect.mock.calls[0]?.[0];
@@ -70,11 +76,13 @@ describe('useAutoSelect', () => {
 		expect(next).toStrictEqual({ value: ['a', 'b'], allSelected: true });
 	});
 
-	it('falls back to ALL, not the first option, when every selected value is gone', () => {
+	// Re-scoped options only — a time-range refetch must NOT re-default; see below.
+	it('re-scoped: falls back to ALL, not the first option, when every selected value is gone', () => {
 		const next = run(
 			model({ type: 'QUERY', multiSelect: true, showAllOption: true }),
 			['x', 'y'],
 			{ value: ['a', 'b'], allSelected: false },
+			VariableCycleReason.ValueCascade,
 		);
 		expect(next).toStrictEqual({ value: ['x', 'y'], allSelected: true });
 	});
@@ -102,20 +110,23 @@ describe('useAutoSelect', () => {
 		expect(next).toStrictEqual({ value: ['b'], allSelected: false });
 	});
 
-	it('keeps the still-valid subset of a multi-select when options re-scope', () => {
+	it('re-scoped: keeps the still-valid subset of a multi-select', () => {
 		const next = run(
 			model({ type: 'QUERY', multiSelect: true }),
 			['a', 'b', 'd'],
 			{ value: ['a', 'b', 'c'], allSelected: false },
+			VariableCycleReason.ValueCascade,
 		);
 		expect(next).toStrictEqual({ value: ['a', 'b'], allSelected: false });
 	});
 
-	it('re-defaults a multi-select when none of the selected values remain', () => {
-		const next = run(model({ type: 'QUERY', multiSelect: true }), ['x', 'y'], {
-			value: ['a', 'b'],
-			allSelected: false,
-		});
+	it('re-scoped: re-defaults a multi-select when none of the selected values remain', () => {
+		const next = run(
+			model({ type: 'QUERY', multiSelect: true }),
+			['x', 'y'],
+			{ value: ['a', 'b'], allSelected: false },
+			VariableCycleReason.ValueCascade,
+		);
 		expect(next).toStrictEqual({ value: ['x'], allSelected: false });
 	});
 
@@ -151,4 +162,45 @@ describe('useAutoSelect', () => {
 		});
 		expect(next).toBeUndefined();
 	});
+
+	describe('by cycle reason', () => {
+		const service = model({
+			name: 'service',
+			type: 'DYNAMIC',
+			multiSelect: true,
+			showAllOption: true,
+			dynamicAttribute: 'service.name',
+		});
+		const gone: VariableSelection = { value: ['frontend'], allSelected: false };
+
+		it('keeps the selection when a full cycle refetched the options', () => {
+			// The new window has no data for the selected service — no reason to widen to ALL.
+			const next = run(
+				service,
+				['backend', 'cart'],
+				gone,
+				VariableCycleReason.FullCycle,
+			);
+			expect(next).toBeUndefined();
+		});
+
+		it('re-scopes the selection when a value cascade refetched the options', () => {
+			const next = run(
+				service,
+				['backend', 'cart'],
+				gone,
+				VariableCycleReason.ValueCascade,
+			);
+			expect(next).toStrictEqual({ value: null, allSelected: true });
+		});
+
+		it('reconciles a variable with no cycle of its own (custom definition change)', () => {
+			const next = run(
+				model({ name: 'env', type: 'CUSTOM', multiSelect: true }),
+				['staging', 'prod'],
+				{ value: ['dev'], allSelected: false },
+			);
+			expect(next).toStrictEqual({ value: ['staging'], allSelected: false });
+		});
+	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/useVariableSelection.test.tsx

@@ -13,11 +13,11 @@ jest.mock('nuqs', () => ({
 	useQueryState: (): unknown => [null, jest.fn()],
 }));
 
+const mockGlobalTime = { minTime: 1, maxTime: 2, selectedTime: '5m' };
+
 jest.mock('react-redux', () => ({
 	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({
-			globalTime: { minTime: 1, maxTime: 2, selectedTime: '5m' },
-		}),
+		selector({ globalTime: mockGlobalTime }),
 }));
 
 jest.mock('../../DashboardSettings/Variables/variableAdapters', () => ({
@@ -150,3 +150,57 @@ describe('useVariableSelection — setSelection', () => {
 		expect(svcCycleId()).toBe(before + 1);
 	});
 });
+
+describe('useVariableSelection — what a time-range change enqueues', () => {
+	// Longer than FETCH_CYCLE_DEBOUNCE_MS, which the hook keeps private.
+	const PAST_DEBOUNCE = 400;
+
+	function reasons(): Record<string, string> {
+		return useDashboardStore.getState().variableCycleReasons;
+	}
+
+	beforeEach(() => {
+		jest.useFakeTimers();
+		mockGlobalTime.selectedTime = '5m';
+		useDashboardStore.setState({
+			variableValues: {},
+			variableFetchStates: {},
+			variableLastUpdated: {},
+			variableCycleIds: {},
+			variableCycleReasons: {},
+			variableResolvedEmpty: {},
+			variableFetchContext: null,
+			lastFetchAllKey: null,
+		});
+	});
+
+	afterEach(() => {
+		jest.useRealTimers();
+	});
+
+	// The tag is what stops the reconcile re-defaulting a user's selection.
+	it('tags every variable as a full cycle, overriding an earlier cascade tag', () => {
+		const { result, rerender } = renderHook(() =>
+			useVariableSelection(dashboard),
+		);
+
+		act(() => {
+			jest.advanceTimersByTime(PAST_DEBOUNCE);
+		});
+		expect(reasons()).toStrictEqual({ env: 'full-cycle', svc: 'full-cycle' });
+
+		// A value change re-scopes the dependent's options: it may drop what no longer applies.
+		act(() => {
+			result.current.setSelection('env', { value: ['prod'], allSelected: false });
+		});
+		expect(reasons().svc).toBe('value-cascade');
+
+		mockGlobalTime.selectedTime = '30m';
+		rerender();
+		act(() => {
+			jest.advanceTimersByTime(PAST_DEBOUNCE);
+		});
+
+		expect(reasons()).toStrictEqual({ env: 'full-cycle', svc: 'full-cycle' });
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/components/selectors/ValueSelector.tsx

@@ -6,6 +6,7 @@ import { DashboardDetailEvents } from 'pages/DashboardPageV2/constants/events';
 
 import type { VariableSelection } from '../../selectionTypes';
 import { areSelectionsEqual } from '../../utils/resolveVariableSelection';
+import { selectionFromCommittedValues } from '../../utils/selectionUtils';
 import OverflowValuesTooltip from './OverflowValuesTooltip';
 import styles from '../../VariablesBar.module.scss';
 
@@ -75,13 +76,23 @@ function ValueSelector({
 		options.every((option) => draft.includes(option));
 
 	const commit = (values: string[]): void => {
-		// CustomMultiSelect emits the full value set when ALL is picked.
-		const isAll =
-			showAllOption &&
-			options.length > 0 &&
-			options.every((option) => values.includes(option));
-		const next: VariableSelection =
-			values.length === 0 ? emptyFallback : { value: values, allSelected: isAll };
+		// A close that left the list as it opened commits nothing — else a pick covering
+		// every option this window offers would be promoted to a standing ALL.
+		if (
+			areSelectionsEqual(
+				{ value: values, allSelected: false },
+				{ value: committedValues, allSelected: false },
+			)
+		) {
+			return;
+		}
+
+		const next = selectionFromCommittedValues({
+			values,
+			options,
+			showAllOption,
+			emptyFallback,
+		});
 
 		// Closing without actually changing the selection must not re-fire onChange —
 		// that would needlessly re-cascade to dependent variables/panels.

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

@@ -1,6 +1,11 @@
 import { useEffect } from 'react';
 
 import type { VariableFormModel } from '../../DashboardSettings/Variables/variableFormModel';
+import {
+	selectVariableCycleReason,
+	VariableCycleReason,
+} from '../../store/slices/variableFetchSlice';
+import { useDashboardStore } from '../../store/useDashboardStore';
 import { reconcileWithOptions } from '../utils/resolveVariableSelection';
 import type { VariableSelection } from '../selectionTypes';
 
@@ -9,6 +14,9 @@ import type { VariableSelection } from '../selectionTypes';
  * `onAutoSelect` only when the value must change. The reconcile rule lives in
  * {@link reconcileWithOptions} (shared with seed + payload defaulting) so the bar
  * and the panel query can never disagree about a variable's default.
+ *
+ * Only a value cascade may re-default the selection; a full cycle (time range,
+ * reload) leaves the user's pick alone. Types with no cycle of their own reconcile.
  */
 export function useAutoSelect(
 	variable: VariableFormModel,
@@ -16,8 +24,14 @@ export function useAutoSelect(
 	selection: VariableSelection,
 	onAutoSelect: (selection: VariableSelection) => void,
 ): void {
+	const cycleReason = useDashboardStore(
+		selectVariableCycleReason(variable.name),
+	);
+
 	useEffect(() => {
-		const next = reconcileWithOptions(variable, selection, options);
+		const next = reconcileWithOptions(variable, selection, options, {
+			preserveSelection: cycleReason === VariableCycleReason.FullCycle,
+		});
 		if (next) {
 			onAutoSelect(next);
 		}

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

@@ -10,6 +10,11 @@ export interface VariableSelection {
 	value: SelectedVariableValue;
 	/** True when every option is selected ("ALL"); for dynamic vars value may be null. */
 	allSelected: boolean;
+	/**
+	 * Entries of `value` the user typed rather than picked. Never in any option list,
+	 * so the reconcile keeps them instead of reading them as invalid.
+	 */
+	customValues?: string[];
 }
 
 /** Selected values for a dashboard's variables, keyed by variable name. */

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

@@ -134,12 +134,23 @@ export function resolveDefaultSelection(
 	return { value: model.multiSelect ? [] : '', allSelected: false };
 }
 
+interface ReconcileOptions {
+	/**
+	 * Set when no other variable caused this refetch (time-range change, reload): the
+	 * selection then outranks the options and is kept as-is. Leave false for a
+	 * dependency cascade, where a selection that no longer applies must give way.
+	 */
+	preserveSelection?: boolean;
+}
+
 /**
  * Reconciles a variable's current selection against its freshly-fetched options.
  * Returns the next selection, or null when nothing should change (a valid pick is
  * left untouched — local-first). Behaviour, in order:
  * - materialize ALL to the full option set (query/custom);
- * - keep a still-valid multi-select subset, dropping only invalid entries;
+ * - keep a multi-select selection outright when `preserveSelection` is set;
+ * - keep a still-valid multi-select subset, dropping only entries the list no longer
+ *   offers and the user did not type in (`customValues`);
  * - otherwise auto-pick the default (or first option) so dependent variables and
  *   panels always resolve against a usable value.
  */
@@ -147,6 +158,7 @@ export function reconcileWithOptions(
 	model: VariableFormModel,
 	current: VariableSelection,
 	options: string[],
+	{ preserveSelection = false }: ReconcileOptions = {},
 ): VariableSelection | null {
 	if (options.length === 0) {
 		return null;
@@ -161,13 +173,31 @@ export function reconcileWithOptions(
 		Array.isArray(current.value) &&
 		current.value.length > 0
 	) {
-		const valid = current.value.map(String).filter((c) => options.includes(c));
+		// A pick this window has no data for is still the user's filter; re-defaulting it
+		// here is what widened a single pick to ALL on every time-range change.
+		if (preserveSelection) {
+			return null;
+		}
+
+		// A typed value is in no option list, so it is never "no longer offered".
+		const custom = new Set(current.customValues ?? []);
+		const valid = current.value
+			.map(String)
+			.filter((c) => options.includes(c) || custom.has(c));
+
 		if (valid.length === current.value.length) {
 			return null;
 		}
-		return valid.length > 0
-			? { value: valid, allSelected: false }
-			: fillDefault(model, options);
+		if (valid.length === 0) {
+			return fillDefault(model, options);
+		}
+
+		const customValues = valid.filter((v) => custom.has(v));
+		return {
+			value: valid,
+			allSelected: false,
+			...(customValues.length > 0 && { customValues }),
+		};
 	}
 
 	if (!model.multiSelect) {

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

@@ -47,6 +47,43 @@ export function hasUsableValue(
 	return value !== '' && value !== null && value !== undefined;
 }
 
+interface CommittedValues {
+	values: string[];
+	options: string[];
+	showAllOption: boolean;
+	emptyFallback: VariableSelection;
+}
+
+/**
+ * The selection a multi-select commit resolves to. Options are known only here, so
+ * this is where a value the list never offered is recorded as typed in.
+ */
+export function selectionFromCommittedValues({
+	values,
+	options,
+	showAllOption,
+	emptyFallback,
+}: CommittedValues): VariableSelection {
+	if (values.length === 0) {
+		return emptyFallback;
+	}
+
+	const customValues = values.filter((value) => !options.includes(value));
+	// ALL re-materializes to the option set, so a set carrying a typed value is not ALL
+	// — the next refetch would expand it back and drop what the user typed.
+	const allSelected =
+		showAllOption &&
+		options.length > 0 &&
+		customValues.length === 0 &&
+		options.every((option) => values.includes(option));
+
+	return {
+		value: values,
+		allSelected,
+		...(customValues.length > 0 && { customValues }),
+	};
+}
+
 /** Flatten the selection map into the `{ name: value }` payload a query expects. */
 export function selectionToPayload(
 	selection: VariableSelectionMap,

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

@@ -34,6 +34,7 @@ function reset(names: string[], context: VariableFetchContext): void {
 		variableFetchStates: {},
 		variableLastUpdated: {},
 		variableCycleIds: {},
+		variableCycleReasons: {},
 		variableFetchContext: null,
 	});
 	store().initVariableFetch(names, context);
@@ -133,6 +134,33 @@ describe('variableFetchSlice', () => {
 		expect(states().q1).toBe('error');
 		expect(states().q2).toBe('idle');
 	});
+
+	// The reason is what tells the post-fetch reconcile whether it may re-default a
+	// selection: a full cycle must not, a value cascade must.
+	it('tags a full cycle, then re-tags only the cascaded variables', () => {
+		store().enqueueFetchAll();
+		expect(store().variableCycleReasons).toStrictEqual({
+			q1: 'full-cycle',
+			q2: 'full-cycle',
+			d1: 'full-cycle',
+			d2: 'full-cycle',
+		});
+
+		resolve('q1');
+		store().enqueueDescendants('q1');
+		expect(store().variableCycleReasons).toStrictEqual({
+			q1: 'full-cycle',
+			q2: 'value-cascade',
+			d1: 'full-cycle',
+			d2: 'full-cycle',
+		});
+	});
+
+	it('drops the reason for a variable that no longer exists', () => {
+		store().enqueueFetchAll();
+		store().initVariableFetch(['q1'], context);
+		expect(store().variableCycleReasons).toStrictEqual({ q1: 'full-cycle' });
+	});
 });
 
 describe('variableFetchSlice — query depends on a dynamic', () => {

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

@@ -9,6 +9,7 @@ import {
 	type FetchMaps,
 	isVariableInActiveFetchState,
 	resolveFetchState,
+	VariableCycleReason,
 	VariableFetchState,
 } from './variableFetchSlice.utils';
 
@@ -30,7 +31,10 @@ function queryParentsHaveValues(
 	);
 }
 
-export { VariableFetchState } from './variableFetchSlice.utils';
+export {
+	VariableCycleReason,
+	VariableFetchState,
+} from './variableFetchSlice.utils';
 
 /**
  * Runtime fetch orchestration for dashboard variables — native port of V1's
@@ -45,6 +49,8 @@ export interface VariableFetchSlice {
 	variableFetchStates: Record<string, VariableFetchState>;
 	variableLastUpdated: Record<string, number>;
 	variableCycleIds: Record<string, number>;
+	/** Why each variable's current cycle was enqueued, read by the post-fetch reconcile. */
+	variableCycleReasons: Record<string, VariableCycleReason>;
 	/**
 	 * Whether a QUERY/DYNAMIC variable settled its fetch with zero options (so it
 	 * will never get a value). Lets a dependent panel fall through to "no data"
@@ -106,6 +112,7 @@ export const createVariableFetchSlice: StateCreator<
 	variableFetchStates: {},
 	variableLastUpdated: {},
 	variableCycleIds: {},
+	variableCycleReasons: {},
 	variableResolvedEmpty: {},
 	variableFetchContext: null,
 	lastFetchAllKey: null,
@@ -115,6 +122,7 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: {},
 			variableLastUpdated: {},
 			variableCycleIds: {},
+			variableCycleReasons: {},
 			variableResolvedEmpty: {},
 			variableFetchContext: null,
 			lastFetchAllKey: null,
@@ -132,6 +140,7 @@ export const createVariableFetchSlice: StateCreator<
 	initVariableFetch: (names, context): void => {
 		const maps = cloneMaps(get());
 		const resolvedEmpty = { ...get().variableResolvedEmpty };
+		const reasons = { ...get().variableCycleReasons };
 		names.forEach((name) => {
 			if (!maps.states[name]) {
 				maps.states[name] = VariableFetchState.Idle;
@@ -144,12 +153,14 @@ export const createVariableFetchSlice: StateCreator<
 				delete maps.lastUpdated[name];
 				delete maps.cycleIds[name];
 				delete resolvedEmpty[name];
+				delete reasons[name];
 			}
 		});
 		set({
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
+			variableCycleReasons: reasons,
 			variableResolvedEmpty: resolvedEmpty,
 			variableFetchContext: context,
 		});
@@ -171,6 +182,11 @@ export const createVariableFetchSlice: StateCreator<
 			dynamicVariableOrder,
 		} = variableFetchContext;
 		const maps = cloneMaps(get());
+		const reasons = { ...get().variableCycleReasons };
+		const bump = (name: string): void => {
+			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
+			reasons[name] = VariableCycleReason.FullCycle;
+		};
 
 		// Query variables wait only for their QUERY parents. A DYNAMIC parent does not
 		// gate: its option fetch feeds only its own dropdown, while its selected value
@@ -178,7 +194,7 @@ export const createVariableFetchSlice: StateCreator<
 		// dependent query substitutes it immediately and refetches via the cascade if
 		// it later changes. Text/custom parents resolve synchronously, so nothing waits.
 		queryVariableOrder.forEach((name) => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
+			bump(name);
 			const parents = dependencyData.parentGraph[name] || [];
 			const hasQueryParents = parents.some((p) => variableTypes[p] === 'QUERY');
 			maps.states[name] = hasQueryParents
@@ -192,7 +208,7 @@ export const createVariableFetchSlice: StateCreator<
 		const orderedQuery = new Set(queryVariableOrder);
 		Object.keys(variableTypes).forEach((name) => {
 			if (variableTypes[name] === 'QUERY' && !orderedQuery.has(name)) {
-				maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
+				bump(name);
 				maps.states[name] = resolveFetchState(maps, name);
 			}
 		});
@@ -203,7 +219,7 @@ export const createVariableFetchSlice: StateCreator<
 		// populate fast even when query variables are slow; a sibling selection change
 		// later refetches them via `enqueueDescendantsBatch`.
 		dynamicVariableOrder.forEach((name) => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
+			bump(name);
 			maps.states[name] = resolveFetchState(maps, name);
 		});
 
@@ -211,6 +227,7 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
+			variableCycleReasons: reasons,
 			lastFetchAllKey: key ?? get().lastFetchAllKey,
 		});
 	},
@@ -290,6 +307,11 @@ export const createVariableFetchSlice: StateCreator<
 		const { dependencyData, variableTypes, dynamicVariableOrder } =
 			variableFetchContext;
 		const maps = cloneMaps(get());
+		const reasons = { ...get().variableCycleReasons };
+		const bump = (name: string): void => {
+			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
+			reasons[name] = VariableCycleReason.ValueCascade;
+		};
 		const changed = new Set(names);
 		// Callers commit values before this runs, so the gate sees the new parent values.
 		const selection = selectVariableValues(get().dashboardId)(get());
@@ -305,7 +327,7 @@ export const createVariableFetchSlice: StateCreator<
 			});
 		});
 		queryDescendants.forEach((desc) => {
-			maps.cycleIds[desc] = (maps.cycleIds[desc] || 0) + 1;
+			bump(desc);
 			maps.states[desc] = queryParentsHaveValues(
 				desc,
 				variableFetchContext,
@@ -322,7 +344,7 @@ export const createVariableFetchSlice: StateCreator<
 			dynamicVariableOrder
 				.filter((dynName) => !changed.has(dynName))
 				.forEach((dynName) => {
-					maps.cycleIds[dynName] = (maps.cycleIds[dynName] || 0) + 1;
+					bump(dynName);
 					maps.states[dynName] = resolveFetchState(maps, dynName);
 				});
 		}
@@ -331,6 +353,7 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
+			variableCycleReasons: reasons,
 		});
 	},
 });
@@ -347,6 +370,12 @@ export const selectVariableCycleId =
 	(state: DashboardStore): number =>
 		state.variableCycleIds[name] ?? 0;
 
+/** Selector: why a variable's cycle was enqueued. Undefined for types that never fetch. */
+export const selectVariableCycleReason =
+	(name: string) =>
+	(state: DashboardStore): VariableCycleReason | undefined =>
+		state.variableCycleReasons[name];
+
 /** Selector: whether a variable has completed at least one fetch. */
 export const selectVariableFetchedOnce =
 	(name: string) =>

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

@@ -7,6 +7,14 @@ export enum VariableFetchState {
 	Error = 'error',
 }
 
+/** Why a cycle was started — only a cascade may re-default a user's selection. */
+export enum VariableCycleReason {
+	/** `enqueueFetchAll`: load, time-range or variable-order change. */
+	FullCycle = 'full-cycle',
+	/** `enqueueDescendantsBatch`: a parent or sibling variable's value changed. */
+	ValueCascade = 'value-cascade',
+}
+
 /** Mutable clones a fetch action works over before committing back in one `set`. */
 export interface FetchMaps {
 	states: Record<string, VariableFetchState>;

pkg/apiserver/signozapiserver/savedview.go

@@ -51,7 +51,7 @@ func (provider *provider) addSavedViewRoutes(router *mux.Router) error {
 			Response:            new(types.Identifiable),
 			ResponseContentType: "application/json",
 			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest},
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
 			Deprecated:          false,
 			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceSavedView.Scope(coretypes.VerbCreate)}),
 		},

pkg/modules/dashboard/impldashboard/v2_module.go

@@ -245,11 +245,13 @@ func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.
 }
 
 func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	existing, err := module.GetV2(ctx, orgID, id)
+	// Read the storable, not the decoded v2 dashboard: deleting must work even
+	// when the stored data is corrupt or never migrated off the v1 schema.
+	storable, err := module.store.Get(ctx, orgID, id)
 	if err != nil {
 		return err
 	}
-	if err := existing.ErrIfNotDeletable(); err != nil {
+	if err := storable.ErrIfNotDeletable(); err != nil {
 		return err
 	}
 

pkg/modules/savedview/implsavedview/handler.go

@@ -39,26 +39,28 @@ type legacyExtraData struct {
 func newPostableSavedViewFromLegacyView(v *v3.SavedView) savedviewtypes.PostableSavedView {
 	var legacy legacyExtraData
 	if v.ExtraData != "" {
-		// Best-effort: malformed/older extraData shapes never fail the request
+		// Best-effort: malformed/older extraData shapes never fail the request.
 		_ = json.Unmarshal([]byte(v.ExtraData), &legacy)
 	}
 
+	panelType := savedviewtypes.PanelType{String: valuer.NewString(string(v.CompositeQuery.PanelType))}
+
 	return savedviewtypes.PostableSavedView{
-		GenerateName: true,
-		Source:       savedviewtypes.Source{String: valuer.NewString(v.SourcePage)},
-		Data: savedviewtypes.SavedViewData{
-			SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
-			Spec: savedviewtypes.SavedViewSpec{
-				DisplayName:    v.Name,
-				PanelType:      savedviewtypes.PanelType{String: valuer.NewString(string(v.CompositeQuery.PanelType))},
-				Queries:        v.CompositeQuery.Queries,
-				SelectedFields: legacy.SelectColumns,
-				Display: savedviewtypes.Display{
-					MaxLines: legacy.MaxLines,
-					FontSize: legacy.FontSize,
-					Format:   legacy.Format,
-					Color:    legacy.Color,
-				},
+		GenerateName:  true,
+		Source:        savedviewtypes.Source{String: valuer.NewString(v.SourcePage)},
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName: v.Name,
+			PanelType:   panelType,
+			// v1 has no requestType concept of its own -- fall back to the panelType-derived guess.
+			RequestType:    savedviewtypes.LegacyRequestTypeForPanelType(panelType),
+			Queries:        v.CompositeQuery.Queries,
+			SelectedFields: legacy.SelectColumns,
+			Display: savedviewtypes.Display{
+				MaxLines: legacy.MaxLines,
+				FontSize: legacy.FontSize,
+				Format:   legacy.Format,
+				Color:    legacy.Color,
 			},
 		},
 	}
@@ -68,25 +70,27 @@ func newPostableSavedViewFromLegacyView(v *v3.SavedView) savedviewtypes.Postable
 func newUpdatableSavedViewFromLegacyView(v *v3.SavedView) savedviewtypes.UpdatableSavedView {
 	var legacy legacyExtraData
 	if v.ExtraData != "" {
-		// Best-effort: malformed/older extraData shapes never fail the request
+		// Best-effort: malformed/older extraData shapes never fail the request.
 		_ = json.Unmarshal([]byte(v.ExtraData), &legacy)
 	}
 
+	panelType := savedviewtypes.PanelType{String: valuer.NewString(string(v.CompositeQuery.PanelType))}
+
 	return savedviewtypes.UpdatableSavedView{
-		Source: savedviewtypes.Source{String: valuer.NewString(v.SourcePage)},
-		Data: savedviewtypes.SavedViewData{
-			SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
-			Spec: savedviewtypes.SavedViewSpec{
-				DisplayName:    v.Name,
-				PanelType:      savedviewtypes.PanelType{String: valuer.NewString(string(v.CompositeQuery.PanelType))},
-				Queries:        v.CompositeQuery.Queries,
-				SelectedFields: legacy.SelectColumns,
-				Display: savedviewtypes.Display{
-					MaxLines: legacy.MaxLines,
-					FontSize: legacy.FontSize,
-					Format:   legacy.Format,
-					Color:    legacy.Color,
-				},
+		Source:        savedviewtypes.Source{String: valuer.NewString(v.SourcePage)},
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName: v.Name,
+			PanelType:   panelType,
+			// v1 has no requestType concept of its own -- fall back to the panelType-derived guess.
+			RequestType:    savedviewtypes.LegacyRequestTypeForPanelType(panelType),
+			Queries:        v.CompositeQuery.Queries,
+			SelectedFields: legacy.SelectColumns,
+			Display: savedviewtypes.Display{
+				MaxLines: legacy.MaxLines,
+				FontSize: legacy.FontSize,
+				Format:   legacy.Format,
+				Color:    legacy.Color,
 			},
 		},
 	}
@@ -95,11 +99,11 @@ func newUpdatableSavedViewFromLegacyView(v *v3.SavedView) savedviewtypes.Updatab
 // newLegacyViewFromSavedView renders a v2 SavedView back into the v1 shape.
 func newLegacyViewFromSavedView(v *savedviewtypes.SavedView) (*v3.SavedView, error) {
 	extraData, err := json.Marshal(legacyExtraData{
-		Color:         v.Data.Spec.Display.Color,
-		SelectColumns: v.Data.Spec.SelectedFields,
-		Format:        v.Data.Spec.Display.Format,
-		MaxLines:      v.Data.Spec.Display.MaxLines,
-		FontSize:      v.Data.Spec.Display.FontSize,
+		Color:         v.Spec.Display.Color,
+		SelectColumns: v.Spec.SelectedFields,
+		Format:        v.Spec.Display.Format,
+		MaxLines:      v.Spec.Display.MaxLines,
+		FontSize:      v.Spec.Display.FontSize,
 	})
 	if err != nil {
 		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error in marshalling extra data")
@@ -107,17 +111,17 @@ func newLegacyViewFromSavedView(v *savedviewtypes.SavedView) (*v3.SavedView, err
 
 	return &v3.SavedView{
 		ID:         v.ID,
-		Name:       v.Data.Spec.DisplayName,
+		Name:       v.Spec.DisplayName,
 		CreatedAt:  v.CreatedAt,
 		CreatedBy:  v.CreatedBy,
 		UpdatedAt:  v.UpdatedAt,
 		UpdatedBy:  v.UpdatedBy,
 		SourcePage: v.Source.StringValue(),
 		CompositeQuery: &v3.CompositeQuery{
-			PanelType: v3.PanelType(v.Data.Spec.PanelType.StringValue()),
+			PanelType: v3.PanelType(v.Spec.PanelType.StringValue()),
 			// Saved views are only ever created from the explorer's builder mode.
 			QueryType: v3.QueryTypeBuilder,
-			Queries:   v.Data.Spec.Queries,
+			Queries:   v.Spec.Queries,
 		},
 		ExtraData: string(extraData),
 	}, nil
@@ -156,7 +160,14 @@ func (handler *handler) Create(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	uuid, err := handler.module.CreateView(ctx, claims.OrgID, newPostableSavedViewFromLegacyView(&view))
+	postable := newPostableSavedViewFromLegacyView(&view)
+
+	if err := postable.Validate(); err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	uuid, err := handler.module.CreateView(ctx, claims.OrgID, postable)
 	if err != nil {
 		render.Error(w, err)
 		return
@@ -224,8 +235,14 @@ func (handler *handler) Update(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	err = handler.module.UpdateView(ctx, claims.OrgID, viewUUID, newUpdatableSavedViewFromLegacyView(&view))
-	if err != nil {
+	updatable := newUpdatableSavedViewFromLegacyView(&view)
+
+	if err := updatable.Validate(); err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	if err := handler.module.UpdateView(ctx, claims.OrgID, viewUUID, updatable); err != nil {
 		render.Error(w, err)
 		return
 	}

pkg/modules/savedview/implsavedview/handler_test.go

@@ -42,13 +42,14 @@ func TestNewPostableSavedViewFromLegacyView(t *testing.T) {
 
 		assert.Empty(t, postable.Name, "v1 has no slug concept -- name must always be generated")
 		assert.True(t, postable.GenerateName, "v1 has no slug concept -- name must always be generated")
-		assert.Equal(t, "my view", postable.Data.Spec.DisplayName)
+		assert.Equal(t, "my view", postable.Spec.DisplayName)
 		assert.Equal(t, savedviewtypes.SourceLogs, postable.Source)
-		assert.Equal(t, savedviewtypes.SavedViewSchemaVersion, postable.Data.SchemaVersion)
-		assert.Equal(t, savedviewtypes.PanelTypeGraph, postable.Data.Spec.PanelType)
-		assert.Equal(t, legacy.CompositeQuery.Queries, postable.Data.Spec.Queries)
-		assert.Equal(t, []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}}, postable.Data.Spec.SelectedFields)
-		assert.Equal(t, savedviewtypes.Display{MaxLines: 10, FontSize: "large", Format: "table", Color: "blue"}, postable.Data.Spec.Display)
+		assert.Equal(t, savedviewtypes.SavedViewSchemaVersion, postable.SchemaVersion)
+		assert.Equal(t, savedviewtypes.PanelTypeGraph, postable.Spec.PanelType)
+		assert.Equal(t, qbtypes.RequestTypeTimeSeries, postable.Spec.RequestType, "graph panel type must map to the time_series request type")
+		assert.Equal(t, legacy.CompositeQuery.Queries, postable.Spec.Queries)
+		assert.Equal(t, []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}}, postable.Spec.SelectedFields)
+		assert.Equal(t, savedviewtypes.Display{MaxLines: 10, FontSize: "large", Format: "table", Color: "blue"}, postable.Spec.Display)
 	})
 
 	t.Run("empty extra data leaves display and selected fields zero-valued", func(t *testing.T) {
@@ -64,8 +65,9 @@ func TestNewPostableSavedViewFromLegacyView(t *testing.T) {
 
 		postable := newPostableSavedViewFromLegacyView(legacy)
 
-		assert.Equal(t, savedviewtypes.Display{}, postable.Data.Spec.Display)
-		assert.Nil(t, postable.Data.Spec.SelectedFields)
+		assert.Equal(t, savedviewtypes.PanelTypeTable, postable.Spec.PanelType)
+		assert.Equal(t, savedviewtypes.Display{}, postable.Spec.Display)
+		assert.Nil(t, postable.Spec.SelectedFields)
 	})
 
 	t.Run("malformed extra data is ignored, not an error", func(t *testing.T) {
@@ -81,8 +83,48 @@ func TestNewPostableSavedViewFromLegacyView(t *testing.T) {
 
 		postable := newPostableSavedViewFromLegacyView(legacy)
 
-		assert.Equal(t, "malformed extra data", postable.Data.Spec.DisplayName)
-		assert.Equal(t, savedviewtypes.Display{}, postable.Data.Spec.Display)
+		assert.Equal(t, "malformed extra data", postable.Spec.DisplayName)
+		assert.Equal(t, savedviewtypes.PanelTypeList, postable.Spec.PanelType)
+		assert.Equal(t, savedviewtypes.Display{}, postable.Spec.Display)
+	})
+
+	t.Run("legacy validation gap: empty builderQueries map with no queries", func(t *testing.T) {
+		legacy := &v3.SavedView{
+			Name:       "no real queries",
+			SourcePage: "logs",
+			CompositeQuery: &v3.CompositeQuery{
+				PanelType:      v3.PanelTypeGraph,
+				QueryType:      v3.QueryTypeBuilder,
+				BuilderQueries: map[string]*v3.BuilderQuery{},
+			},
+		}
+
+		require.NoError(t, legacy.Validate(), "the legacy CompositeQuery check is expected to miss this")
+
+		postable := newPostableSavedViewFromLegacyView(legacy)
+		assert.Error(t, postable.Validate(), "the converted postable must catch what the legacy check missed")
+	})
+
+	t.Run("list panel query with no aggregation is valid", func(t *testing.T) {
+		legacy := &v3.SavedView{
+			Name:       "raw list view",
+			SourcePage: "traces",
+			CompositeQuery: &v3.CompositeQuery{
+				PanelType: v3.PanelTypeList,
+				Queries: []qbtypes.QueryEnvelope{{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+						Signal: telemetrytypes.SignalTraces,
+						Filter: &qbtypes.Filter{Expression: "db_name = 'two'"},
+					},
+				}},
+			},
+		}
+
+		postable := newPostableSavedViewFromLegacyView(legacy)
+
+		assert.Equal(t, qbtypes.RequestTypeRaw, postable.Spec.RequestType, "list panel type must map to the raw request type")
+		assert.NoError(t, postable.Validate(), "a raw list query must not be required to carry an aggregation")
 	})
 }
 
@@ -99,24 +141,23 @@ func TestNewUpdatableSavedViewFromLegacyView(t *testing.T) {
 
 	updatable := newUpdatableSavedViewFromLegacyView(legacy)
 
-	assert.Equal(t, "renamed view", updatable.Data.Spec.DisplayName)
+	assert.Equal(t, "renamed view", updatable.Spec.DisplayName)
 	assert.Equal(t, savedviewtypes.SourceTraces, updatable.Source)
+	assert.Equal(t, qbtypes.RequestTypeScalar, updatable.Spec.RequestType, "table panel type must map to the scalar request type")
 }
 
 func TestNewLegacyViewFromSavedView(t *testing.T) {
 	now := time.Now()
 	savedView := &savedviewtypes.SavedView{
-		Name:   "my-view-abc123ef",
-		Source: savedviewtypes.SourceLogs,
-		Data: savedviewtypes.SavedViewData{
-			SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
-			Spec: savedviewtypes.SavedViewSpec{
-				DisplayName:    "my view",
-				PanelType:      savedviewtypes.PanelTypeGraph,
-				Queries:        testQueries(),
-				SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
-				Display:        savedviewtypes.Display{MaxLines: 10, FontSize: "large", Format: "table", Color: "blue"},
-			},
+		Name:          "my-view-abc123ef",
+		Source:        savedviewtypes.SourceLogs,
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName:    "my view",
+			PanelType:      savedviewtypes.PanelTypeGraph,
+			Queries:        testQueries(),
+			SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
+			Display:        savedviewtypes.Display{MaxLines: 10, FontSize: "large", Format: "table", Color: "blue"},
 		},
 	}
 	savedView.ID = valuer.GenerateUUID()
@@ -129,7 +170,7 @@ func TestNewLegacyViewFromSavedView(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.Equal(t, savedView.ID, legacy.ID)
-	assert.Equal(t, savedView.Data.Spec.DisplayName, legacy.Name)
+	assert.Equal(t, savedView.Spec.DisplayName, legacy.Name)
 	assert.Equal(t, savedView.CreatedAt, legacy.CreatedAt)
 	assert.Equal(t, savedView.CreatedBy, legacy.CreatedBy)
 	assert.Equal(t, savedView.UpdatedAt, legacy.UpdatedAt)
@@ -137,20 +178,20 @@ func TestNewLegacyViewFromSavedView(t *testing.T) {
 	assert.Equal(t, "logs", legacy.SourcePage)
 	assert.Equal(t, v3.PanelTypeGraph, legacy.CompositeQuery.PanelType)
 	assert.Equal(t, v3.QueryTypeBuilder, legacy.CompositeQuery.QueryType)
-	assert.Equal(t, savedView.Data.Spec.Queries, legacy.CompositeQuery.Queries)
+	assert.Equal(t, savedView.Spec.Queries, legacy.CompositeQuery.Queries)
 
 	var extra legacyExtraData
 	require.NoError(t, json.Unmarshal([]byte(legacy.ExtraData), &extra))
 	assert.Equal(t, "blue", extra.Color)
-	assert.Equal(t, savedView.Data.Spec.SelectedFields, extra.SelectColumns)
+	assert.Equal(t, savedView.Spec.SelectedFields, extra.SelectColumns)
 	assert.Equal(t, "table", extra.Format)
 	assert.Equal(t, 10, extra.MaxLines)
 	assert.Equal(t, "large", extra.FontSize)
 }
 
 func TestNewLegacyViewsFromSavedViews(t *testing.T) {
-	a := &savedviewtypes.SavedView{Name: "a-slug", Source: savedviewtypes.SourceLogs, Data: savedviewtypes.SavedViewData{Spec: savedviewtypes.SavedViewSpec{DisplayName: "a", PanelType: savedviewtypes.PanelTypeGraph, Queries: testQueries()}}}
-	b := &savedviewtypes.SavedView{Name: "b-slug", Source: savedviewtypes.SourceTraces, Data: savedviewtypes.SavedViewData{Spec: savedviewtypes.SavedViewSpec{DisplayName: "b", PanelType: savedviewtypes.PanelTypeTable, Queries: testQueries()}}}
+	a := &savedviewtypes.SavedView{Name: "a-slug", Source: savedviewtypes.SourceLogs, Spec: savedviewtypes.SavedViewSpec{DisplayName: "a", PanelType: savedviewtypes.PanelTypeGraph, Queries: testQueries()}}
+	b := &savedviewtypes.SavedView{Name: "b-slug", Source: savedviewtypes.SourceTraces, Spec: savedviewtypes.SavedViewSpec{DisplayName: "b", PanelType: savedviewtypes.PanelTypeTable, Queries: testQueries()}}
 
 	legacyViews, err := newLegacyViewsFromSavedViews([]*savedviewtypes.SavedView{a, b})
 	require.NoError(t, err)
@@ -167,17 +208,15 @@ func TestNewLegacyViewsFromSavedViews(t *testing.T) {
 // slug (Name) is deliberately NOT part of this contract -- v1 never sees it.
 func TestLegacyViewRoundTrip(t *testing.T) {
 	original := &savedviewtypes.SavedView{
-		Name:   "round-trip-abc123ef",
-		Source: savedviewtypes.SourceMetrics,
-		Data: savedviewtypes.SavedViewData{
-			SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
-			Spec: savedviewtypes.SavedViewSpec{
-				DisplayName:    "round trip",
-				PanelType:      savedviewtypes.PanelTypeTable,
-				Queries:        testQueries(),
-				SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
-				Display:        savedviewtypes.Display{MaxLines: 5, FontSize: "small", Format: "list", Color: "red"},
-			},
+		Name:          "round-trip-abc123ef",
+		Source:        savedviewtypes.SourceMetrics,
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName:    "round trip",
+			PanelType:      savedviewtypes.PanelTypeTable,
+			Queries:        testQueries(),
+			SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
+			Display:        savedviewtypes.Display{MaxLines: 5, FontSize: "small", Format: "list", Color: "red"},
 		},
 	}
 
@@ -188,10 +227,37 @@ func TestLegacyViewRoundTrip(t *testing.T) {
 
 	assert.Empty(t, roundTripped.Name)
 	assert.True(t, roundTripped.GenerateName)
-	assert.Equal(t, original.Data.Spec.DisplayName, roundTripped.Data.Spec.DisplayName)
+	assert.Equal(t, original.Spec.DisplayName, roundTripped.Spec.DisplayName)
 	assert.Equal(t, original.Source, roundTripped.Source)
-	assert.Equal(t, original.Data.Spec.PanelType, roundTripped.Data.Spec.PanelType)
-	assert.Equal(t, original.Data.Spec.Queries, roundTripped.Data.Spec.Queries)
-	assert.Equal(t, original.Data.Spec.SelectedFields, roundTripped.Data.Spec.SelectedFields)
-	assert.Equal(t, original.Data.Spec.Display, roundTripped.Data.Spec.Display)
+	assert.Equal(t, original.Spec.Queries, roundTripped.Spec.Queries)
+	assert.Equal(t, original.Spec.SelectedFields, roundTripped.Spec.SelectedFields)
+	assert.Equal(t, original.Spec.PanelType, roundTripped.Spec.PanelType)
+	assert.Equal(t, original.Spec.Display, roundTripped.Spec.Display)
+}
+
+func TestLegacyViewRoundTrip_EmptySelectedFieldsAndDisplay(t *testing.T) {
+	original := &savedviewtypes.SavedView{
+		Name:          "round-trip-empty-abc123ef",
+		Source:        savedviewtypes.SourceMetrics,
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName:    "round trip empty",
+			PanelType:      savedviewtypes.PanelTypeTable,
+			Queries:        testQueries(),
+			SelectedFields: []telemetrytypes.TelemetryFieldKey{},
+		},
+	}
+
+	legacy, err := newLegacyViewFromSavedView(original)
+	require.NoError(t, err)
+
+	var extra legacyExtraData
+	require.NoError(t, json.Unmarshal([]byte(legacy.ExtraData), &extra))
+	assert.Nil(t, extra.SelectColumns, "omitempty drops an empty selectColumns from extraData entirely")
+
+	roundTripped := newPostableSavedViewFromLegacyView(legacy)
+
+	assert.Empty(t, roundTripped.Spec.SelectedFields, "empty, not necessarily non-nil, on this leg of the round trip")
+	assert.Equal(t, savedviewtypes.PanelTypeTable, roundTripped.Spec.PanelType)
+	assert.Equal(t, savedviewtypes.Display{}, roundTripped.Spec.Display)
 }

pkg/modules/savedview/implsavedview/module.go

@@ -19,7 +19,11 @@ func NewModule(store savedviewtypes.Store) savedview.Module {
 }
 
 func (module *module) GetViewsForFilters(ctx context.Context, orgID string, source savedviewtypes.Source, name string) ([]*savedviewtypes.SavedView, error) {
-	return module.store.List(ctx, orgID, source, name)
+	storables, err := module.store.List(ctx, orgID, source, name)
+	if err != nil {
+		return nil, err
+	}
+	return savedviewtypes.NewSavedViewsFromStorableSavedViews(storables), nil
 }
 
 func (module *module) CreateView(ctx context.Context, orgID string, view savedviewtypes.PostableSavedView) (valuer.UUID, error) {
@@ -30,14 +34,19 @@ func (module *module) CreateView(ctx context.Context, orgID string, view savedvi
 
 	dbView := view.ToSavedView(orgID, claims.Email)
 
-	if err := module.store.Create(ctx, dbView); err != nil {
+	if err := module.store.Create(ctx, savedviewtypes.NewStorableSavedView(dbView)); err != nil {
 		return valuer.UUID{}, err
 	}
 	return dbView.ID, nil
 }
 
 func (module *module) GetView(ctx context.Context, orgID string, uuid valuer.UUID) (*savedviewtypes.SavedView, error) {
-	return module.store.Get(ctx, orgID, uuid)
+	storable, err := module.store.Get(ctx, orgID, uuid)
+	if err != nil {
+		return nil, err
+	}
+
+	return storable.ToSavedView(), nil
 }
 
 func (module *module) UpdateView(ctx context.Context, orgID string, uuid valuer.UUID, view savedviewtypes.UpdatableSavedView) error {
@@ -46,7 +55,8 @@ func (module *module) UpdateView(ctx context.Context, orgID string, uuid valuer.
 		return errors.NewInternalf(errors.CodeInternal, "error in getting email from context")
 	}
 
-	return module.store.Update(ctx, view.ToSavedView(uuid, orgID, claims.Email))
+	dbView := view.ToSavedView(uuid, orgID, claims.Email)
+	return module.store.Update(ctx, savedviewtypes.NewStorableSavedView(dbView))
 }
 
 func (module *module) DeleteView(ctx context.Context, orgID string, uuid valuer.UUID) error {
@@ -54,10 +64,10 @@ func (module *module) DeleteView(ctx context.Context, orgID string, uuid valuer.
 }
 
 func (module *module) Collect(ctx context.Context, orgID valuer.UUID) (map[string]any, error) {
-	savedViews, err := module.store.List(ctx, orgID.StringValue(), savedviewtypes.Source{}, "")
+	storables, err := module.store.List(ctx, orgID.StringValue(), savedviewtypes.Source{}, "")
 	if err != nil {
 		return nil, err
 	}
 
-	return savedviewtypes.NewStatsFromSavedViews(savedViews), nil
+	return savedviewtypes.NewStatsFromStorableSavedViews(storables), nil
 }

pkg/modules/savedview/implsavedview/module_test.go

@@ -28,24 +28,23 @@ func newTestStore() (savedview.Module, *savedviewtypestest.StoreTest) {
 
 func testPostableSavedView(name string, source savedviewtypes.Source) savedviewtypes.PostableSavedView {
 	return savedviewtypes.PostableSavedView{
-		Name:   name,
-		Source: source,
-		Data: savedviewtypes.SavedViewData{
-			SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
-			Spec: savedviewtypes.SavedViewSpec{
-				DisplayName: name,
-				PanelType:   savedviewtypes.PanelTypeGraph,
-				Queries: []qbtypes.QueryEnvelope{
-					{
-						Type: qbtypes.QueryTypeBuilder,
-						Spec: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
-							Signal:       telemetrytypes.SignalLogs,
-							Aggregations: []qbtypes.LogAggregation{{Expression: "count()"}},
-						},
+		Name:          name,
+		Source:        source,
+		SchemaVersion: savedviewtypes.SavedViewSchemaVersion,
+		Spec: savedviewtypes.SavedViewSpec{
+			DisplayName: name,
+			PanelType:   savedviewtypes.PanelTypeGraph,
+			RequestType: qbtypes.RequestTypeTimeSeries,
+			Queries: []qbtypes.QueryEnvelope{
+				{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
+						Signal:       telemetrytypes.SignalLogs,
+						Aggregations: []qbtypes.LogAggregation{{Expression: "count()"}},
 					},
 				},
-				SelectedFields: []telemetrytypes.TelemetryFieldKey{},
 			},
+			SelectedFields: []telemetrytypes.TelemetryFieldKey{},
 		},
 	}
 }
@@ -53,8 +52,9 @@ func testPostableSavedView(name string, source savedviewtypes.Source) savedviewt
 func testUpdatableSavedView(displayName string, source savedviewtypes.Source) savedviewtypes.UpdatableSavedView {
 	postable := testPostableSavedView(displayName, source)
 	return savedviewtypes.UpdatableSavedView{
-		Source: postable.Source,
-		Data:   postable.Data,
+		Source:        postable.Source,
+		SchemaVersion: postable.SchemaVersion,
+		Spec:          postable.Spec,
 	}
 }
 
@@ -93,7 +93,22 @@ func TestModule_CreateAndGetView(t *testing.T) {
 	assert.Equal(t, savedviewtypes.SourceLogs, got.Source)
 	assert.Equal(t, "creator@signoz.io", got.CreatedBy)
 	assert.Equal(t, "creator@signoz.io", got.UpdatedBy)
-	assert.Equal(t, savedviewtypes.PanelTypeGraph, got.Data.Spec.PanelType)
+	assert.Equal(t, savedviewtypes.PanelTypeGraph, got.Spec.PanelType)
+
+	require.NoError(t, st.AssertExpectations())
+}
+
+// A duplicate-name insert failure must surface as errors.TypeAlreadyExists, not a generic internal error.
+func TestModule_CreateView_DuplicateNameIsConflict(t *testing.T) {
+	m, st := newTestStore()
+
+	orgID := valuer.GenerateUUID().StringValue()
+	ctx := contextWithClaims(orgID, "creator@signoz.io")
+
+	st.ExpectCreateError(errors.Newf(errors.TypeInternal, errors.CodeInternal, "UNIQUE constraint failed: saved_view.org_id, saved_view.name"))
+	_, err := m.CreateView(ctx, orgID, testPostableSavedView("same-name", savedviewtypes.SourceLogs))
+	require.Error(t, err)
+	assert.True(t, errors.Ast(err, errors.TypeAlreadyExists), "expected an already-exists error, got %v", err)
 
 	require.NoError(t, st.AssertExpectations())
 }
@@ -138,21 +153,21 @@ func TestModule_UpdateView(t *testing.T) {
 	existingName := existing.Name
 
 	updated := testUpdatableSavedView("renamed", savedviewtypes.SourceTraces)
-	updated.Data.Spec.PanelType = savedviewtypes.PanelTypeTable
+	updated.Spec.PanelType = savedviewtypes.PanelTypeTable
 
 	st.ExpectUpdate(orgID, id, 1)
 	require.NoError(t, m.UpdateView(contextWithClaims(orgID, "updater@signoz.io"), orgID, id, updated))
 
 	stored := testSavedView(orgID, id, "updater@signoz.io", testPostableSavedView("renamed", savedviewtypes.SourceTraces))
 	stored.Name = existingName
-	stored.Data.Spec.PanelType = savedviewtypes.PanelTypeTable
+	stored.Spec.PanelType = savedviewtypes.PanelTypeTable
 	st.ExpectGet(orgID, id, stored)
 	got, err := m.GetView(contextWithClaims(orgID, "creator@signoz.io"), orgID, id)
 	require.NoError(t, err)
 	assert.Equal(t, existingName, got.Name, "name must not change on update")
-	assert.Equal(t, "renamed", got.Data.Spec.DisplayName)
+	assert.Equal(t, "renamed", got.Spec.DisplayName)
 	assert.Equal(t, savedviewtypes.SourceTraces, got.Source)
-	assert.Equal(t, savedviewtypes.PanelTypeTable, got.Data.Spec.PanelType)
+	assert.Equal(t, savedviewtypes.PanelTypeTable, got.Spec.PanelType)
 	assert.Equal(t, "updater@signoz.io", got.UpdatedBy)
 
 	require.NoError(t, st.AssertExpectations())

pkg/modules/savedview/implsavedview/store.go

@@ -6,7 +6,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/savedviewtypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -18,32 +17,31 @@ func NewStore(sqlstore sqlstore.SQLStore) savedviewtypes.Store {
 	return &store{sqlstore: sqlstore}
 }
 
-func (store *store) Create(ctx context.Context, view *savedviewtypes.SavedView) error {
-	_, err := store.sqlstore.BunDB().NewInsert().Model(view).Exec(ctx)
+func (store *store) Create(ctx context.Context, storable *savedviewtypes.StorableSavedView) error {
+	_, err := store.sqlstore.BunDB().NewInsert().Model(storable).Exec(ctx)
 	if err != nil {
-		return store.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "saved view with name %s already exists", view.Name)
+		return store.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "saved view with name %s already exists", storable.Name)
 	}
 	return nil
 }
 
-func (store *store) Get(ctx context.Context, orgID string, id valuer.UUID) (*savedviewtypes.SavedView, error) {
-	var view savedviewtypes.SavedView
-	err := store.sqlstore.BunDB().NewSelect().Model(&view).Where("org_id = ? AND id = ?", orgID, id.StringValue()).Scan(ctx)
+func (store *store) Get(ctx context.Context, orgID string, id valuer.UUID) (*savedviewtypes.StorableSavedView, error) {
+	var storable savedviewtypes.StorableSavedView
+	err := store.sqlstore.BunDB().NewSelect().Model(&storable).Where("org_id = ? AND id = ?", orgID, id.StringValue()).Scan(ctx)
 	if err != nil {
 		return nil, store.sqlstore.WrapNotFoundErrf(err, savedviewtypes.ErrCodeSavedViewNotFound, "saved view %s not found", id.StringValue())
 	}
 
-	normalizeSelectedFields(&view)
-	return &view, nil
+	return &storable, nil
 }
 
-func (store *store) Update(ctx context.Context, view *savedviewtypes.SavedView) error {
+func (store *store) Update(ctx context.Context, storable *savedviewtypes.StorableSavedView) error {
 	res, err := store.sqlstore.BunDB().NewUpdate().
-		Model(&savedviewtypes.SavedView{}).
+		Model((*savedviewtypes.StorableSavedView)(nil)).
 		Set("updated_at = ?, updated_by = ?, source = ?, data = ?",
-			view.UpdatedAt, view.UpdatedBy, view.Source, view.Data).
-		Where("id = ?", view.ID.StringValue()).
-		Where("org_id = ?", view.OrgID).
+			storable.UpdatedAt, storable.UpdatedBy, storable.Source, storable.Data).
+		Where("id = ?", storable.ID.StringValue()).
+		Where("org_id = ?", storable.OrgID).
 		Exec(ctx)
 	if err != nil {
 		return errors.WrapInternalf(err, errors.CodeInternal, "error in updating saved view")
@@ -54,7 +52,7 @@ func (store *store) Update(ctx context.Context, view *savedviewtypes.SavedView)
 		return errors.WrapInternalf(err, errors.CodeInternal, "error in verifying the updated saved view")
 	}
 	if rowsAffected == 0 {
-		return errors.NewNotFoundf(savedviewtypes.ErrCodeSavedViewNotFound, "saved view %s not found", view.ID.StringValue())
+		return errors.NewNotFoundf(savedviewtypes.ErrCodeSavedViewNotFound, "saved view %s not found", storable.ID.StringValue())
 	}
 
 	return nil
@@ -62,7 +60,7 @@ func (store *store) Update(ctx context.Context, view *savedviewtypes.SavedView)
 
 func (store *store) Delete(ctx context.Context, orgID string, id valuer.UUID) error {
 	res, err := store.sqlstore.BunDB().NewDelete().
-		Model(&savedviewtypes.SavedView{}).
+		Model((*savedviewtypes.StorableSavedView)(nil)).
 		Where("id = ?", id.StringValue()).
 		Where("org_id = ?", orgID).
 		Exec(ctx)
@@ -81,9 +79,9 @@ func (store *store) Delete(ctx context.Context, orgID string, id valuer.UUID) er
 	return nil
 }
 
-func (store *store) List(ctx context.Context, orgID string, source savedviewtypes.Source, name string) ([]*savedviewtypes.SavedView, error) {
-	var views []*savedviewtypes.SavedView
-	q := store.sqlstore.BunDB().NewSelect().Model(&views).
+func (store *store) List(ctx context.Context, orgID string, source savedviewtypes.Source, name string) ([]*savedviewtypes.StorableSavedView, error) {
+	var storables []*savedviewtypes.StorableSavedView
+	q := store.sqlstore.BunDB().NewSelect().Model(&storables).
 		Where("org_id = ?", orgID).
 		Where("name LIKE ?", "%"+name+"%")
 	if !source.IsZero() {
@@ -94,16 +92,5 @@ func (store *store) List(ctx context.Context, orgID string, source savedviewtype
 		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error in getting saved views")
 	}
 
-	for _, view := range views {
-		normalizeSelectedFields(view)
-	}
-
-	return views, nil
-}
-
-// normalizeSelectedFields fixes up a scanned row's nil SelectedFields.
-func normalizeSelectedFields(view *savedviewtypes.SavedView) {
-	if view.Data.Spec.SelectedFields == nil {
-		view.Data.Spec.SelectedFields = []telemetrytypes.TelemetryFieldKey{}
-	}
+	return storables, nil
 }

pkg/querier/promql_query.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"math"
 	"regexp"
 	"sort"
 	"strings"
@@ -479,19 +478,11 @@ func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began ti
 
 		for idx := range v.Floats {
 			p := v.Floats[idx]
-			// NaN and +/-Inf have no JSON number form and nothing to plot; the
-			// builder path drops them while scanning rows (see consume.go).
-			if math.IsNaN(p.F) || math.IsInf(p.F, 0) {
-				continue
-			}
 			s.Values = append(s.Values, &qbv5.TimeSeriesValue{
 				Timestamp: p.T,
 				Value:     p.F,
 			})
 		}
-		if len(s.Values) == 0 {
-			continue
-		}
 		series = append(series, &s)
 	}
 
@@ -503,11 +494,13 @@ func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began ti
 	}
 	statsMu.Unlock()
 
-	tsData := &qbv5.TimeSeriesData{QueryName: q.query.Name}
-	// No bucket at all when nothing survived: a bucket holding no series reads
-	// as "filtered to empty" to the cache, which stores it as a real result.
-	if len(series) > 0 {
-		tsData.Aggregations = []*qbv5.AggregationBucket{{Series: series}}
+	tsData := &qbv5.TimeSeriesData{
+		QueryName: q.query.Name,
+		Aggregations: []*qbv5.AggregationBucket{
+			{
+				Series: series,
+			},
+		},
 	}
 
 	var payload any = tsData

pkg/querier/promql_query_test.go

@@ -2,21 +2,14 @@ package querier
 
 import (
 	"log/slog"
-	"math"
 	"strings"
-	"sync"
 	"testing"
-	"time"
-
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/prometheus/prometheustest"
 	qbv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestRemoveAllVarMatchers(t *testing.T) {
@@ -460,82 +453,3 @@ func TestFingerprint_PinnedProviderBypassesCache(t *testing.T) {
 	}
 	assert.Empty(t, q.Fingerprint())
 }
-
-func TestToResultDropsNonFiniteValues(t *testing.T) {
-	tests := []struct {
-		description        string
-		floats             []promql.FPoint
-		expectedTimestamps []int64
-		expectedValues     []float64
-	}{
-		{
-			description:        "finite values pass through untouched",
-			floats:             []promql.FPoint{{T: 1000, F: 1.5}, {T: 2000, F: 2.5}},
-			expectedTimestamps: []int64{1000, 2000},
-			expectedValues:     []float64{1.5, 2.5},
-		},
-		{
-			description:        "a ratio's 0/0 points are dropped, the rest kept",
-			floats:             []promql.FPoint{{T: 1000, F: 1.5}, {T: 2000, F: math.NaN()}, {T: 3000, F: 2.5}},
-			expectedTimestamps: []int64{1000, 3000},
-			expectedValues:     []float64{1.5, 2.5},
-		},
-		{
-			description:        "both infinities are dropped",
-			floats:             []promql.FPoint{{T: 1000, F: math.Inf(1)}, {T: 2000, F: 4.5}, {T: 3000, F: math.Inf(-1)}},
-			expectedTimestamps: []int64{2000},
-			expectedValues:     []float64{4.5},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			q := &promqlQuery{query: qbv5.PromQuery{Name: "A"}, requestType: qbv5.RequestTypeTimeSeries}
-			matrix := promql.Matrix{{Metric: labels.FromStrings("job_name", "dbBloatMonitorJob"), Floats: test.floats}}
-
-			var mu sync.Mutex
-			var rows, bytes uint64
-			result := q.toResult(matrix, nil, time.Now(), &mu, &rows, &bytes)
-
-			tsData, ok := result.Value.(*qbv5.TimeSeriesData)
-			require.True(t, ok)
-			require.Len(t, tsData.Aggregations, 1)
-			require.Len(t, tsData.Aggregations[0].Series, 1)
-
-			timestamps := make([]int64, 0, len(test.expectedTimestamps))
-			values := make([]float64, 0, len(test.expectedValues))
-			for _, v := range tsData.Aggregations[0].Series[0].Values {
-				timestamps = append(timestamps, v.Timestamp)
-				values = append(values, v.Value)
-			}
-			assert.Equal(t, test.expectedTimestamps, timestamps)
-			assert.Equal(t, test.expectedValues, values)
-		})
-	}
-}
-
-// A series left with nothing must not surface as an empty series, and a result
-// left with no series must carry no aggregation bucket at all — the cache reads
-// a bucket holding no series as a real, filtered-to-empty result and stores it.
-func TestToResultDropsSeriesAndBucketLeftEmpty(t *testing.T) {
-	q := &promqlQuery{query: qbv5.PromQuery{Name: "A"}, requestType: qbv5.RequestTypeTimeSeries}
-	matrix := promql.Matrix{
-		{Metric: labels.FromStrings("job_name", "idleJob"), Floats: []promql.FPoint{{T: 1000, F: math.NaN()}}},
-		{Metric: labels.FromStrings("job_name", "activeJob"), Floats: []promql.FPoint{{T: 1000, F: 7.5}}},
-	}
-
-	var mu sync.Mutex
-	var rows, bytes uint64
-	tsData, ok := q.toResult(matrix, nil, time.Now(), &mu, &rows, &bytes).Value.(*qbv5.TimeSeriesData)
-	require.True(t, ok)
-	require.Len(t, tsData.Aggregations, 1)
-	require.Len(t, tsData.Aggregations[0].Series, 1, "the all-NaN series is gone")
-	assert.Equal(t, "activeJob", tsData.Aggregations[0].Series[0].Labels[0].Value)
-
-	allNaN := promql.Matrix{
-		{Metric: labels.FromStrings("job_name", "idleJob"), Floats: []promql.FPoint{{T: 1000, F: math.NaN()}}},
-	}
-	tsData, ok = q.toResult(allNaN, nil, time.Now(), &mu, &rows, &bytes).Value.(*qbv5.TimeSeriesData)
-	require.True(t, ok)
-	assert.Empty(t, tsData.Aggregations)
-}

pkg/querybuilder/query_to_keys.go

@@ -56,6 +56,17 @@ func QueryStringToKeysSelectors(query string) []*telemetrytypes.FieldKeySelector
 					FieldDataType: key.FieldDataType,
 				})
 			}
+
+			// todo(tushar): consider reverting changes done to this method in below PR to avoid scope specific checks
+			// https://github.com/SigNoz/signoz/issues/11374
+			if key.FieldContext == telemetrytypes.FieldContextScope {
+				keys = append(keys, &telemetrytypes.FieldKeySelector{
+					Name:          key.FieldContext.StringValue() + "." + key.Name,
+					Signal:        key.Signal,
+					FieldContext:  telemetrytypes.FieldContextUnspecified, // this allows 'scope.' prefix for keys with other context as well
+					FieldDataType: key.FieldDataType,
+				})
+			}
 		}
 	}
 

pkg/querybuilder/query_to_keys_test.go

@@ -72,6 +72,23 @@ func TestQueryToKeys(t *testing.T) {
 				},
 			},
 		},
+		{
+			query: `scope.version = '1.0.0'`,
+			expectedKeys: []telemetrytypes.FieldKeySelector{
+				{
+					Name:          "version",
+					Signal:        telemetrytypes.SignalUnspecified,
+					FieldContext:  telemetrytypes.FieldContextScope,
+					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
+				},
+				{
+					Name:          "scope.version",
+					Signal:        telemetrytypes.SignalUnspecified,
+					FieldContext:  telemetrytypes.FieldContextUnspecified,
+					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
+				},
+			},
+		},
 	}
 
 	for _, testCase := range testCases {

pkg/signoz/provider.go

@@ -237,6 +237,8 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddDashboardTuplesFactory(sqlstore),
 		sqlmigration.NewRestructureSavedViewSpecFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddSavedViewTuplesFactory(sqlstore),
+		sqlmigration.NewFixSavedViewSelectedFieldsFactory(sqlstore),
+		sqlmigration.NewBackfillSavedViewRequestTypeFactory(sqlstore),
 	)
 }
 

pkg/sqlmigration/111_fix_saved_view_selected_fields.go

@@ -0,0 +1,220 @@
+package sqlmigration
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+// knownQueryTypes mirrors the discriminator values qbtypes.QueryType currently defines.
+var knownQueryTypes = map[string]bool{
+	"builder_query":          true,
+	"builder_ai_query":       true,
+	"builder_formula":        true,
+	"builder_sub_query":      true,
+	"builder_join":           true,
+	"builder_trace_operator": true,
+	"clickhouse_sql":         true,
+	"promql":                 true,
+}
+
+// specFieldZeroValueJSON is the JSON to substitute for a spec key that fails to unmarshal.
+var specFieldZeroValueJSON = map[string]string{
+	"displayName":    `""`,
+	"panelType":      `""`,
+	"queries":        `[]`,
+	"selectedFields": `[]`,
+	"display":        `{}`,
+}
+
+// storableSavedViewData is the shape of the `saved_view` table this migration repairs.
+type storableSavedViewData struct {
+	bun.BaseModel `bun:"table:saved_view"`
+
+	ID   string `bun:"id,pk,type:text"`
+	Data string `bun:"data,type:text"`
+}
+
+// queryEnvelope mirrors minimal required qbtypes.QueryEnvelope.
+type queryEnvelope struct {
+	Type string          `json:"type"`
+	Spec json.RawMessage `json:"spec"`
+}
+
+// telemetryFieldKey mirrors telemetrytypes.TelemetryFieldKey's JSON-visible fields.
+// Signal/FieldContext/FieldDataType are plain strings to test UnmarshalJSON.
+type telemetryFieldKey struct {
+	Name          string `json:"name"`
+	Description   string `json:"description"`
+	Unit          string `json:"unit"`
+	Signal        string `json:"signal"`
+	FieldContext  string `json:"fieldContext"`
+	FieldDataType string `json:"fieldDataType"`
+}
+
+// fixDisplay mirrors savedviewtypes.Display.
+type fixDisplay struct {
+	MaxLines int    `json:"maxLines"`
+	FontSize string `json:"fontSize"`
+	Format   string `json:"format"`
+	Color    string `json:"color"`
+}
+
+// fixSpec mirrors savedviewtypes.SavedViewSpec.
+type fixSpec struct {
+	DisplayName    string              `json:"displayName"`
+	PanelType      string              `json:"panelType"`
+	Queries        []queryEnvelope     `json:"queries"`
+	SelectedFields []telemetryFieldKey `json:"selectedFields"`
+	Display        fixDisplay          `json:"display"`
+}
+
+// fixData mirrors savedviewtypes.SavedViewData.
+type fixData struct {
+	SchemaVersion string  `json:"schemaVersion"`
+	Spec          fixSpec `json:"spec"`
+}
+
+type fixSavedViewSelectedFields struct {
+	sqlstore sqlstore.SQLStore
+	settings factory.ProviderSettings
+}
+
+func NewFixSavedViewSelectedFieldsFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("fix_saved_view_selected_fields"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &fixSavedViewSelectedFields{sqlstore: sqlstore, settings: ps}, nil
+	})
+}
+
+func (migration *fixSavedViewSelectedFields) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *fixSavedViewSelectedFields) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	var rows []*storableSavedViewData
+	if err := tx.NewSelect().Model(&rows).Scan(ctx); err != nil {
+		return err
+	}
+
+	var repaired, deleted int
+	for _, row := range rows {
+		fixedData, blanked, ok := repairSavedViewData(row.Data)
+		if ok && len(blanked) == 0 {
+			// already scans cleanly field-by-field -- nothing to repair.
+			continue
+		}
+		if !ok {
+			migration.settings.Logger.WarnContext(ctx, "saved view data could not be repaired field-by-field, deleting the row", slog.String("saved_view_id", row.ID), slog.String("raw_data", row.Data))
+			if _, err := tx.NewDelete().Model((*storableSavedViewData)(nil)).Where("id = ?", row.ID).Exec(ctx); err != nil {
+				return err
+			}
+			deleted++
+			continue
+		}
+
+		repaired++
+		migration.settings.Logger.WarnContext(ctx, "repaired saved view data by blanking fields that failed to unmarshal", slog.String("saved_view_id", row.ID), slog.Any("fields_blanked", blanked))
+
+		if _, err := tx.NewUpdate().Model((*storableSavedViewData)(nil)).Set("data = ?", fixedData).Where("id = ?", row.ID).Exec(ctx); err != nil {
+			return err
+		}
+	}
+
+	migration.settings.Logger.InfoContext(ctx, "checked saved views for unreadable data", slog.Int("total", len(rows)), slog.Int("repaired", repaired), slog.Int("deleted", deleted))
+
+	return tx.Commit()
+}
+
+func (migration *fixSavedViewSelectedFields) Down(context.Context, *bun.DB) error {
+	return nil
+}
+
+// specFieldUnmarshalsCleanly reports whether value can be unmarshalled into
+// the expected shape of the given savedviewtypes.SavedViewSpec JSON key.
+func specFieldUnmarshalsCleanly(key string, value json.RawMessage) bool {
+	switch key {
+	case "displayName", "panelType":
+		var s string
+		return json.Unmarshal(value, &s) == nil
+	case "queries":
+		var q []queryEnvelope
+		if err := json.Unmarshal(value, &q); err != nil {
+			return false
+		}
+		if q == nil {
+			// a JSON null unmarshals into a nil slice with no error; treat it as unclean so it
+			// gets blanked to [] rather than shipping "queries": null against a nullable:false schema.
+			return false
+		}
+		for _, e := range q {
+			if !knownQueryTypes[e.Type] || len(e.Spec) == 0 {
+				return false
+			}
+		}
+		return true
+	case "selectedFields":
+		var f []telemetryFieldKey
+		if err := json.Unmarshal(value, &f); err != nil {
+			return false
+		}
+		// same null-vs-[] gap as "queries" above: blank a JSON null to [] instead of leaving it.
+		return f != nil
+	case "display":
+		var d fixDisplay
+		return json.Unmarshal(value, &d) == nil
+	default:
+		return true
+	}
+}
+
+// repairSavedViewData tries to make data unmarshal cleanly by blanking, one key at a time,
+// whichever top-level spec fields fail to unmarshal into their expected shape.
+func repairSavedViewData(data string) (fixed string, blanked []string, ok bool) {
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(data), &raw); err != nil {
+		return "", nil, false
+	}
+
+	var spec map[string]json.RawMessage
+	if err := json.Unmarshal(raw["spec"], &spec); err != nil {
+		return "", nil, false
+	}
+
+	for key, value := range spec {
+		if specFieldUnmarshalsCleanly(key, value) {
+			continue
+		}
+		spec[key] = json.RawMessage(specFieldZeroValueJSON[key])
+		blanked = append(blanked, key)
+	}
+
+	fixedSpec, err := json.Marshal(spec)
+	if err != nil {
+		return "", nil, false
+	}
+	raw["spec"] = fixedSpec
+
+	fixedData, err := json.Marshal(raw)
+	if err != nil {
+		return "", nil, false
+	}
+
+	// verify the fix actually round-trips before writing it.
+	if err := json.Unmarshal(fixedData, new(fixData)); err != nil {
+		return "", nil, false
+	}
+
+	return string(fixedData), blanked, true
+}

pkg/sqlmigration/112_backfill_saved_view_request_type.go

@@ -0,0 +1,152 @@
+package sqlmigration
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+// panelTypeToRequestType mirrors savedviewtypes.LegacyRequestTypeForPanelType.
+var panelTypeToRequestType = map[string]string{
+	"list":  "raw",
+	"trace": "trace",
+	"graph": "time_series",
+}
+
+// storableSavedViewRow is the shape of the `saved_view` table this migration repairs.
+type storableSavedViewRow struct {
+	bun.BaseModel `bun:"table:saved_view"`
+
+	ID   string `bun:"id,pk,type:text"`
+	Data string `bun:"data,type:text"`
+}
+
+// viewSpec mirrors savedviewtypes.SavedViewSpec, used only to verify the fix round-trips.
+type viewSpec struct {
+	DisplayName    string          `json:"displayName"`
+	PanelType      string          `json:"panelType"`
+	RequestType    string          `json:"requestType"`
+	Queries        json.RawMessage `json:"queries"`
+	SelectedFields json.RawMessage `json:"selectedFields"`
+	Display        json.RawMessage `json:"display"`
+}
+
+type viewData struct {
+	SchemaVersion string   `json:"schemaVersion"`
+	Spec          viewSpec `json:"spec"`
+}
+
+type savedViewRequestType struct {
+	sqlstore sqlstore.SQLStore
+	settings factory.ProviderSettings
+}
+
+func NewBackfillSavedViewRequestTypeFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("backfill_view_request_type"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &savedViewRequestType{sqlstore: sqlstore, settings: ps}, nil
+	})
+}
+
+func (migration *savedViewRequestType) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *savedViewRequestType) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	var rows []*storableSavedViewRow
+	if err := tx.NewSelect().Model(&rows).Scan(ctx); err != nil {
+		return err
+	}
+
+	var migrated, skipped int
+	for _, row := range rows {
+		fixedData, ok := backfillSavedViewRequestType(row.Data)
+		if !ok {
+			migration.settings.Logger.WarnContext(ctx, "saved view data could not be repaired, leaving it untouched", slog.String("saved_view_id", row.ID), slog.String("raw_data", row.Data))
+			skipped++
+			continue
+		}
+		if fixedData == "" {
+			// already has a requestType -- nothing to do.
+			continue
+		}
+
+		migrated++
+		if _, err := tx.NewUpdate().Model((*storableSavedViewRow)(nil)).Set("data = ?", fixedData).Where("id = ?", row.ID).Exec(ctx); err != nil {
+			return err
+		}
+	}
+
+	migration.settings.Logger.InfoContext(ctx, "backfilled saved view requestType from panelType", slog.Int("total", len(rows)), slog.Int("migrated", migrated), slog.Int("skipped", skipped))
+
+	return tx.Commit()
+}
+
+func (migration *savedViewRequestType) Down(context.Context, *bun.DB) error {
+	return nil
+}
+
+// backfillSavedViewRequestType sets spec.requestType from spec.panelType when absent, leaving
+// panelType where it already is. Returns ok=false if data can't be parsed at all, and fixed="" if
+// there's nothing to do (requestType already set).
+func backfillSavedViewRequestType(data string) (fixed string, ok bool) {
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(data), &raw); err != nil {
+		return "", false
+	}
+
+	var spec map[string]json.RawMessage
+	if err := json.Unmarshal(raw["spec"], &spec); err != nil {
+		return "", false
+	}
+
+	if requestTypeRaw, ok := spec["requestType"]; ok && string(requestTypeRaw) != `""` {
+		return "", true
+	}
+
+	var panelType string
+	if panelTypeRaw, ok := spec["panelType"]; ok {
+		if err := json.Unmarshal(panelTypeRaw, &panelType); err != nil {
+			return "", false
+		}
+	}
+
+	requestType, known := panelTypeToRequestType[panelType]
+	if !known {
+		requestType = "scalar"
+	}
+	requestTypeJSON, err := json.Marshal(requestType)
+	if err != nil {
+		return "", false
+	}
+	spec["requestType"] = requestTypeJSON
+
+	fixedSpec, err := json.Marshal(spec)
+	if err != nil {
+		return "", false
+	}
+	raw["spec"] = fixedSpec
+
+	fixedData, err := json.Marshal(raw)
+	if err != nil {
+		return "", false
+	}
+
+	// verify the fix actually round-trips before writing it.
+	if err := json.Unmarshal(fixedData, new(viewData)); err != nil {
+		return "", false
+	}
+
+	return string(fixedData), true
+}

pkg/statementbuilder/tracesstatementbuilder/stmt_builder_test.go

@@ -373,6 +373,94 @@ func TestStatementBuilder(t *testing.T) {
 			},
 			expectedErr: nil,
 		},
+		{
+			name:        "scope.name filter and group by",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal:       telemetrytypes.SignalTraces,
+				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
+				Aggregations: []qbtypes.TraceAggregation{
+					{
+						Expression: "count()",
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "scope.name = 'opentelemetry-io'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name:         "scope.name",
+							FieldContext: telemetrytypes.FieldContextScope,
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __limit_cte AS (SELECT toString(multiIf(scope.name::String IS NOT NULL, scope.name::String, NULL)) AS `scope.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.name::String = ? AND scope.name::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? GROUP BY `scope.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(timestamp, INTERVAL 30 SECOND) AS ts, toString(multiIf(scope.name::String IS NOT NULL, scope.name::String, NULL)) AS `scope.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.name::String = ? AND scope.name::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? AND (`scope.name`) GLOBAL IN (SELECT `scope.name` FROM __limit_cte) GROUP BY ts, `scope.name`",
+				Args:  []any{"opentelemetry-io", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10, "opentelemetry-io", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448)},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:        "scope.version filter with scope.name group by",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal:       telemetrytypes.SignalTraces,
+				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
+				Aggregations: []qbtypes.TraceAggregation{
+					{
+						Expression: "count()",
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "scope.version = '1.0.0'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name:         "scope.name",
+							FieldContext: telemetrytypes.FieldContextScope,
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __limit_cte AS (SELECT toString(multiIf(scope.name::String IS NOT NULL, scope.name::String, NULL)) AS `scope.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.version::String = ? AND scope.version::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? GROUP BY `scope.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(timestamp, INTERVAL 30 SECOND) AS ts, toString(multiIf(scope.name::String IS NOT NULL, scope.name::String, NULL)) AS `scope.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.version::String = ? AND scope.version::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? AND (`scope.name`) GLOBAL IN (SELECT `scope.name` FROM __limit_cte) GROUP BY ts, `scope.name`",
+				Args:  []any{"1.0.0", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10, "1.0.0", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448)},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:        "scope.version filter only (no scope field in group by)",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal:       telemetrytypes.SignalTraces,
+				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
+				Aggregations: []qbtypes.TraceAggregation{
+					{
+						Expression: "count()",
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "scope.version = '1.0.0'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "service.name",
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __limit_cte AS (SELECT toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.version::String = ? AND scope.version::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(timestamp, INTERVAL 30 SECOND) AS ts, toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.version::String = ? AND scope.version::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name`",
+				Args:  []any{"1.0.0", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10, "1.0.0", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448)},
+			},
+		},
 	}
 
 	fl := flaggertest.New(t)
@@ -799,6 +887,52 @@ func TestStatementBuilderListQueryWithCorruptData(t *testing.T) {
 			},
 			expectedErr: nil,
 		},
+		{
+			name:        "List query with scope filter only (no scope in select or group by)",
+			requestType: qbtypes.RequestTypeRaw,
+			keysMap: map[string][]*telemetrytypes.TelemetryFieldKey{
+				"scope.version": {
+					{
+						Name:          "scope.version",
+						Signal:        telemetrytypes.SignalTraces,
+						FieldContext:  telemetrytypes.FieldContextScope,
+						FieldDataType: telemetrytypes.FieldDataTypeString,
+					},
+				},
+			},
+			query: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal:       telemetrytypes.SignalTraces,
+				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
+				Filter: &qbtypes.Filter{
+					Expression: "scope.version = '1.0.0'",
+				},
+				Limit: 10,
+			},
+			expected: qbtypes.Statement{
+				Query: "SELECT timestamp AS `timestamp`, trace_id AS `trace_id`, span_id AS `span_id`, trace_state AS `trace_state`, parent_span_id AS `parent_span_id`, flags AS `flags`, name AS `name`, kind AS `kind`, kind_string AS `kind_string`, duration_nano AS `duration_nano`, status_code AS `status_code`, status_message AS `status_message`, status_code_string AS `status_code_string`, events AS `events`, links AS `links`, response_status_code AS `response_status_code`, external_http_url AS `external_http_url`, http_url AS `http_url`, external_http_method AS `external_http_method`, http_method AS `http_method`, http_host AS `http_host`, db_name AS `db_name`, db_operation AS `db_operation`, has_error AS `has_error`, is_remote AS `is_remote`, attributes_string, attributes_number, attributes_bool, resources_string FROM signoz_traces.distributed_signoz_index_v3 WHERE (scope.version::String = ? AND scope.version::String IS NOT NULL) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? LIMIT ?",
+				Args:  []any{"1.0.0", "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10},
+			},
+		},
+		{
+			// Regression test: scope.version in selectFields with no metadata (isColumn=true filters it out)
+			// must still produce scope.version::String, not scope.attributes.version::String
+			name:        "scope.version in selectFields only, no metadata (intrinsic field fallback)",
+			requestType: qbtypes.RequestTypeRaw,
+			keysMap:     map[string][]*telemetrytypes.TelemetryFieldKey{},
+			query: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal:       telemetrytypes.SignalTraces,
+				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
+				Filter:       &qbtypes.Filter{},
+				SelectFields: []telemetrytypes.TelemetryFieldKey{
+					{Name: "scope.version", FieldContext: telemetrytypes.FieldContextUnspecified},
+				},
+				Limit: 10,
+			},
+			expected: qbtypes.Statement{
+				Query: "SELECT timestamp AS `timestamp`, trace_id AS `trace_id`, span_id AS `span_id`, scope.version::String AS `scope.version` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? LIMIT ?",
+				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10},
+			},
+		},
 	}
 
 	for _, c := range cases {

pkg/telemetrymetadata/metadata.go

@@ -180,7 +180,7 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 		`CASE
 			// WHEN tagType = 'spanfield' THEN 1
 			WHEN tagType = 'resource' THEN 2
-			// WHEN tagType = 'scope' THEN 3
+			WHEN tagType = 'scope' THEN 3
 			WHEN tagType = 'tag' THEN 4
 			ELSE 5
 		END as priority`,

pkg/telemetryschema/tracestelemetryschema/const.go

@@ -121,6 +121,20 @@ var (
 			FieldContext:  telemetrytypes.FieldContextSpan,
 			FieldDataType: telemetrytypes.FieldDataTypeString,
 		},
+		"scope.name": {
+			Name:          "scope.name",
+			Description:   "Instrumentation scope name",
+			Signal:        telemetrytypes.SignalTraces,
+			FieldContext:  telemetrytypes.FieldContextScope,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
+		},
+		"scope.version": {
+			Name:          "scope.version",
+			Description:   "Instrumentation scope version",
+			Signal:        telemetrytypes.SignalTraces,
+			FieldContext:  telemetrytypes.FieldContextScope,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
+		},
 	}
 	IntrinsicFieldsDeprecated = map[string]telemetrytypes.TelemetryFieldKey{
 		"traceID": {

pkg/telemetryschema/tracestelemetryschema/field_mapper.go

@@ -52,6 +52,7 @@ var (
 			ValueType: schema.ColumnTypeString,
 		}},
 		"resource": {Name: "resource", Type: schema.JSONColumnType{}},
+		"scope":    {Name: "scope", Type: schema.JSONColumnType{}},
 
 		"events": {Name: "events", Type: schema.ArrayColumnType{
 			ElementType: schema.ColumnTypeString,
@@ -176,7 +177,7 @@ func (m *fieldMapper) getColumn(
 	case telemetrytypes.FieldContextResource:
 		return []*schema.Column{indexV3Columns["resource"], indexV3Columns["resources_string"]}, nil
 	case telemetrytypes.FieldContextScope:
-		return []*schema.Column{}, qbtypes.ErrColumnNotFound
+		return []*schema.Column{indexV3Columns["scope"]}, nil
 	case telemetrytypes.FieldContextAttribute:
 		switch key.FieldDataType {
 		case telemetrytypes.FieldDataTypeString:
@@ -287,14 +288,24 @@ func (m *fieldMapper) resolveColumnExprs(
 
 		switch column.Type.GetType() {
 		case schema.ColumnTypeEnumJSON:
-			// json is only supported for resource context as of now
-			if key.FieldContext != telemetrytypes.FieldContextResource {
-				return nil, nil, nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource context fields are supported for json columns, got %s", key.FieldContext.String)
-			}
 			// have to add ::string as clickHouse throws an error :- data types Variant/Dynamic are not allowed in GROUP BY
 			// once clickHouse dependency is updated, we need to check if we can remove it.
-			exprs = append(exprs, fmt.Sprintf("%s.`%s`::String", columnName, key.Name))
-			existExprs = append(existExprs, fmt.Sprintf("%s.`%s` IS NOT NULL", columnName, key.Name))
+			switch key.FieldContext {
+			case telemetrytypes.FieldContextResource:
+				exprs = append(exprs, fmt.Sprintf("%s.`%s`::String", columnName, key.Name))
+				existExprs = append(existExprs, fmt.Sprintf("%s.`%s` IS NOT NULL", columnName, key.Name))
+			case telemetrytypes.FieldContextScope:
+				switch key.Name {
+				case "scope.name", "scope.version":
+					exprs = append(exprs, fmt.Sprintf("%s::String", key.Name))
+					existExprs = append(existExprs, fmt.Sprintf("%s IS NOT NULL", key.Name))
+				default:
+					exprs = append(exprs, fmt.Sprintf("%s.attributes.`%s`::String", columnName, key.Name))
+					existExprs = append(existExprs, fmt.Sprintf("%s.attributes.`%s` IS NOT NULL", columnName, key.Name))
+				}
+			default:
+				return nil, nil, nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource and scope context fields are supported for json columns, got %s", key.FieldContext.String)
+			}
 		case schema.ColumnTypeEnumString,
 			schema.ColumnTypeEnumUInt64,
 			schema.ColumnTypeEnumUInt32,

pkg/telemetryschema/tracestelemetryschema/field_mapper_test.go

@@ -83,6 +83,33 @@ func TestGetFieldKeyName(t *testing.T) {
 			expectedResult: "multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, `resource_string_deployment$$environment_exists`, `resource_string_deployment$$environment`, NULL)",
 			expectedError:  nil,
 		},
+		{
+			name: "Scope field - scope.name",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "scope.name",
+				FieldContext: telemetrytypes.FieldContextScope,
+			},
+			expectedResult: "scope.name::String",
+			expectedError:  nil,
+		},
+		{
+			name: "Scope field - scope.version",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "scope.version",
+				FieldContext: telemetrytypes.FieldContextScope,
+			},
+			expectedResult: "scope.version::String",
+			expectedError:  nil,
+		},
+		{
+			name: "Scope field - custom attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "custom.attr",
+				FieldContext: telemetrytypes.FieldContextScope,
+			},
+			expectedResult: "scope.attributes.`custom.attr`::String",
+			expectedError:  nil,
+		},
 		{
 			// Query like `attribute.attribute_string:string` should resolve to `attributes_string['attribute_string']`.
 			name: "Attribute key whose name collides with contextual map column resolves as a map lookup",

pkg/telemetryschema/tracestelemetryschema/test_data.go

@@ -113,6 +113,20 @@ func BuildCompleteFieldKeyMap(releaseTime time.Time) map[string][]*telemetrytype
 				FieldDataType: telemetrytypes.FieldDataTypeBool,
 			},
 		},
+		"scope.name": {
+			{
+				Name:          "scope.name",
+				FieldContext:  telemetrytypes.FieldContextScope,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+		},
+		"scope.version": {
+			{
+				Name:          "scope.version",
+				FieldContext:  telemetrytypes.FieldContextScope,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+		},
 	}
 	for _, keys := range keysMap {
 		for _, key := range keys {

pkg/types/dashboardtypes/dashboard.go

@@ -201,6 +201,18 @@ func (storableDashboardData *StorableDashboardData) GetWidgetIds() []string {
 	return widgetIds
 }
 
+// ErrIfNotDeletable gates deletion on the columns alone, never on Data, so a
+// dashboard whose data is corrupt or stuck on the v1 schema stays deletable.
+func (storable StorableDashboard) ErrIfNotDeletable() error {
+	if storable.Locked {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete a locked dashboard, please unlock the dashboard to delete")
+	}
+	if !storable.Source.isUserDeletable() {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be deleted", storable.Source)
+	}
+	return nil
+}
+
 func (dashboard *Dashboard) ErrIfNotMutable() error {
 	if dashboard.Source == SourceIntegration {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be modified")

pkg/types/dashboardtypes/dashboard_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/stretchr/testify/assert"
 )
@@ -81,3 +82,64 @@ func TestCanUpdate_MultipleDeletions_ByDiff(t *testing.T) {
 		})
 	}
 }
+
+func TestStorableDashboardErrIfNotDeletable(t *testing.T) {
+	testCases := []struct {
+		subtestName     string
+		locked          bool
+		source          Source
+		data            StorableDashboardData
+		expectDeletable bool
+	}{
+		{
+			subtestName:     "user dashboard on the v2 schema",
+			source:          SourceUser,
+			data:            StorableDashboardData{"metadata": map[string]any{"schemaVersion": SchemaVersion}},
+			expectDeletable: true,
+		},
+		{
+			subtestName:     "user dashboard still on the v1 schema",
+			source:          SourceUser,
+			data:            StorableDashboardData{"widgets": makeTestWidgets("a")},
+			expectDeletable: true,
+		},
+		{
+			subtestName:     "user dashboard with unreadable data",
+			source:          SourceUser,
+			data:            StorableDashboardData{"metadata": "not-an-object"},
+			expectDeletable: true,
+		},
+		{
+			subtestName:     "locked user dashboard",
+			locked:          true,
+			source:          SourceUser,
+			data:            StorableDashboardData{"widgets": makeTestWidgets("a")},
+			expectDeletable: false,
+		},
+		{
+			subtestName:     "system dashboard",
+			source:          SourceSystem,
+			data:            StorableDashboardData{"widgets": makeTestWidgets("a")},
+			expectDeletable: false,
+		},
+		{
+			subtestName:     "integration dashboard",
+			source:          SourceIntegration,
+			data:            StorableDashboardData{"widgets": makeTestWidgets("a")},
+			expectDeletable: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.subtestName, func(t *testing.T) {
+			storable := StorableDashboard{
+				Identifiable: types.Identifiable{ID: valuer.GenerateUUID()},
+				OrgID:        valuer.GenerateUUID(),
+				Locked:       tc.locked,
+				Source:       tc.source,
+				Data:         tc.data,
+			}
+			assert.Equal(t, tc.expectDeletable, storable.ErrIfNotDeletable() == nil)
+		})
+	}
+}

pkg/types/dashboardtypes/perses_dashboard.go

@@ -129,16 +129,6 @@ func (d *DashboardV2) LockUnlock(lock bool, isAdmin bool, updatedBy string) erro
 	return nil
 }
 
-func (d *DashboardV2) ErrIfNotDeletable() error {
-	if d.Locked {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete a locked dashboard, please unlock the dashboard to delete")
-	}
-	if !d.Source.isUserDeletable() {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be deleted", d.Source)
-	}
-	return nil
-}
-
 func (d *DashboardV2) ErrIfNotClonable() error {
 	if !d.Source.isClonable() {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be cloned", d.Source)

pkg/types/savedviewtypes/savedview.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"k8s.io/apimachinery/pkg/util/validation"
@@ -28,27 +30,76 @@ var (
 )
 
 type SavedView struct {
+	types.Identifiable
+	types.TimeAuditable
+	types.UserAuditable
+	OrgID         string        `json:"-"`
+	Name          string        `json:"name"`
+	Source        Source        `json:"source"`
+	SchemaVersion SchemaVersion `json:"schemaVersion" required:"true"`
+	Spec          SavedViewSpec `json:"spec" required:"true"`
+}
+
+type StorableSavedView struct {
 	bun.BaseModel `bun:"table:saved_view"`
 
 	types.Identifiable
 	types.TimeAuditable
 	types.UserAuditable
-	OrgID  string        `json:"-" bun:"org_id,notnull"`
-	Name   string        `json:"name" bun:"name,type:text,notnull"`
-	Source Source        `json:"source" bun:"source,type:text,notnull"`
-	Data   SavedViewData `json:"data" bun:"data,type:text,notnull"`
+	OrgID  string        `bun:"org_id,notnull"`
+	Name   string        `bun:"name,type:text,notnull"`
+	Source Source        `bun:"source,type:text,notnull"`
+	Data   SavedViewData `bun:"data,type:text,notnull"`
+}
+
+func (s *StorableSavedView) ToSavedView() *SavedView {
+	spec := s.Data.Spec
+	if spec.Queries == nil {
+		spec.Queries = []qbtypes.QueryEnvelope{}
+	}
+	if spec.SelectedFields == nil {
+		spec.SelectedFields = []telemetrytypes.TelemetryFieldKey{}
+	}
+
+	return &SavedView{
+		Identifiable:  s.Identifiable,
+		TimeAuditable: s.TimeAuditable,
+		UserAuditable: s.UserAuditable,
+		OrgID:         s.OrgID,
+		Name:          s.Name,
+		Source:        s.Source,
+		SchemaVersion: SchemaVersion{valuer.NewString(s.Data.SchemaVersion)},
+		Spec:          spec,
+	}
+}
+
+func NewStorableSavedView(view *SavedView) *StorableSavedView {
+	return &StorableSavedView{
+		Identifiable:  view.Identifiable,
+		TimeAuditable: view.TimeAuditable,
+		UserAuditable: view.UserAuditable,
+		OrgID:         view.OrgID,
+		Name:          view.Name,
+		Source:        view.Source,
+		Data: SavedViewData{
+			SchemaVersion: view.SchemaVersion.StringValue(),
+			Spec:          view.Spec,
+		},
+	}
 }
 
 type PostableSavedView struct {
-	Name         string        `json:"name"`
-	GenerateName bool          `json:"generateName"`
-	Source       Source        `json:"source" required:"true"`
-	Data         SavedViewData `json:"data" required:"true"`
+	Name          string        `json:"name"`
+	GenerateName  bool          `json:"generateName"`
+	Source        Source        `json:"source" required:"true"`
+	SchemaVersion SchemaVersion `json:"schemaVersion" required:"true"`
+	Spec          SavedViewSpec `json:"spec" required:"true"`
 }
 
 type UpdatableSavedView struct {
-	Source Source        `json:"source" required:"true"`
-	Data   SavedViewData `json:"data" required:"true"`
+	Source        Source        `json:"source" required:"true"`
+	SchemaVersion SchemaVersion `json:"schemaVersion" required:"true"`
+	Spec          SavedViewSpec `json:"spec" required:"true"`
 }
 
 type ListSavedViewsParams struct {
@@ -83,7 +134,7 @@ func (postable PostableSavedView) ToSavedView(orgID string, createdBy string) *S
 
 	name := postable.Name
 	if postable.GenerateName {
-		name = generateSavedViewName(postable.Data.Spec.DisplayName)
+		name = generateSavedViewName(postable.Spec.DisplayName)
 	}
 
 	return &SavedView{
@@ -93,7 +144,8 @@ func (postable PostableSavedView) ToSavedView(orgID string, createdBy string) *S
 		OrgID:         orgID,
 		Name:          name,
 		Source:        postable.Source,
-		Data:          postable.Data,
+		SchemaVersion: postable.SchemaVersion,
+		Spec:          postable.Spec,
 	}
 }
 
@@ -106,7 +158,8 @@ func (updatable UpdatableSavedView) ToSavedView(id valuer.UUID, orgID string, up
 		UserAuditable: types.UserAuditable{UpdatedBy: updatedBy},
 		OrgID:         orgID,
 		Source:        updatable.Source,
-		Data:          updatable.Data,
+		SchemaVersion: updatable.SchemaVersion,
+		Spec:          updatable.Spec,
 	}
 }
 
@@ -117,8 +170,11 @@ func (p *PostableSavedView) Validate() error {
 	if err := p.Source.Validate(); err != nil {
 		return err
 	}
+	if err := p.SchemaVersion.Validate(); err != nil {
+		return err
+	}
 
-	return p.Data.Validate()
+	return p.Spec.Validate()
 }
 
 func (p *PostableSavedView) validateName() error {
@@ -135,8 +191,11 @@ func (u *UpdatableSavedView) Validate() error {
 	if err := u.Source.Validate(); err != nil {
 		return err
 	}
+	if err := u.SchemaVersion.Validate(); err != nil {
+		return err
+	}
 
-	return u.Data.Validate()
+	return u.Spec.Validate()
 }
 
 func (p *ListSavedViewsParams) Validate() error {
@@ -147,7 +206,17 @@ func (p *ListSavedViewsParams) Validate() error {
 	return p.Source.Validate()
 }
 
-func NewStatsFromSavedViews(savedViews []*SavedView) map[string]any {
+// NewSavedViewsFromStorableSavedViews converts scanned rows to their domain shape.
+func NewSavedViewsFromStorableSavedViews(storableSavedViews []*StorableSavedView) []*SavedView {
+	savedViews := make([]*SavedView, len(storableSavedViews))
+	for idx, storableSavedView := range storableSavedViews {
+		savedViews[idx] = storableSavedView.ToSavedView()
+	}
+
+	return savedViews
+}
+
+func NewStatsFromStorableSavedViews(savedViews []*StorableSavedView) map[string]any {
 	stats := make(map[string]any)
 	for _, savedView := range savedViews {
 		key := "savedview.source." + strings.ToLower(savedView.Source.StringValue()) + ".count"

pkg/types/savedviewtypes/savedview_test.go

@@ -4,29 +4,28 @@ import (
 	"strings"
 	"testing"
 
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/util/validation"
 )
 
 func validPostableSavedView() PostableSavedView {
 	return PostableSavedView{
-		Name:   "my-view",
-		Source: SourceLogs,
-		Data: SavedViewData{
-			SchemaVersion: SavedViewSchemaVersion,
-			Spec:          SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()},
-		},
+		Name:          "my-view",
+		Source:        SourceLogs,
+		SchemaVersion: SavedViewSchemaVersion,
+		Spec:          SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
 	}
 }
 
 func validUpdatableSavedView() UpdatableSavedView {
 	return UpdatableSavedView{
-		Source: SourceLogs,
-		Data: SavedViewData{
-			SchemaVersion: SavedViewSchemaVersion,
-			Spec:          SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()},
-		},
+		Source:        SourceLogs,
+		SchemaVersion: SavedViewSchemaVersion,
+		Spec:          SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
 	}
 }
 
@@ -69,7 +68,7 @@ func TestPostableSavedViewValidate(t *testing.T) {
 
 	t.Run("invalid saved view data is rejected", func(t *testing.T) {
 		view := validPostableSavedView()
-		view.Data.SchemaVersion = "v1"
+		view.SchemaVersion = SchemaVersion{valuer.NewString("v1")}
 		assert.Error(t, view.Validate())
 	})
 
@@ -100,9 +99,15 @@ func TestPostableSavedViewValidate(t *testing.T) {
 
 	t.Run("empty displayName is rejected", func(t *testing.T) {
 		view := validPostableSavedView()
-		view.Data.Spec.DisplayName = ""
+		view.Spec.DisplayName = ""
 		assert.ErrorContains(t, view.Validate(), "displayName is required")
 	})
+
+	t.Run("missing requestType is rejected", func(t *testing.T) {
+		view := validPostableSavedView()
+		view.Spec.RequestType = qbtypes.RequestType{}
+		assert.ErrorContains(t, view.Validate(), "requestType is required")
+	})
 }
 
 func TestUpdatableSavedViewValidate(t *testing.T) {
@@ -119,9 +124,15 @@ func TestUpdatableSavedViewValidate(t *testing.T) {
 
 	t.Run("empty displayName is rejected", func(t *testing.T) {
 		view := validUpdatableSavedView()
-		view.Data.Spec.DisplayName = ""
+		view.Spec.DisplayName = ""
 		assert.ErrorContains(t, view.Validate(), "displayName is required")
 	})
+
+	t.Run("missing requestType is rejected", func(t *testing.T) {
+		view := validUpdatableSavedView()
+		view.Spec.RequestType = qbtypes.RequestType{}
+		assert.ErrorContains(t, view.Validate(), "requestType is required")
+	})
 }
 
 func TestListSavedViewsParamsValidate(t *testing.T) {
@@ -153,7 +164,8 @@ func TestNewSavedView(t *testing.T) {
 	assert.Equal(t, "creator@signoz.io", savedView.UpdatedBy)
 	assert.Equal(t, view.Name, savedView.Name)
 	assert.Equal(t, view.Source, savedView.Source)
-	assert.Equal(t, view.Data, savedView.Data)
+	assert.Equal(t, view.SchemaVersion, savedView.SchemaVersion)
+	assert.Equal(t, view.Spec, savedView.Spec)
 	assert.False(t, savedView.CreatedAt.IsZero())
 	assert.Equal(t, savedView.CreatedAt, savedView.UpdatedAt)
 }
@@ -163,14 +175,14 @@ func TestNewSavedView_GeneratesNameWhenEmpty(t *testing.T) {
 	view := validPostableSavedView()
 	view.Name = ""
 	view.GenerateName = true
-	view.Data.Spec.DisplayName = "My View!"
+	view.Spec.DisplayName = "My View!"
 
 	savedView := view.ToSavedView(orgID, "creator@signoz.io")
 
 	assert.NotEmpty(t, savedView.Name)
 	assert.Empty(t, validation.IsDNS1123Label(savedView.Name), "generated name must be a valid DNS-1123 label")
 	assert.True(t, strings.HasPrefix(savedView.Name, "my-view-"))
-	assert.Equal(t, "My View!", savedView.Data.Spec.DisplayName)
+	assert.Equal(t, "My View!", savedView.Spec.DisplayName)
 }
 
 func TestGenerateSavedViewName(t *testing.T) {
@@ -212,17 +224,95 @@ func TestGenerateSavedViewName(t *testing.T) {
 	})
 }
 
-func TestNewStatsFromSavedViews(t *testing.T) {
-	views := []*SavedView{
+func TestStorableSavedView_ToSavedView(t *testing.T) {
+	t.Run("round trip preserves populated fields", func(t *testing.T) {
+		view := &SavedView{
+			Name:          "my-view",
+			Source:        SourceLogs,
+			SchemaVersion: SavedViewSchemaVersion,
+			Spec: SavedViewSpec{
+				DisplayName:    "My View",
+				PanelType:      PanelTypeGraph,
+				RequestType:    qbtypes.RequestTypeTimeSeries,
+				Queries:        validQueries(),
+				SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
+			},
+		}
+		view.OrgID = valuer.GenerateUUID().StringValue()
+
+		roundTripped := NewStorableSavedView(view).ToSavedView()
+
+		assert.Equal(t, view.OrgID, roundTripped.OrgID)
+		assert.Equal(t, view.Name, roundTripped.Name)
+		assert.Equal(t, view.Source, roundTripped.Source)
+		assert.Equal(t, view.SchemaVersion, roundTripped.SchemaVersion)
+		assert.Equal(t, view.Spec, roundTripped.Spec)
+	})
+
+	t.Run("nil selectedFields normalizes to an empty slice, not nil", func(t *testing.T) {
+		storable := &StorableSavedView{
+			Data: SavedViewData{
+				SchemaVersion: SavedViewSchemaVersion.StringValue(),
+				Spec: SavedViewSpec{
+					DisplayName:    "My View",
+					PanelType:      PanelTypeGraph,
+					Queries:        validQueries(),
+					SelectedFields: nil,
+				},
+			},
+		}
+
+		view := storable.ToSavedView()
+
+		assert.NotNil(t, view.Spec.SelectedFields)
+		assert.Empty(t, view.Spec.SelectedFields)
+	})
+
+	t.Run("nil queries normalizes to an empty slice, not nil", func(t *testing.T) {
+		storable := &StorableSavedView{
+			Data: SavedViewData{
+				SchemaVersion: SavedViewSchemaVersion.StringValue(),
+				Spec: SavedViewSpec{
+					DisplayName: "My View",
+					PanelType:   PanelTypeGraph,
+					Queries:     nil,
+				},
+			},
+		}
+
+		view := storable.ToSavedView()
+
+		assert.NotNil(t, view.Spec.Queries)
+		assert.Empty(t, view.Spec.Queries)
+	})
+}
+
+func TestNewStatsFromStorableSavedViews(t *testing.T) {
+	storables := []*StorableSavedView{
 		{Source: SourceLogs},
 		{Source: SourceLogs},
 		{Source: SourceTraces},
 	}
 
-	stats := NewStatsFromSavedViews(views)
+	stats := NewStatsFromStorableSavedViews(storables)
 
 	assert.Equal(t, int64(3), stats["savedview.count"])
 	assert.Equal(t, int64(2), stats["savedview.source.logs.count"])
 	assert.Equal(t, int64(1), stats["savedview.source.traces.count"])
 	assert.NotContains(t, stats, "savedview.source.metrics.count")
 }
+
+func TestNewSavedViewsFromStorableSavedViews(t *testing.T) {
+	storables := []*StorableSavedView{
+		{Name: "a", Source: SourceLogs, Data: SavedViewData{SchemaVersion: SavedViewSchemaVersion.StringValue(), Spec: SavedViewSpec{DisplayName: "a", PanelType: PanelTypeGraph, Queries: validQueries()}}},
+		{Name: "b", Source: SourceTraces, Data: SavedViewData{SchemaVersion: SavedViewSchemaVersion.StringValue(), Spec: SavedViewSpec{DisplayName: "b", PanelType: PanelTypeTable, Queries: validQueries()}}},
+	}
+
+	views := NewSavedViewsFromStorableSavedViews(storables)
+
+	require.Len(t, views, 2)
+	assert.Equal(t, "a", views[0].Name)
+	assert.Equal(t, SourceLogs, views[0].Source)
+	assert.Equal(t, "b", views[1].Name)
+	assert.Equal(t, SourceTraces, views[1].Source)
+}

pkg/types/savedviewtypes/savedviewtypestest/store.go

@@ -28,7 +28,7 @@ func (t *StoreTest) Store() savedviewtypes.Store { return t.store }
 func (t *StoreTest) Mock() sqlmock.Sqlmock { return t.mock }
 
 func savedViewRow(view *savedviewtypes.SavedView) []driver.Value {
-	data, _ := json.Marshal(view.Data)
+	data, _ := json.Marshal(savedviewtypes.NewStorableSavedView(view).Data)
 	return []driver.Value{
 		view.ID.StringValue(),
 		view.CreatedAt,
@@ -47,6 +47,12 @@ func (t *StoreTest) ExpectCreate() {
 	t.mock.ExpectExec(`INSERT INTO "saved_view"`).WillReturnResult(sqlmock.NewResult(1, 1))
 }
 
+// ExpectCreateError sets up the SQL expectation for a Create call whose insert
+// fails, e.g. on a UNIQUE(org_id, name) violation.
+func (t *StoreTest) ExpectCreateError(err error) {
+	t.mock.ExpectExec(`INSERT INTO "saved_view"`).WillReturnError(err)
+}
+
 // ExpectGet sets up the SQL expectation for a Get call. Pass view = nil to
 // simulate a not-found row.
 func (t *StoreTest) ExpectGet(orgID string, id valuer.UUID, view *savedviewtypes.SavedView) {

pkg/types/savedviewtypes/spec.go

@@ -8,7 +8,7 @@ import (
 )
 
 // SavedViewSchemaVersion is the only schemaVersion currently.
-const SavedViewSchemaVersion = "v2"
+var SavedViewSchemaVersion = SchemaVersion{valuer.NewString("v2")}
 
 var (
 	PanelTypeValue = PanelType{valuer.NewString("value")}
@@ -30,9 +30,10 @@ type Display struct {
 type SavedViewSpec struct {
 	DisplayName    string                             `json:"displayName" required:"true"`
 	PanelType      PanelType                          `json:"panelType" required:"true"`
-	Queries        []qbtypes.QueryEnvelope            `json:"queries" required:"true" nullable:"false"`
-	SelectedFields []telemetrytypes.TelemetryFieldKey `json:"selectedFields" required:"true" nullable:"false"`
-	Display        Display                            `json:"display" required:"true"`
+	RequestType    qbtypes.RequestType                `json:"requestType" required:"true"`
+	Queries        []qbtypes.QueryEnvelope            `json:"queries" required:"true" nullable:"false" minItems:"1"`
+	SelectedFields []telemetrytypes.TelemetryFieldKey `json:"selectedFields" nullable:"false"`
+	Display        Display                            `json:"display"`
 }
 
 // SavedViewData is what's persisted as saved view data.
@@ -41,6 +42,11 @@ type SavedViewData struct {
 	Spec          SavedViewSpec `json:"spec" required:"true"`
 }
 
+// SchemaVersion has v2 as the only value currently.
+type SchemaVersion struct {
+	valuer.String
+}
+
 // PanelType is the explore-page panel a saved view renders as.
 type PanelType struct {
 	valuer.String
@@ -65,6 +71,17 @@ func (p PanelType) Validate() error {
 	}
 }
 
+func (SchemaVersion) Enum() []any {
+	return []any{SavedViewSchemaVersion}
+}
+
+func (s SchemaVersion) Validate() error {
+	if s != SavedViewSchemaVersion {
+		return errors.NewInvalidInputf(ErrCodeSavedViewInvalidInput, "schemaVersion must be %q, got %q", SavedViewSchemaVersion.StringValue(), s.StringValue())
+	}
+	return nil
+}
+
 func (s *SavedViewSpec) Validate() error {
 	if s.DisplayName == "" {
 		return errors.NewInvalidInputf(ErrCodeSavedViewInvalidInput, "displayName is required")
@@ -72,14 +89,23 @@ func (s *SavedViewSpec) Validate() error {
 	if err := s.PanelType.Validate(); err != nil {
 		return err
 	}
-
-	return (&qbtypes.CompositeQuery{Queries: s.Queries}).Validate()
-}
-
-func (d *SavedViewData) Validate() error {
-	if d.SchemaVersion != SavedViewSchemaVersion {
-		return errors.NewInvalidInputf(ErrCodeSavedViewInvalidInput, "schemaVersion must be %q, got %q", SavedViewSchemaVersion, d.SchemaVersion)
+	if s.RequestType.IsZero() {
+		return errors.NewInvalidInputf(ErrCodeSavedViewInvalidInput, "requestType is required")
 	}
 
-	return d.Spec.Validate()
+	return (&qbtypes.CompositeQuery{Queries: s.Queries}).Validate(qbtypes.GetValidationOptions(s.RequestType)...)
+}
+
+// LegacyRequestTypeForPanelType exists only for the v1 legacy API.
+func LegacyRequestTypeForPanelType(p PanelType) qbtypes.RequestType {
+	switch p {
+	case PanelTypeList:
+		return qbtypes.RequestTypeRaw
+	case PanelTypeTrace:
+		return qbtypes.RequestTypeTrace
+	case PanelTypeGraph:
+		return qbtypes.RequestTypeTimeSeries
+	default:
+		return qbtypes.RequestTypeScalar
+	}
 }

pkg/types/savedviewtypes/spec_test.go

@@ -1,12 +1,15 @@
 package savedviewtypes
 
 import (
+	"encoding/json"
+	"testing"
+
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func validQueries() []qbtypes.QueryEnvelope {
@@ -56,35 +59,124 @@ func TestSavedViewSpecValidate(t *testing.T) {
 	}{
 		{
 			name:        "valid spec",
-			spec:        SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()},
+			spec:        SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
 			expectError: false,
 		},
 		{
 			name:        "empty display name is rejected",
-			spec:        SavedViewSpec{PanelType: PanelTypeGraph, Queries: validQueries()},
+			spec:        SavedViewSpec{RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
 			expectError: true,
 		},
 		{
-			name:        "invalid panel type is rejected before queries are checked",
-			spec:        SavedViewSpec{DisplayName: "My View", PanelType: PanelType{valuer.NewString("bogus")}, Queries: validQueries()},
+			name:        "invalid panel type is rejected",
+			spec:        SavedViewSpec{DisplayName: "My View", PanelType: PanelType{valuer.NewString("bogus")}, RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
+			expectError: true,
+		},
+		{
+			name:        "unset panel type is rejected",
+			spec:        SavedViewSpec{DisplayName: "My View", RequestType: qbtypes.RequestTypeTimeSeries, Queries: validQueries()},
+			expectError: true,
+		},
+		{
+			name:        "missing requestType is rejected",
+			spec:        SavedViewSpec{DisplayName: "My View", Queries: validQueries()},
 			expectError: true,
 		},
 		{
 			name:        "no queries is rejected",
-			spec:        SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph},
+			spec:        SavedViewSpec{DisplayName: "My View", RequestType: qbtypes.RequestTypeTimeSeries},
 			expectError: true,
 		},
 		{
-			name: "selected fields and display are not required",
+			name: "selectedFields and display populated is still valid",
 			spec: SavedViewSpec{
 				DisplayName:    "My View",
 				PanelType:      PanelTypeTable,
+				RequestType:    qbtypes.RequestTypeScalar,
 				Queries:        validQueries(),
 				SelectedFields: []telemetrytypes.TelemetryFieldKey{{Name: "service.name"}},
 				Display:        Display{MaxLines: 3, FontSize: "small", Format: "table", Color: "blue"},
 			},
 			expectError: false,
 		},
+		{
+			name: "nil selectedFields is valid -- selectedFields itself is not required",
+			spec: SavedViewSpec{
+				DisplayName:    "My View",
+				PanelType:      PanelTypeValue,
+				RequestType:    qbtypes.RequestTypeScalar,
+				Queries:        validQueries(),
+				SelectedFields: nil,
+			},
+			expectError: false,
+		},
+		{
+			name: "empty (non-nil) selectedFields is valid",
+			spec: SavedViewSpec{
+				DisplayName:    "My View",
+				PanelType:      PanelTypeValue,
+				RequestType:    qbtypes.RequestTypeScalar,
+				Queries:        validQueries(),
+				SelectedFields: []telemetrytypes.TelemetryFieldKey{},
+			},
+			expectError: false,
+		},
+		{
+			name: "zero-value display is valid",
+			spec: SavedViewSpec{
+				DisplayName: "My View",
+				PanelType:   PanelTypeValue,
+				RequestType: qbtypes.RequestTypeScalar,
+				Queries:     validQueries(),
+				Display:     Display{},
+			},
+			expectError: false,
+		},
+		{
+			name: "list panel query with no aggregation is valid",
+			spec: SavedViewSpec{
+				DisplayName: "My View",
+				PanelType:   PanelTypeList,
+				RequestType: qbtypes.RequestTypeRaw,
+				Queries: []qbtypes.QueryEnvelope{{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+						Signal: telemetrytypes.SignalTraces,
+					},
+				}},
+			},
+			expectError: false,
+		},
+		{
+			name: "trace panel query with no aggregation is valid",
+			spec: SavedViewSpec{
+				DisplayName: "My View",
+				PanelType:   PanelTypeTrace,
+				RequestType: qbtypes.RequestTypeTrace,
+				Queries: []qbtypes.QueryEnvelope{{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+						Signal: telemetrytypes.SignalTraces,
+					},
+				}},
+			},
+			expectError: false,
+		},
+		{
+			name: "graph panel query with no aggregation is still rejected",
+			spec: SavedViewSpec{
+				DisplayName: "My View",
+				PanelType:   PanelTypeGraph,
+				RequestType: qbtypes.RequestTypeTimeSeries,
+				Queries: []qbtypes.QueryEnvelope{{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+						Signal: telemetrytypes.SignalTraces,
+					},
+				}},
+			},
+			expectError: true,
+		},
 	}
 
 	for _, c := range cases {
@@ -99,37 +191,65 @@ func TestSavedViewSpecValidate(t *testing.T) {
 	}
 }
 
-func TestSavedViewDataValidate(t *testing.T) {
+func TestSavedViewSpecValidate_RequestTypeIsIndependentOfPanelType(t *testing.T) {
+	// RequestType, not PanelType, governs which aggregation rules apply -- nothing
+	// derives one from the other inside Validate.
+	spec := SavedViewSpec{
+		DisplayName: "My View",
+		PanelType:   PanelTypeGraph,
+		RequestType: qbtypes.RequestTypeRaw,
+		Queries: []qbtypes.QueryEnvelope{{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+				Signal: telemetrytypes.SignalTraces,
+			},
+		}},
+	}
+
+	assert.NoError(t, spec.Validate())
+
+	spec.RequestType = qbtypes.RequestTypeTimeSeries
+	assert.Error(t, spec.Validate())
+}
+
+func TestSavedViewSpecJSONUnmarshal_OptionalFields(t *testing.T) {
+	base := `"displayName":"My View","panelType":"value","requestType":"scalar","queries":[{"type":"builder_query","spec":{"signal":"logs","aggregations":[{"expression":"count()"}]}}]`
+
 	cases := []struct {
-		name        string
-		data        SavedViewData
-		expectError bool
+		name string
+		json string
 	}{
-		{
-			name:        "valid data",
-			data:        SavedViewData{SchemaVersion: SavedViewSchemaVersion, Spec: SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()}},
-			expectError: false,
-		},
-		{
-			name:        "wrong schema version is rejected",
-			data:        SavedViewData{SchemaVersion: "v1", Spec: SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()}},
-			expectError: true,
-		},
-		{
-			name:        "empty schema version is rejected",
-			data:        SavedViewData{Spec: SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph, Queries: validQueries()}},
-			expectError: true,
-		},
-		{
-			name:        "invalid spec is rejected",
-			data:        SavedViewData{SchemaVersion: SavedViewSchemaVersion, Spec: SavedViewSpec{DisplayName: "My View", PanelType: PanelTypeGraph}},
-			expectError: true,
-		},
+		{name: "selectedFields and display omitted entirely", json: `{` + base + `}`},
+		{name: "selectedFields and display explicitly null", json: `{` + base + `,"selectedFields":null,"display":null}`},
+		{name: "selectedFields empty array, display empty object", json: `{` + base + `,"selectedFields":[],"display":{}}`},
 	}
 
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			err := c.data.Validate()
+			var spec SavedViewSpec
+			err := json.Unmarshal([]byte(c.json), &spec)
+			require.NoError(t, err)
+			assert.NoError(t, spec.Validate())
+			assert.Empty(t, spec.SelectedFields)
+			assert.Equal(t, Display{}, spec.Display)
+		})
+	}
+}
+
+func TestSchemaVersionValidate(t *testing.T) {
+	cases := []struct {
+		name          string
+		schemaVersion SchemaVersion
+		expectError   bool
+	}{
+		{name: "valid schema version", schemaVersion: SavedViewSchemaVersion, expectError: false},
+		{name: "wrong schema version is rejected", schemaVersion: SchemaVersion{valuer.NewString("v1")}, expectError: true},
+		{name: "empty schema version is rejected", schemaVersion: SchemaVersion{}, expectError: true},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			err := c.schemaVersion.Validate()
 			if c.expectError {
 				assert.Error(t, err)
 			} else {

pkg/types/savedviewtypes/store.go

@@ -7,9 +7,9 @@ import (
 )
 
 type Store interface {
-	Create(ctx context.Context, view *SavedView) error
-	Get(ctx context.Context, orgID string, id valuer.UUID) (*SavedView, error)
-	Update(ctx context.Context, view *SavedView) error
+	Create(ctx context.Context, view *StorableSavedView) error
+	Get(ctx context.Context, orgID string, id valuer.UUID) (*StorableSavedView, error)
+	Update(ctx context.Context, view *StorableSavedView) error
 	Delete(ctx context.Context, orgID string, id valuer.UUID) error
-	List(ctx context.Context, orgID string, source Source, name string) ([]*SavedView, error)
+	List(ctx context.Context, orgID string, source Source, name string) ([]*StorableSavedView, error)
 }

tests/fixtures/querier.py

@@ -999,6 +999,8 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "cloud.provider": "integration",
                 "cloud.account.id": "000",
                 "trace_id": "corrupt_data",
+                "scope_name": "corrupt_data",
+                "scope.scope.name": "corrupt_data",
             },
             attributes={
                 "net.transport": "IP.TCP",
@@ -1007,7 +1009,10 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "http.request.method": "POST",
                 "http.response.status_code": "200",
                 "timestamp": "corrupt_data",
+                "version": "1.0.0",
+                "scope.scope.version": "1.0.0",
             },
+            scope={"name": "io.signoz.http.server", "version": "2.0.0"},
         ),
         Traces(
             timestamp=now - timedelta(seconds=3.5),
@@ -1027,12 +1032,24 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "cloud.provider": "integration",
                 "cloud.account.id": "000",
                 "timestamp": "corrupt_data",
+                "scope.attributes.name": "corrupt_data",
             },
             attributes={
                 "db.name": "integration",
                 "db.operation": "SELECT",
                 "db.statement": "SELECT * FROM integration",
                 "trace_d": "corrupt_data",
+                "scope.attributes.version": "corrupt_data",
+            },
+            scope={
+                "name": "io.opentelemetry.contrib.http",
+                "version": "1.0.0",
+                "attributes": {
+                    "telemetry.sdk.language": "cpp",
+                    "name": "not-the-real-name",
+                    "version": "not-the-real-version",
+                    "attributes": "literally-a-key-named-attributes",
+                },
             },
         ),
         Traces(
@@ -1053,12 +1070,15 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "cloud.provider": "integration",
                 "cloud.account.id": "000",
                 "duration_nano": "corrupt_data",
+                "scope.scope.attributes.version": "corrupt_data",
             },
             attributes={
                 "http.request.method": "PATCH",
                 "http.status_code": "404",
                 "id": "1",
+                "scope.scope.version": "corrupt_data",
             },
+            scope={"name": "io.signoz.http.client", "version": "2.0.0"},
         ),
         Traces(
             timestamp=now - timedelta(seconds=1),
@@ -1077,6 +1097,7 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "host.name": "linux-001",
                 "cloud.provider": "integration",
                 "cloud.account.id": "001",
+                "scope.scope.version": "corrupt_data",
             },
             attributes={
                 "message.type": "SENT",
@@ -1084,7 +1105,10 @@ def generate_traces_with_corrupt_metadata() -> list[Traces]:
                 "messaging.message.id": "001",
                 "duration_nano": "corrupt_data",
                 "id": 1,
+                "scope": "corrupt_data",
+                "scope.attributes.name": "corrupt_data",
             },
+            scope={"name": "io.signoz.messaging", "version": "3.0.0"},
         ),
     ]
 

tests/fixtures/savedview.py

@@ -13,15 +13,14 @@ def _body(name: str, source: str = "logs") -> dict:
     return {
         "name": name,
         "source": source,
-        "data": {
-            "schemaVersion": "v2",
-            "spec": {
-                "displayName": name,
-                "panelType": "table",
-                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
-                "selectedFields": [],
-                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-            },
+        "schemaVersion": "v2",
+        "spec": {
+            "displayName": name,
+            "panelType": "table",
+            "requestType": "scalar",
+            "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+            "selectedFields": [],
+            "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
         },
     }
 

tests/fixtures/traces.py

@@ -302,6 +302,7 @@ class Traces(ABC):
     db_operation: str
     has_error: bool
     is_remote: str
+    scope_json: dict[str, Any]
 
     resource: list[TracesResource]
     tag_attributes: list[TracesTagAttributes]
@@ -327,6 +328,7 @@ class Traces(ABC):
         links: list[TracesLink] = [],
         trace_state: str = "",
         flags: np.uint32 = 0,
+        scope: dict[str, Any] = {},
         resource_write_mode: Literal["legacy_only", "dual_write"] = "dual_write",
     ) -> None:
         if timestamp is None:
@@ -408,6 +410,33 @@ class Traces(ABC):
         # Calculate resource fingerprint
         self.resource_fingerprint = LogsOrTracesFingerprint(self.resources_string).calculate()
 
+        # Process scope mirroring the InstrumentationScope on the OTLP span.
+        scope_name = scope.get("name", "")
+        scope_version = scope.get("version", "")
+        scope_string = {k: str(v) for k, v in scope.get("attributes", {}).items()}
+        self.scope_json = {
+            "name": scope_name,
+            "version": scope_version,
+            "attributes": scope_string,
+        }
+
+        scope_keys = {"scope.name": scope_name, "scope.version": scope_version}
+        scope_keys.update(scope_string)
+        for k, v in scope_keys.items():
+            if v == "":
+                continue
+            self.tag_attributes.append(
+                TracesTagAttributes(
+                    timestamp=timestamp,
+                    tag_key=k,
+                    tag_type="scope",
+                    tag_data_type="string",
+                    string_value=v,
+                    number_value=None,
+                )
+            )
+            self.attribute_keys.append(TracesResourceOrAttributeKeys(name=k, datatype="string", tag_type="scope"))
+
         # Process attributes by type and populate custom fields
         self.attribute_string = {}
         self.attributes_number = {}
@@ -659,6 +688,7 @@ class Traces(ABC):
                 self.has_error,
                 self.is_remote,
                 self.resource_json,
+                self.scope_json,
             ],
             dtype=object,
         )
@@ -689,6 +719,7 @@ class Traces(ABC):
             attributes=data.get("attributes", {}),
             trace_state=data.get("trace_state", ""),
             flags=data.get("flags", 0),
+            scope=data.get("scope", {}),
         )
 
     @classmethod
@@ -828,6 +859,7 @@ def insert_traces_to_clickhouse(conn, traces: list[Traces]) -> None:
             "has_error",
             "is_remote",
             "resource",
+            "scope",
         ],
         data=[trace.np_arr() for trace in traces],
     )

tests/integration/testdata/promqltestcorpus/nonfinite_exclusions.json

@@ -1,116 +0,0 @@
-{
-  "note": "Cases SigNoz intentionally does not match, on every leg: promql_query.go drops NaN and +/-Inf, so these come back short a timestamp or a whole series. Not defects, not for burn-down, but a case that starts matching must be removed.",
-  "cases": [
-    "aggregators.test:630[base]",
-    "aggregators.test:630[instant-coarse]",
-    "aggregators.test:633[base]",
-    "aggregators.test:633[instant-coarse]",
-    "aggregators.test:636[base]",
-    "aggregators.test:636[instant-coarse]",
-    "aggregators.test:639[base]",
-    "aggregators.test:639[instant-coarse]",
-    "aggregators.test:642[base]",
-    "aggregators.test:642[instant-coarse]",
-    "aggregators.test:645[base]",
-    "aggregators.test:645[instant-coarse]",
-    "aggregators.test:648[base]",
-    "aggregators.test:648[instant-coarse]",
-    "aggregators.test:661[base]",
-    "aggregators.test:661[instant-coarse]",
-    "aggregators.test:698[base]",
-    "aggregators.test:698[instant-coarse]",
-    "aggregators.test:702[base]",
-    "aggregators.test:702[instant-coarse]",
-    "aggregators.test:706[base]",
-    "aggregators.test:706[instant-coarse]",
-    "aggregators.test:710[base]",
-    "aggregators.test:710[instant-coarse]",
-    "aggregators.test:714[base]",
-    "aggregators.test:714[instant-coarse]",
-    "aggregators.test:717[base]",
-    "aggregators.test:717[instant-coarse]",
-    "aggregators.test:720[base]",
-    "aggregators.test:720[instant-coarse]",
-    "aggregators.test:724[base]",
-    "aggregators.test:724[instant-coarse]",
-    "aggregators.test:862[base]",
-    "aggregators.test:862[instant-coarse]",
-    "aggregators.test:865[base]",
-    "aggregators.test:865[instant-coarse]",
-    "aggregators.test:868[base]",
-    "aggregators.test:868[instant-coarse]",
-    "aggregators.test:873[base]",
-    "aggregators.test:873[instant-coarse]",
-    "aggregators.test:885[base]",
-    "aggregators.test:885[instant-coarse]",
-    "aggregators.test:888[base]",
-    "aggregators.test:888[instant-coarse]",
-    "aggregators.test:891[base]",
-    "aggregators.test:891[instant-coarse]",
-    "aggregators.test:896[base]",
-    "aggregators.test:896[instant-coarse]",
-    "aggregators.test:906[base]",
-    "aggregators.test:906[instant-coarse]",
-    "aggregators.test:909[base]",
-    "aggregators.test:909[instant-coarse]",
-    "aggregators.test:919[base]",
-    "aggregators.test:919[instant-coarse]",
-    "aggregators.test:922[base]",
-    "aggregators.test:922[instant-coarse]",
-    "aggregators.test:925[base]",
-    "aggregators.test:925[instant-coarse]",
-    "aggregators.test:930[base]",
-    "aggregators.test:930[instant-coarse]",
-    "aggregators.test:942[base]",
-    "aggregators.test:942[instant-coarse]",
-    "aggregators.test:945[base]",
-    "aggregators.test:945[instant-coarse]",
-    "aggregators.test:948[base]",
-    "aggregators.test:948[instant-coarse]",
-    "aggregators.test:953[base]",
-    "aggregators.test:953[instant-coarse]",
-    "aggregators.test:963[base]",
-    "aggregators.test:963[instant-coarse]",
-    "aggregators.test:966[base]",
-    "aggregators.test:966[instant-coarse]",
-    "operators.test:533[base]",
-    "operators.test:533[instant-coarse]",
-    "operators.test:539[base]",
-    "trig_functions.test:13[base]",
-    "trig_functions.test:13[instant-coarse]",
-    "trig_functions.test:18[base]",
-    "trig_functions.test:18[instant-coarse]",
-    "trig_functions.test:23[base]",
-    "trig_functions.test:23[instant-coarse]",
-    "trig_functions.test:28[base]",
-    "trig_functions.test:28[instant-coarse]",
-    "trig_functions.test:33[base]",
-    "trig_functions.test:33[instant-coarse]",
-    "trig_functions.test:38[base]",
-    "trig_functions.test:38[instant-coarse]",
-    "trig_functions.test:43[base]",
-    "trig_functions.test:43[instant-coarse]",
-    "trig_functions.test:48[base]",
-    "trig_functions.test:48[instant-coarse]",
-    "trig_functions.test:53[base]",
-    "trig_functions.test:53[instant-coarse]",
-    "trig_functions.test:58[base]",
-    "trig_functions.test:58[instant-coarse]",
-    "trig_functions.test:63[base]",
-    "trig_functions.test:63[instant-coarse]",
-    "trig_functions.test:68[base]",
-    "trig_functions.test:68[instant-coarse]",
-    "trig_functions.test:73[base]",
-    "trig_functions.test:73[instant-coarse]",
-    "trig_functions.test:78[base]",
-    "trig_functions.test:78[instant-coarse]",
-    "trig_functions.test:83[base]",
-    "trig_functions.test:83[instant-coarse]",
-    "trig_functions.test:88[base]",
-    "trig_functions.test:88[instant-coarse]",
-    "trig_functions.test:8[base]",
-    "trig_functions.test:8[instant-coarse]",
-    "trig_functions.test:93[base]",
-    "trig_functions.test:93[instant-coarse]"
-  ]
-}

tests/integration/tests/promqlconformance/01_upstream_corpus.py

@@ -26,11 +26,6 @@ LEDGER_FILES = {
     "clickhousev2": os.path.join(TESTDATA_DIR, "promqltestcorpus", "known_divergences_v2.json"),
 }
 
-# Cases SigNoz intentionally does not match, on every leg — kept out of the
-# ledgers because those track defects to be burned down and these are a product
-# decision. Enforced in both directions all the same.
-NONFINITE_EXCLUSIONS_FILE = os.path.join(TESTDATA_DIR, "promqltestcorpus", "nonfinite_exclusions.json")
-
 # Every case replays on both legs, each asserted against the same frozen
 # expectations and its own ledger — deliberately never against each other: both
 # legs can sit within one rounding quantum of the expected value yet differ from
@@ -207,11 +202,6 @@ def test_upstream_promqltest_corpus(
     # divergence is a regression, and a known divergence that starts passing
     # must be removed from the file. Problems across both legs are collected
     # before asserting so one leg's failure never hides the other's.
-    nonfinite_exclusions: set[str] = set()
-    if os.path.exists(NONFINITE_EXCLUSIONS_FILE):
-        with open(NONFINITE_EXCLUSIONS_FILE, encoding="utf-8") as f:
-            nonfinite_exclusions = set(json.load(f)["cases"])
-
     problems: list[str] = []
     for leg, _ in LEGS:
         known: dict[str, str] = {}
@@ -220,15 +210,12 @@ def test_upstream_promqltest_corpus(
                 known = json.load(f)["divergences"]
 
         failed_ids = {f_line.split(": ", 1)[0] for f_line in failures[leg]}
-        unexpected = [f_line for f_line in failures[leg] if f_line.split(": ", 1)[0] not in known and f_line.split(": ", 1)[0] not in nonfinite_exclusions]
+        unexpected = [f_line for f_line in failures[leg] if f_line.split(": ", 1)[0] not in known]
         now_passing = sorted(set(known) - failed_ids)
-        stale_nonfinite_exclusions = sorted(nonfinite_exclusions - failed_ids)
 
         if unexpected:
             problems.append(f"[{leg}] {len(unexpected)} corpus cases diverged beyond the known set:\n" + "\n".join(unexpected[:25]))
         if now_passing:
             problems.append(f"[{leg}] {len(now_passing)} known divergences now pass — remove them from {os.path.basename(LEDGER_FILES[leg])}: {now_passing[:25]}")
-        if stale_nonfinite_exclusions:
-            problems.append(f"[{leg}] {len(stale_nonfinite_exclusions)} non-finite exclusions no longer diverge, so the promql path has stopped dropping them — remove them from {os.path.basename(NONFINITE_EXCLUSIONS_FILE)}: {stale_nonfinite_exclusions[:25]}")
 
     assert not problems, "\n\n".join(problems)

tests/integration/tests/promqlconformance/03_nonfinite_cache.py

@@ -1,65 +0,0 @@
-from collections.abc import Callable
-from datetime import UTC, datetime, timedelta
-from http import HTTPStatus
-from uuid import uuid4
-
-from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.metrics import Metrics
-from fixtures.querier import get_all_series, make_query_request
-
-HOUR_MS = 3_600_000
-SAMPLE_INTERVAL_MS = 60_000
-
-
-def test_promql_ratio_with_zero_denominator_is_dropped_and_cached(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_metrics: Callable[[list[Metrics]], None],
-) -> None:
-    # 12h ending on an hour boundary 15m ago — old enough to be cached.
-    end_ms = (int((datetime.now(tz=UTC) - timedelta(minutes=15)).timestamp() * 1000) // HOUR_MS) * HOUR_MS
-    start_ms = end_ms - 12 * HOUR_MS
-
-    sum_metric = f"job_duration_sum_{uuid4().hex[:8]}"
-    count_metric = f"job_duration_count_{uuid4().hex[:8]}"
-
-    # active_job divides finite; idle_job is 0/0 at every step.
-    series = {"active_job": (100.0, 4.0), "idle_job": (0.0, 0.0)}
-    metrics: list[Metrics] = []
-    for job_name, (sum_value, count_value) in series.items():
-        for ts_ms in range(start_ms, end_ms + 1, SAMPLE_INTERVAL_MS):
-            timestamp = datetime.fromtimestamp(ts_ms / 1000, tz=UTC)
-            metrics.append(Metrics(metric_name=sum_metric, labels={"job_name": job_name}, timestamp=timestamp, value=sum_value))
-            metrics.append(Metrics(metric_name=count_metric, labels={"job_name": job_name}, timestamp=timestamp, value=count_value))
-    insert_metrics(metrics)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    promql = f"sum by (job_name) ({sum_metric}) / sum by (job_name) ({count_metric})"
-
-    def run() -> tuple[dict[str, dict[int, object]], int]:
-        query = {"type": "promql", "spec": {"name": "A", "query": promql}}
-        response = make_query_request(signoz, token, start_ms, end_ms, [query], no_cache=False)
-        assert response.status_code == HTTPStatus.OK, response.text[:300]
-        body = response.json()
-        out: dict[str, dict[int, object]] = {}
-        for entry in get_all_series(body, "A") or []:
-            labels = {l["key"]["name"]: str(l["value"]) for l in entry.get("labels") or []}
-            out[labels["job_name"]] = {v["timestamp"]: v["value"] for v in entry.get("values") or []}
-        return out, int(body["data"]["meta"]["stepIntervals"]["A"])
-
-    # First populates the cache, second must be served from it.
-    first, step_seconds = run()
-    second, _ = run()
-
-    expected_points = (end_ms - start_ms) // (step_seconds * 1000) + 1
-    assert set(first) == {"active_job"}, f"the 0/0 series must not reach the response: {sorted(first)}"
-    assert set(first["active_job"].values()) == {25.0}, sorted(set(first["active_job"].values()))
-    assert len(first["active_job"]) == expected_points, f"expected {expected_points} points, got {len(first['active_job'])}"
-
-    # The cached read excludes end_ms, the one legitimate difference.
-    assert set(second) == set(first), sorted(second)
-    for job_name, points in first.items():
-        expected = {ts: value for ts, value in points.items() if ts < end_ms}
-        assert second[job_name] == expected, f"{job_name}: got {len(second[job_name])} of {len(expected)} points"

tests/integration/tests/queriertraces/01_list.py

@@ -1240,6 +1240,13 @@ def test_traces_list_span_scope(
             lambda x: {"duration_nano": int(x[1].duration_nano), "span_id": x[1].span_id, "timestamp": format_timestamp(x[1].timestamp), "trace_id": x[1].trace_id},
             id="select_attribute_duration_order_intrinsic",
         ),
+        # Case 9: filter on the intrinsic scope.version. Only x[1] should match.
+        pytest.param(
+            BuilderQuery(signal="traces", name="A", select_fields=[TelemetryFieldKey("timestamp")], filter_expression="scope.version = '1.0.0'", limit=1),
+            HTTPStatus.OK,
+            lambda x: {"span_id": x[1].span_id, "timestamp": format_timestamp(x[1].timestamp), "trace_id": x[1].trace_id},
+            id="filter_scope_version",
+        ),
     ],
 )
 def test_traces_list_with_corrupt_data(
@@ -1283,6 +1290,156 @@ def test_traces_list_with_corrupt_data(
         assert get_rows(response)[0]["data"] == expected(traces)
 
 
+@pytest.mark.parametrize(
+    "filter_expression,expected_indices",
+    [
+        # Intrinsic scope.name / scope.version resolve to the JSON sub-columns.
+        pytest.param("scope.name = 'io.signoz.payment'", [1], id="intrinsic_scope_name"),
+        pytest.param("scope.version = '2.3.1'", [0], id="intrinsic_scope_version"),
+        # A scope attribute resolves against the scope JSON column's attributes.
+        pytest.param("scope.telemetry.sdk.language = 'python'", [1], id="scope_attribute"),
+        # `env.tier` is a span attribute on span 0 and a scope attribute on
+        # span 1. Unprefixed -> no explicit context, so it is checked in every
+        # applicable context (attribute OR scope) and both spans match.
+        pytest.param("env.tier = 'gold'", [0, 1], id="bare_cross_context"),
+        # The explicit `scope.` prefix forces scope context only, so span 0's
+        # span attribute is ignored — only span 1 matches.
+        pytest.param("scope.env.tier = 'gold'", [1], id="scope_prefixed_cross_context"),
+        # `scope.name` matches BOTH the intrinsic scope.name field (span 0) and a
+        # scope attribute literally named `name` (span 1's scope attribute
+        # name='io.signoz.checkout').
+        pytest.param("scope.name = 'io.signoz.checkout'", [0, 1], id="scope_name_collision"),
+        # `scope.name` also matches a span attribute literally named `scope.name`
+        # (attribute context) — span 2 carries attribute scope.name='attr-scope-name'.
+        pytest.param("scope.name = 'attr-scope-name'", [2], id="scope_name_attribute_collision"),
+        # An unprefixed `name` resolves to the intrinsic span `name` column and a
+        # `name` scope attribute, but NOT the scope.name field. Span 2's span
+        # name and span 1's scope attribute `name` both equal 'io.signoz.checkout';
+        # span 0's scope.name field equals it too but is NOT matched.
+        pytest.param("name = 'io.signoz.checkout'", [1, 2], id="bare_name_excludes_scope_name_field"),
+        # A value that no resolvable key holds (scope.name/scope.version field,
+        # a `name`/`version` scope attribute, or a same-named attribute/resource)
+        # returns nothing.
+        pytest.param("scope.version = 'corrupt_data'", [], id="scope_version_no_match"),
+        pytest.param("scope.name = 'corrupt_data'", [], id="scope_name_no_match"),
+    ],
+)
+def test_traces_list_with_scope_filter(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+    filter_expression: str,
+    expected_indices: list[int],
+) -> None:
+    """
+    Setup three spans with different scope key resolution:
+    - x[0]: scope.name/version 'io.signoz.checkout'/'2.3.1'; span attribute
+      env.tier='gold'.
+    - x[1]: scope.name/version 'io.signoz.payment'/'4.5.6'; scope attributes
+      telemetry.sdk.language='python', env.tier='gold', and a `name` scope
+      attribute colliding with x[0]'s scope.name value.
+    - x[2]: span name 'io.signoz.checkout' (colliding with x[0]'s scope.name
+      value) and a span attribute literally named `scope.name`.
+
+    Tests:
+    - Filtering on scope.name / scope.version / a scope attribute.
+    - An unprefixed key is resolved across contexts (scope checked alongside
+      attribute / intrinsic), while a `scope.`-prefixed key is scope-only.
+    - `scope.name` hits the intrinsic field, a `name` scope attribute, and a
+      span attribute `scope.name` (cross-context), while a bare `name` hits
+      the span name column (and a `name` scope attribute) but never the
+      scope.name field.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    trace_id = TraceIdGenerator.trace_id()
+    span_ids = [TraceIdGenerator.span_id() for _ in range(3)]
+
+    traces = [
+        Traces(
+            timestamp=now - timedelta(seconds=4),
+            duration=timedelta(seconds=2),
+            trace_id=trace_id,
+            span_id=span_ids[0],
+            parent_span_id="",
+            name="GET /checkout",
+            kind=TracesKind.SPAN_KIND_SERVER,
+            status_code=TracesStatusCode.STATUS_CODE_OK,
+            resources={"service.name": "checkout"},
+            attributes={"http.request.method": "GET", "env.tier": "gold"},
+            scope={
+                "name": "io.signoz.checkout",
+                "version": "2.3.1",
+                "attributes": {"telemetry.sdk.language": "go"},
+            },
+        ),
+        Traces(
+            timestamp=now - timedelta(seconds=2),
+            duration=timedelta(seconds=1),
+            trace_id=trace_id,
+            span_id=span_ids[1],
+            parent_span_id="",
+            name="POST /pay",
+            kind=TracesKind.SPAN_KIND_SERVER,
+            status_code=TracesStatusCode.STATUS_CODE_OK,
+            resources={"service.name": "payment"},
+            attributes={"http.request.method": "POST"},
+            # env.tier is a scope attribute here (cross-context with span 0);
+            # `name` is a scope attribute colliding with span 0's scope.name.
+            scope={
+                "name": "io.signoz.payment",
+                "version": "4.5.6",
+                "attributes": {
+                    "telemetry.sdk.language": "python",
+                    "env.tier": "gold",
+                    "name": "io.signoz.checkout",
+                },
+            },
+        ),
+        Traces(
+            timestamp=now - timedelta(seconds=1),
+            duration=timedelta(seconds=1),
+            trace_id=trace_id,
+            span_id=span_ids[2],
+            parent_span_id="",
+            # span name collides with span 0's scope.name value
+            name="io.signoz.checkout",
+            kind=TracesKind.SPAN_KIND_SERVER,
+            status_code=TracesStatusCode.STATUS_CODE_OK,
+            resources={"service.name": "probe"},
+            # a span attribute named `scope.name`
+            attributes={"scope.name": "attr-scope-name"},
+            scope={"name": "span-gamma", "version": "9.9.9"},
+        ),
+    ]
+    insert_traces(traces)
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    start_ms, end_ms = _query_window(now)
+
+    response = make_query_request(
+        signoz,
+        token,
+        start_ms=start_ms,
+        end_ms=end_ms,
+        request_type=RequestType.RAW,
+        queries=[
+            BuilderQuery(
+                signal="traces",
+                name="A",
+                select_fields=[TelemetryFieldKey("timestamp")],
+                filter_expression=filter_expression,
+                limit=10,
+            ).to_dict()
+        ],
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    got_span_ids = {row["data"]["span_id"] for row in get_rows(response)}
+    expected_span_ids = {traces[i].span_id for i in expected_indices}
+    assert got_span_ids == expected_span_ids
+
+
 @pytest.mark.parametrize("surface", ["filter", "select", "order"])
 def test_traces_list_unknown_span_context_synthesizes(
     signoz: types.SigNoz,

tests/integration/tests/savedview/01_saved_view.py

@@ -26,15 +26,14 @@ def test_create_rejects_wrong_schema_version(
             "name": "my-view",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v9",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v9",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -59,15 +58,14 @@ def test_create_rejects_invalid_panel_type(
             "name": "my-view",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "bogus",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "bogus",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -91,15 +89,14 @@ def test_create_rejects_empty_queries(
             "name": "my-view",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -127,15 +124,14 @@ def test_create_rejects_empty_display_name(
             "name": "my-view",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -160,15 +156,14 @@ def test_create_rejects_invalid_source(
             "name": "my-view",
             "generateName": False,
             "source": "bogus",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -192,15 +187,14 @@ def test_create_rejects_invalid_name(
             "name": "Not A Valid Slug",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -226,15 +220,14 @@ def test_create_rejects_empty_name_without_generate_name(
             "name": "",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -261,15 +254,14 @@ def test_create_rejects_name_when_generate_name_is_true(
             "name": "explicit-name",
             "generateName": True,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -298,15 +290,14 @@ def test_create_rejects_unknown_field(
             "name": "my-view",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
             "unknownfield": "boom",
         },
@@ -366,15 +357,14 @@ def test_update_missing_view_returns_not_found(
         signoz.self.host_configs["8080"].get(f"{BASE_URL}/{uuid.uuid4()}"),
         json={
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -402,15 +392,14 @@ def test_update_rejects_name_field(
             "name": "update-rejects-name-field",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My View",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My View",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers=headers,
@@ -424,15 +413,14 @@ def test_update_rejects_name_field(
             signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
             json={
                 "source": "logs",
-                "data": {
-                    "schemaVersion": "v2",
-                    "spec": {
-                        "displayName": "My View",
-                        "panelType": "table",
-                        "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                        "selectedFields": [],
-                        "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                    },
+                "schemaVersion": "v2",
+                "spec": {
+                    "displayName": "My View",
+                    "requestType": "scalar",
+                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                    "selectedFields": [],
+                    "panelType": "table",
+                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
                 },
                 "name": "update-rejects-name-field",
             },
@@ -485,15 +473,14 @@ def test_saved_view_lifecycle(
             "name": "lc-logs-overview",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "lc-logs-overview",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "lc-logs-overview",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers=headers,
@@ -508,15 +495,14 @@ def test_saved_view_lifecycle(
             "name": "lc-traces-overview",
             "generateName": False,
             "source": "traces",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "lc-traces-overview",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "lc-traces-overview",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers=headers,
@@ -535,9 +521,9 @@ def test_saved_view_lifecycle(
         got = response.json()["data"]
         assert got["id"] == view_id
         assert got["name"] == "lc-logs-overview"
-        assert got["data"]["spec"]["displayName"] == "lc-logs-overview"
+        assert got["spec"]["displayName"] == "lc-logs-overview"
         assert got["source"] == "logs"
-        assert got["data"]["spec"]["panelType"] == "table"
+        assert got["spec"]["panelType"] == "table"
 
         # ── list filters by source and name ──────────────────────────────
         response = requests.get(
@@ -564,15 +550,14 @@ def test_saved_view_lifecycle(
             signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
             json={
                 "source": "metrics",
-                "data": {
-                    "schemaVersion": "v2",
-                    "spec": {
-                        "displayName": "lc-logs-overview-renamed",
-                        "panelType": "graph",
-                        "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                        "selectedFields": [],
-                        "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                    },
+                "schemaVersion": "v2",
+                "spec": {
+                    "displayName": "lc-logs-overview-renamed",
+                    "requestType": "time_series",
+                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                    "selectedFields": [],
+                    "panelType": "graph",
+                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
                 },
             },
             headers=headers,
@@ -588,9 +573,9 @@ def test_saved_view_lifecycle(
         assert response.status_code == HTTPStatus.OK, response.text
         updated = response.json()["data"]
         assert updated["name"] == "lc-logs-overview", "name is immutable"
-        assert updated["data"]["spec"]["displayName"] == "lc-logs-overview-renamed"
+        assert updated["spec"]["displayName"] == "lc-logs-overview-renamed"
         assert updated["source"] == "metrics"
-        assert updated["data"]["spec"]["panelType"] == "graph"
+        assert updated["spec"]["panelType"] == "graph"
     finally:
         requests.delete(
             signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
@@ -621,15 +606,14 @@ def test_empty_name_derives_a_slug_from_display_name(
             "name": "",
             "generateName": True,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "My Generated View!",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "My Generated View!",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers=headers,
@@ -646,7 +630,7 @@ def test_empty_name_derives_a_slug_from_display_name(
         )
         assert response.status_code == HTTPStatus.OK, response.text
         got = response.json()["data"]
-        assert got["data"]["spec"]["displayName"] == "My Generated View!"
+        assert got["spec"]["displayName"] == "My Generated View!"
         assert got["name"].startswith("my-generated-view-")
         assert got["name"] != "my-generated-view-", "expected a random suffix, not just the slugified prefix"
     finally:
@@ -681,15 +665,14 @@ def test_create_roundtrip_preserves_zero_values(
             "name": "create-zero-values",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "create-zero-values",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "create-zero-values",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers=headers,
@@ -705,10 +688,11 @@ def test_create_roundtrip_preserves_zero_values(
             timeout=5,
         )
         assert response.status_code == HTTPStatus.OK, response.text
-        spec = response.json()["data"]["data"]["spec"]
+        spec = response.json()["data"]["spec"]
         query = spec["queries"][0]["spec"]
 
         cases = [
+            ("panelType preserved", spec["panelType"], "table"),
             ("maxLines 0", spec["display"]["maxLines"], 0),
             ("fontSize empty", spec["display"]["fontSize"], ""),
             ("format empty", spec["display"]["format"], ""),
@@ -727,28 +711,30 @@ def test_create_roundtrip_preserves_zero_values(
         )
 
 
-def test_selected_fields_omitted_on_create_reads_back_as_empty_list_not_null(
+def test_selected_fields_and_display_omitted_on_create_read_back_as_empty_defaults(
     signoz: SigNoz,
     create_user_admin: Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
 ):
+    """Neither selectedFields nor display is required. Omitting both entirely
+    must not 400 or leave either null on read-back: selectedFields defaults to
+    an empty list, display to its zero-value object. panelType is a separate,
+    required, top-level field and is supplied here so the create succeeds."""
     token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
     headers = {"Authorization": f"Bearer {token}"}
 
     response = requests.post(
         signoz.self.host_configs["8080"].get(BASE_URL),
         json={
-            "name": "omitted-selected-fields",
+            "name": "omitted-selected-fields-and-display",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "omitted-selected-fields",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "omitted-selected-fields-and-display",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "panelType": "table",
             },
         },
         headers=headers,
@@ -764,7 +750,108 @@ def test_selected_fields_omitted_on_create_reads_back_as_empty_list_not_null(
             timeout=5,
         )
         assert response.status_code == HTTPStatus.OK, response.text
-        assert response.json()["data"]["data"]["spec"]["selectedFields"] == []
+        spec = response.json()["data"]["spec"]
+        assert spec["selectedFields"] == []
+        assert spec["display"] == {"maxLines": 0, "fontSize": "", "format": "", "color": ""}
+    finally:
+        requests.delete(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )
+
+
+def test_selected_fields_and_display_explicit_null_on_create(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    """JSON null decodes as a no-op onto a non-pointer Go field (struct/slice), so
+    an explicit null is expected to behave identically to omitting the field."""
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json={
+            "name": "null-selected-fields-and-display",
+            "generateName": False,
+            "source": "logs",
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "null-selected-fields-and-display",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "panelType": "table",
+                "selectedFields": None,
+                "display": None,
+            },
+        },
+        headers=headers,
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.CREATED, response.text
+    view_id = response.json()["data"]["id"]
+
+    try:
+        response = requests.get(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.OK, response.text
+        spec = response.json()["data"]["spec"]
+        assert spec["selectedFields"] == []
+        assert spec["display"] == {"maxLines": 0, "fontSize": "", "format": "", "color": ""}
+    finally:
+        requests.delete(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )
+
+
+def test_create_with_partial_display_defaults_missing_fields(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    """display's fields are each independently optional -- sending only one
+    (color) must not 400, and the fields left unset must default to their own
+    zero value rather than being rejected or dropped."""
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json={
+            "name": "partial-display-color-only",
+            "generateName": False,
+            "source": "logs",
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "partial-display-color-only",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "panelType": "table",
+                "selectedFields": [],
+                "display": {"color": "test"},
+            },
+        },
+        headers=headers,
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.CREATED, response.text
+    view_id = response.json()["data"]["id"]
+
+    try:
+        response = requests.get(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.OK, response.text
+        assert response.json()["data"]["spec"]["display"] == {"maxLines": 0, "fontSize": "", "format": "", "color": "test"}
     finally:
         requests.delete(
             signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
@@ -793,15 +880,14 @@ def test_update_does_not_corrupt_zero_values(
             "name": "update-zero-values",
             "generateName": False,
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "update-zero-values",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": True, "legend": "Custom Legend"}}],
-                    "selectedFields": [{"name": "service.name"}],
-                    "display": {"maxLines": 25, "fontSize": "large", "format": "table", "color": "blue"},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "update-zero-values",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": True, "legend": "Custom Legend"}}],
+                "selectedFields": [{"name": "service.name"}],
+                "panelType": "table",
+                "display": {"maxLines": 25, "fontSize": "large", "format": "table", "color": "blue"},
             },
         },
         headers=headers,
@@ -817,7 +903,7 @@ def test_update_does_not_corrupt_zero_values(
             timeout=5,
         )
         assert response.status_code == HTTPStatus.OK, response.text
-        spec = response.json()["data"]["data"]["spec"]
+        spec = response.json()["data"]["spec"]
         assert spec["display"]["maxLines"] == 25
         # signal/fieldContext/fieldDataType always serialize on TelemetryFieldKey
         # (no omitempty -- see pkg/types/telemetrytypes/field.go), so an entry sent
@@ -830,15 +916,14 @@ def test_update_does_not_corrupt_zero_values(
             signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
             json={
                 "source": "logs",
-                "data": {
-                    "schemaVersion": "v2",
-                    "spec": {
-                        "displayName": "update-zero-values",
-                        "panelType": "table",
-                        "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
-                        "selectedFields": [],
-                        "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                    },
+                "schemaVersion": "v2",
+                "spec": {
+                    "displayName": "update-zero-values",
+                    "requestType": "scalar",
+                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}], "disabled": False, "legend": ""}}],
+                    "selectedFields": [],
+                    "panelType": "table",
+                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
                 },
             },
             headers=headers,
@@ -853,7 +938,7 @@ def test_update_does_not_corrupt_zero_values(
             timeout=5,
         )
         assert response.status_code == HTTPStatus.OK, response.text
-        spec = response.json()["data"]["data"]["spec"]
+        spec = response.json()["data"]["spec"]
         query = spec["queries"][0]["spec"]
 
         cases = [
@@ -873,3 +958,71 @@ def test_update_does_not_corrupt_zero_values(
             headers=headers,
             timeout=5,
         )
+
+
+def test_update_with_partial_display_replaces_whole_object(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    """Update is a whole-object replace, not a merge: sending only "color" on
+    update must not preserve the previous fontSize/format/maxLines -- those
+    reset to their zero value exactly as if display had been sent in full."""
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json={
+            "name": "update-partial-display",
+            "generateName": False,
+            "source": "logs",
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "update-partial-display",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 10, "fontSize": "large", "format": "table", "color": "blue"},
+            },
+        },
+        headers=headers,
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.CREATED, response.text
+    view_id = response.json()["data"]["id"]
+
+    try:
+        response = requests.put(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            json={
+                "source": "logs",
+                "schemaVersion": "v2",
+                "spec": {
+                    "displayName": "update-partial-display",
+                    "requestType": "scalar",
+                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                    "selectedFields": [],
+                    "panelType": "table",
+                    "display": {"color": "green"},
+                },
+            },
+            headers=headers,
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+        response = requests.get(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.OK, response.text
+        assert response.json()["data"]["spec"]["display"] == {"maxLines": 0, "fontSize": "", "format": "", "color": "green"}
+    finally:
+        requests.delete(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers=headers,
+            timeout=5,
+        )

tests/integration/tests/savedview/02_authz.py

@@ -112,15 +112,14 @@ def test_write_forbidden_without_grant(
         signoz.self.host_configs["8080"].get(f"{SAVED_VIEW_BASE}/{target_id}"),
         json={
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": _SAVED_VIEW_FGA_TARGET_NAME,
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": _SAVED_VIEW_FGA_TARGET_NAME,
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -133,15 +132,14 @@ def test_write_forbidden_without_grant(
         json={
             "name": "saved-view-fga-create-attempt",
             "source": "logs",
-            "data": {
-                "schemaVersion": "v2",
-                "spec": {
-                    "displayName": "saved-view-fga-create-attempt",
-                    "panelType": "table",
-                    "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
-                    "selectedFields": [],
-                    "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-                },
+            "schemaVersion": "v2",
+            "spec": {
+                "displayName": "saved-view-fga-create-attempt",
+                "requestType": "scalar",
+                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+                "selectedFields": [],
+                "panelType": "table",
+                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
             },
         },
         headers={"Authorization": f"Bearer {token}"},
@@ -212,15 +210,14 @@ def test_update_scoped_to_granted_view(
     token = get_token(_SAVED_VIEW_FGA_CUSTOM_USER_EMAIL, _SAVED_VIEW_FGA_CUSTOM_USER_PASSWORD)
     updated_body = {
         "source": "logs",
-        "data": {
-            "schemaVersion": "v2",
-            "spec": {
-                "displayName": _SAVED_VIEW_FGA_TARGET_NAME,
-                "panelType": "graph",
-                "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
-                "selectedFields": [],
-                "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
-            },
+        "schemaVersion": "v2",
+        "spec": {
+            "displayName": _SAVED_VIEW_FGA_TARGET_NAME,
+            "requestType": "time_series",
+            "queries": [{"type": "builder_query", "spec": {"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]}}],
+            "selectedFields": [],
+            "panelType": "graph",
+            "display": {"maxLines": 0, "fontSize": "", "format": "", "color": ""},
         },
     }