test(llm-observability): keep only the rule-walk and decode cases for pricing patterns

Pattern semantics are covered once in the collector's pkg/llmpricing.

Assisted-by: Claude Fable 5.1

frontend/src/components/LogDetail/index.tsx

@@ -4,7 +4,6 @@ import { Button } from '@signozhq/ui/button';
 import { Drawer, Tooltip } from 'antd';
 import { ToggleGroup } from '@signozhq/ui/toggle-group';
 import { Typography } from '@signozhq/ui/typography';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import LogStateIndicator from 'components/Logs/LogStateIndicator/LogStateIndicator';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
 import QuerySearch from 'components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch';
@@ -148,7 +147,7 @@ function LogDetailInner({
 
 	const { options } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator: listQuery?.aggregateOperator || StringOperators.NOOP,
 	});
 

frontend/src/components/QueryBuilderV2/stories/QueryBuilderV2.behaviour.stories.tsx

@@ -1,169 +0,0 @@
-import type { Meta, StoryObj } from '@storybook/react-vite';
-import { expect, waitFor } from 'storybook/test';
-
-import { withCanvas } from '@/storybook/decorators/withCanvas';
-
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { DataSource } from 'types/common/queryBuilder';
-
-import { QueryBuilderV2 } from '../QueryBuilderV2';
-import {
-	addOnToggles,
-	appendToAggregation,
-	DEFAULT_ARGS,
-	expectFirstQuery,
-	PANEL_EDITOR_ARGS,
-	PANEL_EDITOR_PATH,
-	payloadIn,
-	routeWith,
-	selectMetric,
-} from './QueryBuilderV2.stories.mocks';
-import QueryProbe from './QueryProbe';
-
-const METRICS_EXPLORER_ARGS = {
-	config: { initialDataSource: DataSource.METRICS, queryVariant: 'static' },
-	showFunctions: false,
-} as const;
-
-const metricsExplorerRoute = routeWith(
-	ROUTES.METRICS_EXPLORER_EXPLORER,
-	initialQueriesMap.metrics,
-);
-
-/**
- * Builder rules that hold without a backend: which add-ons a panel kind
- * offers, the aggregations a metric type defaults to, and input limits. The
- * probe below the builder prints the payload each play asserts on.
- */
-const meta = {
-	title: 'Components/Query Builder/Behaviour',
-	component: QueryBuilderV2,
-	tags: ['play'],
-	decorators: [withCanvas({ maxWidth: 1100 })],
-	args: DEFAULT_ARGS,
-	render: (args): JSX.Element => (
-		<>
-			<QueryBuilderV2 {...args} />
-			<QueryProbe />
-		</>
-	),
-} satisfies Meta<typeof QueryBuilderV2>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-/** A Value panel offers only the legend add-on. */
-export const LogsOnValuePanel: Story = {
-	args: { ...PANEL_EDITOR_ARGS, panelType: PANEL_TYPES.VALUE },
-	parameters: {
-		signoz: { route: routeWith(PANEL_EDITOR_PATH, initialQueriesMap.logs) },
-	},
-	play: async ({ canvasElement }) => {
-		await waitFor(() =>
-			expect(addOnToggles(canvasElement)).toStrictEqual(['legend_format']),
-		);
-	},
-};
-
-/** Metrics on a Table: reduce-to is offered; group by lives in the aggregation row. */
-export const MetricsOnTablePanel: Story = {
-	args: { ...PANEL_EDITOR_ARGS, panelType: PANEL_TYPES.TABLE },
-	parameters: {
-		signoz: { route: routeWith(PANEL_EDITOR_PATH, initialQueriesMap.metrics) },
-	},
-	play: async ({ canvasElement }) => {
-		await waitFor(() =>
-			expect(addOnToggles(canvasElement)).toStrictEqual([
-				'having',
-				'order_by',
-				'limit',
-				'legend_format',
-				'reduce_to',
-			]),
-		);
-	},
-};
-
-/** Traces on a time series: every add-on, with group by as a toggle. */
-export const TracesOnTimeSeriesPanel: Story = {
-	args: PANEL_EDITOR_ARGS,
-	parameters: {
-		signoz: { route: routeWith(PANEL_EDITOR_PATH, initialQueriesMap.traces) },
-	},
-	play: async ({ canvasElement }) => {
-		await waitFor(() =>
-			expect(addOnToggles(canvasElement)).toStrictEqual([
-				'group_by',
-				'having',
-				'order_by',
-				'limit',
-				'legend_format',
-			]),
-		);
-	},
-};
-
-/** Picking a gauge defaults to avg over time and avg across series. */
-export const GaugeMetricDefaults: Story = {
-	args: METRICS_EXPLORER_ARGS,
-	parameters: { signoz: { route: metricsExplorerRoute } },
-	play: async ({ canvasElement }) => {
-		await selectMetric(canvasElement, 'container_cpu_utilization');
-
-		await expectFirstQuery(canvasElement, {
-			aggregations: [
-				expect.objectContaining({
-					metricName: 'container_cpu_utilization',
-					timeAggregation: 'avg',
-					spaceAggregation: 'avg',
-				}),
-			],
-		});
-	},
-};
-
-/** Picking a histogram defaults to the p90 across series. */
-export const HistogramMetricDefaults: Story = {
-	args: METRICS_EXPLORER_ARGS,
-	parameters: { signoz: { route: metricsExplorerRoute } },
-	play: async ({ canvasElement }) => {
-		await selectMetric(canvasElement, 'signoz_latency_bucket');
-
-		await expectFirstQuery(canvasElement, {
-			aggregations: [
-				expect.objectContaining({
-					metricName: 'signoz_latency_bucket',
-					spaceAggregation: 'p90',
-				}),
-			],
-		});
-	},
-};
-
-/** A Value panel takes a single aggregation: a second one is not accepted. */
-export const ValuePanelTakesOneAggregation: Story = {
-	args: { ...PANEL_EDITOR_ARGS, panelType: PANEL_TYPES.VALUE },
-	parameters: {
-		signoz: { route: routeWith(PANEL_EDITOR_PATH, initialQueriesMap.logs) },
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, {
-			aggregations: [{ expression: 'count()' }],
-		});
-
-		const { before, after } = appendToAggregation(
-			canvasElement,
-			', count_distinct(service.name)',
-		);
-		await expect(after).toBe(before);
-
-		await expectFirstQuery(canvasElement, {
-			aggregations: [{ expression: 'count()' }],
-		});
-		await expect(
-			payloadIn(canvasElement).queries[0].spec.aggregations,
-		).toHaveLength(1);
-	},
-};

frontend/src/components/QueryBuilderV2/stories/QueryBuilderV2.stories.mocks.tsx

@@ -1,134 +0,0 @@
-/**
- * AI-owned. Generated and maintained by the `signoz-page-story` skill.
- * Do not hand-edit: regenerate instead.
- */
-
-import { EditorView } from '@codemirror/view';
-import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
-
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import type { QueryBuilderV2 } from '../QueryBuilderV2';
-
-type QueryBuilderProps = Parameters<typeof QueryBuilderV2>[0];
-
-/** The builder's provider reads its starting query from the URL, as every host seeds it. */
-export const routeWith = (path: string, query: Query): string =>
-	`${path}?compositeQuery=${encodeURIComponent(JSON.stringify(query))}`;
-
-export const meterQuery: Query = {
-	...initialQueriesMap.metrics,
-	builder: {
-		...initialQueriesMap.metrics.builder,
-		queryData: [
-			{ ...initialQueriesMap.metrics.builder.queryData[0], source: 'meter' },
-		],
-	},
-};
-
-/** `PanelEditorQueryBuilder`'s props, less the per-kind field config. */
-export const PANEL_EDITOR_ARGS: Partial<QueryBuilderProps> = {
-	allowedDataSources: [
-		TelemetrytypesSignalDTO.logs,
-		TelemetrytypesSignalDTO.traces,
-		TelemetrytypesSignalDTO.metrics,
-	],
-	showTraceOperator: true,
-	signalSourceChangeEnabled: true,
-	savePreviousQuery: true,
-};
-
-export const PANEL_EDITOR_PATH = '/dashboard/story/panel/story';
-
-interface ProbedQuery {
-	type: string;
-	spec: {
-		aggregations?: Record<string, unknown>[];
-		[key: string]: unknown;
-	};
-}
-
-/** The `compositeQuery` the story's `QueryProbe` prints for the builder's state. */
-export const payloadIn = (
-	canvasElement: HTMLElement,
-): { queries: ProbedQuery[] } =>
-	JSON.parse(
-		within(canvasElement).getByTestId('qb-payload').textContent ?? '{}',
-	) as { queries: ProbedQuery[] };
-
-export const expectFirstQuery = async (
-	canvasElement: HTMLElement,
-	spec: Record<string, unknown>,
-): Promise<void> => {
-	await waitFor(() =>
-		expect(payloadIn(canvasElement).queries[0]).toMatchObject({
-			type: 'builder_query',
-			spec: expect.objectContaining(spec),
-		}),
-	);
-};
-
-/** The add-on toggles query `A` offers, in order (`group_by`, `having`, …). */
-export const addOnToggles = (canvasElement: HTMLElement): string[] =>
-	within(within(canvasElement).getByTestId('query-A'))
-		.queryAllByTestId(/^query-add-on-/)
-		.map((toggle) =>
-			(toggle.getAttribute('data-testid') ?? '').replace('query-add-on-', ''),
-		);
-
-/** Picks `metricName` in query `A`'s metric selector; its list portals out. */
-export const selectMetric = async (
-	canvasElement: HTMLElement,
-	metricName: string,
-): Promise<void> => {
-	const field = within(canvasElement).getByTestId('metric-name-selector-0');
-	const input = within(field).getByRole('combobox');
-	await userEvent.click(input);
-	await userEvent.type(input, metricName);
-	const option = await waitFor(async () => {
-		const match = Array.from(
-			document.querySelectorAll<HTMLElement>(
-				'.ant-select-dropdown:not(.ant-select-dropdown-hidden) .ant-select-item-option',
-			),
-		).find((candidate) => candidate.textContent?.includes(metricName));
-		await expect(match).toBeDefined();
-		return match as HTMLElement;
-	});
-	await userEvent.click(option);
-	await waitFor(() => expect(screen.queryByRole('listbox')).toBeNull());
-};
-
-/**
- * Appends `text` to query `A`'s aggregation editor and returns its document
- * before and after. Dispatched as a CodeMirror transaction: `userEvent.type`
- * strands the caret when the line redraws, and a transaction runs the editor's
- * own filters, which is what an input limit is.
- */
-export const appendToAggregation = (
-	canvasElement: HTMLElement,
-	text: string,
-): { before: string; after: string } => {
-	const content = within(canvasElement)
-		.getByTestId('query-aggregation-editor')
-		.querySelector<HTMLElement>('.cm-content');
-	const view = content ? EditorView.findFromDOM(content) : null;
-	if (!view) {
-		throw new Error('aggregation editor not mounted');
-	}
-	const before = view.state.doc.toString();
-	view.dispatch({
-		changes: { from: before.length, insert: text },
-		selection: { anchor: before.length + text.length },
-		userEvent: 'input.type',
-	});
-	// Read synchronously: the document is the editor's own verdict, before
-	// React state catches up.
-	return { before, after: view.state.doc.toString() };
-};
-
-export const DEFAULT_ARGS: Partial<QueryBuilderProps> = {
-	panelType: PANEL_TYPES.TIME_SERIES,
-	version: 'v3',
-};

frontend/src/components/QueryBuilderV2/stories/QueryBuilderV2.stories.tsx

@@ -1,145 +0,0 @@
-import type { Meta, StoryObj } from '@storybook/react-vite';
-import { expect, within } from 'storybook/test';
-
-import { withCanvas } from '@/storybook/decorators/withCanvas';
-
-import { initialQueriesMap } from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { DataSource } from 'types/common/queryBuilder';
-
-import { QueryBuilderV2 } from '../QueryBuilderV2';
-import {
-	DEFAULT_ARGS,
-	expectFirstQuery,
-	meterQuery,
-	PANEL_EDITOR_ARGS,
-	PANEL_EDITOR_PATH,
-	routeWith,
-} from './QueryBuilderV2.stories.mocks';
-import QueryProbe from './QueryProbe';
-
-/**
- * The query builder as each host mounts it: the props come from that host's
- * call site, the starting query from its route. The probe below the builder
- * prints the `query_range` payload its state would send.
- */
-const meta = {
-	title: 'Components/Query Builder',
-	component: QueryBuilderV2,
-	tags: ['play'],
-	decorators: [withCanvas({ maxWidth: 1100 })],
-	args: DEFAULT_ARGS,
-	render: (args): JSX.Element => (
-		<>
-			<QueryBuilderV2 {...args} />
-			<QueryProbe />
-		</>
-	),
-} satisfies Meta<typeof QueryBuilderV2>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-/** Logs explorer, graph view: a fixed logs signal with `count()`. */
-export const LogsExplorer: Story = {
-	args: {
-		config: { initialDataSource: DataSource.LOGS, queryVariant: 'static' },
-	},
-	parameters: {
-		signoz: { route: routeWith(ROUTES.LOGS_EXPLORER, initialQueriesMap.logs) },
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, {
-			signal: 'logs',
-			aggregations: [{ expression: 'count()' }],
-		});
-	},
-};
-
-/** Traces explorer: a fixed traces signal, with trace matching offered. */
-export const TracesExplorer: Story = {
-	args: {
-		config: { initialDataSource: DataSource.TRACES, queryVariant: 'static' },
-		showTraceOperator: true,
-	},
-	parameters: {
-		signoz: {
-			route: routeWith(ROUTES.TRACES_EXPLORER, initialQueriesMap.traces),
-		},
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, { signal: 'traces' });
-	},
-};
-
-/** Metrics explorer: a fixed metrics signal, functions hidden. */
-export const MetricsExplorer: Story = {
-	args: {
-		config: { initialDataSource: DataSource.METRICS, queryVariant: 'static' },
-		showFunctions: false,
-	},
-	parameters: {
-		signoz: {
-			route: routeWith(
-				ROUTES.METRICS_EXPLORER_EXPLORER,
-				initialQueriesMap.metrics,
-			),
-		},
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, { signal: 'metrics' });
-	},
-};
-
-/** Meter explorer: metrics read from the meter source. */
-export const MeterExplorer: Story = {
-	args: {
-		config: {
-			initialDataSource: DataSource.METRICS,
-			queryVariant: 'static',
-			signalSource: 'meter',
-		},
-		showFunctions: false,
-	},
-	parameters: {
-		signoz: { route: routeWith(ROUTES.METER_EXPLORER, meterQuery) },
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, { signal: 'metrics', source: 'meter' });
-	},
-};
-
-/**
- * V2 panel editor: a data-source dropdown per query, several queries,
- * formulas and trace matching.
- */
-export const PanelEditor: Story = {
-	args: PANEL_EDITOR_ARGS,
-	parameters: {
-		signoz: {
-			route: routeWith(PANEL_EDITOR_PATH, initialQueriesMap.logs),
-		},
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, { signal: 'logs' });
-		await expect(
-			within(canvasElement).getByTestId('query-data-source-selector-0'),
-		).toBeVisible();
-	},
-};
-
-/** Logs alert: a fixed logs signal with functions, as the alert form mounts it. */
-export const LogsAlert: Story = {
-	args: {
-		config: { initialDataSource: DataSource.LOGS, queryVariant: 'static' },
-		showFunctions: true,
-		signalSourceChangeEnabled: true,
-	},
-	parameters: {
-		signoz: { route: routeWith(ROUTES.ALERTS_NEW, initialQueriesMap.logs) },
-	},
-	play: async ({ canvasElement }) => {
-		await expectFirstQuery(canvasElement, { signal: 'logs' });
-	},
-};

frontend/src/components/QueryBuilderV2/stories/QueryProbe.module.scss

@@ -1,11 +0,0 @@
-.probe {
-	margin-top: 16px;
-	padding: 12px;
-	max-height: 320px;
-	overflow: auto;
-	border: 1px solid var(--l1-border);
-	border-radius: 4px;
-	font-size: 12px;
-	color: var(--l2-foreground);
-	background: var(--l1-background);
-}

frontend/src/components/QueryBuilderV2/stories/QueryProbe.tsx

@@ -1,38 +0,0 @@
-import { useMemo } from 'react';
-import { prepareQueryRangePayloadV5 } from 'api/v5/queryRange/prepareQueryRangePayloadV5';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-import styles from './QueryProbe.module.scss';
-
-/** Fixed, so the printed payload is the same on every render and capture. */
-const WINDOW = { start: 1_700_000_000_000, end: 1_700_003_600_000 };
-
-/**
- * Prints the `compositeQuery` the builder's live state would send, so a play
- * function asserts on the query rather than on the DOM that edits it.
- */
-function QueryProbe(): JSX.Element {
-	const { currentQuery, panelType } = useQueryBuilder();
-
-	const payload = useMemo(() => {
-		try {
-			return prepareQueryRangePayloadV5({
-				query: currentQuery,
-				graphType: panelType ?? PANEL_TYPES.TIME_SERIES,
-				selectedTime: 'GLOBAL_TIME',
-				...WINDOW,
-			}).queryPayload.compositeQuery;
-		} catch (error) {
-			return { error: String(error) };
-		}
-	}, [currentQuery, panelType]);
-
-	return (
-		<pre className={styles.probe} data-testid="qb-payload">
-			{JSON.stringify(payload, null, 2)}
-		</pre>
-	);
-}
-
-export default QueryProbe;

frontend/src/container/AIAssistant/components/ActionsSection/utils/__tests__/openSavedView.test.ts

@@ -18,6 +18,7 @@ import {
 import ROUTES from 'constants/routes';
 import { navigate } from 'lib/router/navigation';
 import { QueryParams } from 'constants/query';
+import { DataSource } from 'types/common/queryBuilder';
 
 import {
 	findSavedViewInLists,
@@ -25,7 +26,7 @@ import {
 	openSavedViewByKey,
 } from '../openSavedView';
 import {
-	entityToSavedViewSource,
+	entityToDataSource,
 	isSavedViewOpenAction,
 	resolveActionEntity,
 	resolveOpenResourceType,
@@ -129,14 +130,10 @@ describe('resolveOpenResource', () => {
 		).toBe('abc-123');
 	});
 
-	it('maps entity values to saved view sources', () => {
-		expect(entityToSavedViewSource('logs')).toBe(SavedviewtypesSourceDTO.logs);
-		expect(entityToSavedViewSource('logs_explorer')).toBe(
-			SavedviewtypesSourceDTO.logs,
-		);
-		expect(entityToSavedViewSource('traces')).toBe(
-			SavedviewtypesSourceDTO.traces,
-		);
+	it('maps entity values to explorer data sources', () => {
+		expect(entityToDataSource('logs')).toBe(DataSource.LOGS);
+		expect(entityToDataSource('logs_explorer')).toBe(DataSource.LOGS);
+		expect(entityToDataSource('traces')).toBe(DataSource.TRACES);
 	});
 
 	it('prefers entity over signal for saved-view source hints', () => {
@@ -147,7 +144,7 @@ describe('resolveOpenResource', () => {
 				entity: SavedViewEntityDTO.traces,
 				signal: ApplyFilterSignalDTO.logs,
 			}),
-		).toBe(SavedviewtypesSourceDTO.traces);
+		).toBe(DataSource.TRACES);
 	});
 
 	it('falls back to signal when entity is absent', () => {
@@ -157,7 +154,7 @@ describe('resolveOpenResource', () => {
 				label: 'Open view',
 				signal: ApplyFilterSignalDTO.metrics,
 			}),
-		).toBe(SavedviewtypesSourceDTO.metrics);
+		).toBe(DataSource.METRICS);
 	});
 
 	it('normalises saved-view resource types', () => {
@@ -210,10 +207,7 @@ describe('findSavedViewInLists', () => {
 		const tracesView = makeView('view-traces', SavedviewtypesSourceDTO.traces);
 		mockedListSavedViews.mockResolvedValueOnce(mockViewsResponse([tracesView]));
 
-		const result = await findSavedViewInLists(
-			'view-traces',
-			SavedviewtypesSourceDTO.traces,
-		);
+		const result = await findSavedViewInLists('view-traces', DataSource.TRACES);
 
 		expect(result).toStrictEqual(tracesView);
 		expect(mockedListSavedViews).toHaveBeenCalledTimes(1);
@@ -281,7 +275,7 @@ describe('openSavedViewByKey', () => {
 		const view = makeView('view-logs', SavedviewtypesSourceDTO.logs);
 		mockedGetSavedView.mockResolvedValueOnce(mockViewByIdResponse(view));
 
-		await openSavedViewByKey('view-logs', SavedviewtypesSourceDTO.logs);
+		await openSavedViewByKey('view-logs', DataSource.LOGS);
 
 		expect(mockedGetSavedView).toHaveBeenCalledWith({ id: 'view-logs' });
 		expect(mockedListSavedViews).not.toHaveBeenCalled();
@@ -293,7 +287,7 @@ describe('openSavedViewByKey', () => {
 		mockedGetSavedView.mockRejectedValueOnce(new Error('not found'));
 		mockedListSavedViews.mockResolvedValueOnce(mockViewsResponse([view]));
 
-		await openSavedViewByKey('view-traces', SavedviewtypesSourceDTO.traces);
+		await openSavedViewByKey('view-traces', DataSource.TRACES);
 
 		expect(mockedListSavedViews).toHaveBeenCalledWith({
 			source: SavedviewtypesSourceDTO.traces,
@@ -305,8 +299,8 @@ describe('openSavedViewByKey', () => {
 		mockedGetSavedView.mockRejectedValueOnce(new Error('not found'));
 		mockedListSavedViews.mockResolvedValue(mockViewsResponse([]));
 
-		await expect(
-			openSavedViewByKey('missing', SavedviewtypesSourceDTO.logs),
-		).rejects.toThrow('Saved view not found');
+		await expect(openSavedViewByKey('missing', DataSource.LOGS)).rejects.toThrow(
+			'Saved view not found',
+		);
 	});
 });

frontend/src/container/AIAssistant/components/ActionsSection/utils/openSavedView.ts

@@ -2,34 +2,37 @@ import {
 	getSavedView,
 	listSavedViews,
 } from 'api/generated/services/saved-view';
-import {
-	SavedviewtypesSavedViewDTO,
-	SavedviewtypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { SavedviewtypesSavedViewDTO } from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
+import { SavedViewSourcePage } from 'container/SavedViews/types';
 import { findSavedView } from 'container/SavedViews/utils/findSavedView';
 import { getSavedViewQuery } from 'container/SavedViews/utils/getSavedViewQuery';
+import { toSavedViewSource } from 'container/SavedViews/utils/toSavedViewSource';
 import { SOURCEPAGE_VS_ROUTES } from 'container/SavedViews/constants';
 import { navigate } from 'lib/router/navigation';
 import { DataSource } from 'types/common/queryBuilder';
 import { buildExplorerNavigationUrl } from 'utils/buildExplorerNavigationUrl';
 
-const DEFAULT_PROBE_SOURCES: SavedviewtypesSourceDTO[] = [
-	SavedviewtypesSourceDTO.logs,
-	SavedviewtypesSourceDTO.traces,
-	SavedviewtypesSourceDTO.metrics,
+type SavedViewSourceHint = SavedViewSourcePage;
+
+const DEFAULT_PROBE_SOURCES: SavedViewSourceHint[] = [
+	DataSource.LOGS,
+	DataSource.TRACES,
+	DataSource.METRICS,
 ];
 
 export async function findSavedViewInLists(
 	viewKey: string,
-	sourceHint?: SavedviewtypesSourceDTO | null,
+	sourceHint?: SavedViewSourceHint | null,
 ): Promise<SavedviewtypesSavedViewDTO | null> {
 	const sources = sourceHint ? [sourceHint] : DEFAULT_PROBE_SOURCES;
 
 	for (const source of sources) {
 		try {
-			const response = await listSavedViews({ source });
+			const response = await listSavedViews({
+				source: toSavedViewSource(source),
+			});
 			const match = findSavedView(response.data, viewKey);
 			if (match) {
 				return match;
@@ -44,7 +47,7 @@ export async function findSavedViewInLists(
 
 async function loadSavedView(
 	viewKey: string,
-	sourceHint?: SavedviewtypesSourceDTO | null,
+	sourceHint?: SavedViewSourceHint | null,
 ): Promise<SavedviewtypesSavedViewDTO> {
 	try {
 		const response = await getSavedView({ id: viewKey });
@@ -89,7 +92,7 @@ export function openSavedView(view: SavedviewtypesSavedViewDTO): void {
 
 export async function openSavedViewByKey(
 	viewKey: string,
-	sourceHint: SavedviewtypesSourceDTO | null | undefined,
+	sourceHint: SavedViewSourceHint | null | undefined,
 ): Promise<void> {
 	const view = await loadSavedView(viewKey, sourceHint);
 	openSavedView(view);

frontend/src/container/AIAssistant/components/ActionsSection/utils/resolveOpenResource.ts

@@ -3,7 +3,7 @@ import {
 	ApplyFilterSignalDTO,
 	SavedViewEntityDTO,
 } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { ResourceType } from './resourceRoute';
 
@@ -119,15 +119,15 @@ export function resolveActionEntity(
 }
 
 function normalizeToSavedViewEntity(value: string): SavedViewEntityDTO | null {
-	const source = entityToSavedViewSource(value);
+	const source = entityToDataSource(value);
 	switch (source) {
-		case SavedviewtypesSourceDTO.logs:
+		case DataSource.LOGS:
 			return SavedViewEntityDTO.logs;
-		case SavedviewtypesSourceDTO.traces:
+		case DataSource.TRACES:
 			return SavedViewEntityDTO.traces;
-		case SavedviewtypesSourceDTO.metrics:
+		case DataSource.METRICS:
 			return SavedViewEntityDTO.metrics;
-		case SavedviewtypesSourceDTO.meter:
+		case 'meter':
 			return SavedViewEntityDTO.meter;
 		default:
 			return null;
@@ -135,26 +135,26 @@ function normalizeToSavedViewEntity(value: string): SavedViewEntityDTO | null {
 }
 
 /**
- * Maps an action `entity` to the saved views api source for saved-view lookups.
+ * Maps an action `entity` to an explorer `DataSource` for saved-view lookups.
  * Accepts both short (`logs`) and taxonomy (`logs_explorer`) values.
  */
-export function entityToSavedViewSource(
+export function entityToDataSource(
 	entity: SavedViewEntityDTO | string,
-): SavedviewtypesSourceDTO | null {
+): DataSource | 'meter' | null {
 	const normalized = entity.trim().toLowerCase().replace(/-/g, '_');
 
 	switch (normalized) {
 		case SavedViewEntityDTO.logs:
 		case ResourceType.logs_explorer:
-			return SavedviewtypesSourceDTO.logs;
+			return DataSource.LOGS;
 		case SavedViewEntityDTO.traces:
 		case ResourceType.traces_explorer:
-			return SavedviewtypesSourceDTO.traces;
+			return DataSource.TRACES;
 		case SavedViewEntityDTO.metrics:
 		case ResourceType.metrics_explorer:
-			return SavedviewtypesSourceDTO.metrics;
+			return DataSource.METRICS;
 		case SavedViewEntityDTO.meter:
-			return SavedviewtypesSourceDTO.meter;
+			return 'meter';
 		default:
 			return null;
 	}
@@ -166,10 +166,10 @@ export function entityToSavedViewSource(
  */
 export function resolveSavedViewSourceHint(
 	action: MessageActionDTO,
-): SavedviewtypesSourceDTO | null {
+): DataSource | 'meter' | null {
 	const entity = resolveActionEntity(action);
 	if (entity) {
-		const fromEntity = entityToSavedViewSource(entity);
+		const fromEntity = entityToDataSource(entity);
 		if (fromEntity) {
 			return fromEntity;
 		}
@@ -178,11 +178,11 @@ export function resolveSavedViewSourceHint(
 	if (action.signal) {
 		switch (action.signal) {
 			case ApplyFilterSignalDTO.logs:
-				return SavedviewtypesSourceDTO.logs;
+				return DataSource.LOGS;
 			case ApplyFilterSignalDTO.traces:
-				return SavedviewtypesSourceDTO.traces;
+				return DataSource.TRACES;
 			case ApplyFilterSignalDTO.metrics:
-				return SavedviewtypesSourceDTO.metrics;
+				return DataSource.METRICS;
 			default: {
 				const _exhaustive: never = action.signal;
 				return _exhaustive;

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/components/PatternEditor/PatternEditor.tsx

@@ -13,7 +13,7 @@ interface PatternEditorProps {
 	onChange: (patterns: string[]) => void;
 }
 
-// Model-name prefix patterns as removable chips + an add input.
+// Model-name patterns as removable chips + an add input.
 function PatternEditor({
 	patterns,
 	isReadOnly,
@@ -37,12 +37,7 @@ function PatternEditor({
 
 	return (
 		<div className={styles.drawerSection}>
-			<span className={styles.fieldLabel}>
-				Model name patterns{' '}
-				<Typography.Text as="span" color="muted">
-					(prefix match)
-				</Typography.Text>
-			</span>
+			<span className={styles.fieldLabel}>Model name patterns</span>
 			<div className={styles.patternBox}>
 				{patterns.length > 0 && (
 					<div className={styles.patternChips}>
@@ -53,7 +48,7 @@ function PatternEditor({
 								color="secondary"
 								variant="outlined"
 							>
-								{pattern}*
+								{pattern}
 								{!isReadOnly && (
 									<button
 										type="button"
@@ -95,8 +90,9 @@ function PatternEditor({
 				)}
 			</div>
 			<Typography.Text as="p" size="small" color="muted">
-				Each pattern uses <strong>prefix matching</strong> against{' '}
-				<code>gen_ai.request.model</code>.
+				A pattern matches <code>gen_ai.request.model</code> exactly, plus its dated
+				or platform variants such as <code>-20260921</code>, <code>-latest</code> or{' '}
+				<code>@20260921</code>. End it with <code>*</code> to match any suffix.
 			</Typography.Text>
 		</div>
 	);

frontend/src/container/LiveLogs/LiveLogsContainer/index.tsx

@@ -2,7 +2,6 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useAppLocation } from 'lib/router/useAppLocation';
 import { Switch } from '@signozhq/ui/switch';
 import { Typography } from '@signozhq/ui/typography';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import FieldsSelector from 'components/FieldsSelector';
 import LogsFormatOptionsMenu from 'components/LogsFormatOptionsMenu/LogsFormatOptionsMenu';
 import { MAX_LOGS_LIST_SIZE } from 'constants/liveTail';
@@ -55,7 +54,7 @@ function LiveLogsContainer({
 
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator: listQuery?.aggregateOperator || StringOperators.NOOP,
 	});
 

frontend/src/container/LiveLogs/LiveLogsList/index.tsx

@@ -5,7 +5,6 @@ import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
 import { toast } from '@signozhq/ui/sonner';
 import { Card } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import LogDetail from 'components/LogDetail';
 import { VIEW_TYPES } from 'components/LogDetail/constants';
 import ListLogView from 'components/Logs/ListLogView';
@@ -31,7 +30,7 @@ import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useEventSource } from 'providers/EventSource';
 // interfaces
 import { ILog } from 'types/api/logs/log';
-import { StringOperators } from 'types/common/queryBuilder';
+import { DataSource, StringOperators } from 'types/common/queryBuilder';
 
 import loadingPlaneUrl from '@/assets/Icons/loading-plane.gif';
 import { getAbsoluteUrl } from 'utils/basePath';
@@ -69,7 +68,7 @@ function LiveLogsList({
 
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator: StringOperators.NOOP,
 	});
 

frontend/src/container/LogDetailedView/ContextView/ContextLogRenderer.tsx

@@ -1,7 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Virtuoso } from 'react-virtuoso';
 import { Button, Skeleton } from 'antd';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import RawLogView from 'components/Logs/RawLogView';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -17,7 +16,7 @@ import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { ILog } from 'types/api/logs/log';
 import { Query, TagFilter } from 'types/api/queryBuilder/queryBuilderData';
-import { StringOperators } from 'types/common/queryBuilder';
+import { DataSource, StringOperators } from 'types/common/queryBuilder';
 import { withBasePath } from 'utils/basePath';
 
 import { useContextLogData } from './useContextLogData';
@@ -46,7 +45,7 @@ function ContextLogRenderer({
 
 	const { options } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator: listQuery?.aggregateOperator || StringOperators.NOOP,
 	});
 

frontend/src/container/LogsExplorerList/index.tsx

@@ -5,7 +5,6 @@ import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
 import { toast } from '@signozhq/ui/sonner';
 import { Card } from 'antd';
 import logEvent from 'api/common/logEvent';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
 import LogDetail from 'components/LogDetail';
 import { VIEW_TYPES } from 'components/LogDetail/constants';
@@ -78,7 +77,7 @@ function LogsExplorerList({
 
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator:
 			currentStagedQueryData?.aggregateOperator || StringOperators.NOOP,
 	});

frontend/src/container/LogsExplorerViews/LogsActionsContainer.tsx

@@ -1,7 +1,6 @@
 import { ReactNode, useState } from 'react';
 import { Switch } from '@signozhq/ui/switch';
 import { Typography } from '@signozhq/ui/typography';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
 import FieldsSelector from 'components/FieldsSelector';
 import LogsFormatOptionsMenu from 'components/LogsFormatOptionsMenu/LogsFormatOptionsMenu';
@@ -29,7 +28,7 @@ function LogsActionsContainer({
 }): JSX.Element {
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 		aggregateOperator: listQuery?.aggregateOperator || StringOperators.NOOP,
 	});
 

frontend/src/container/OptionsMenu/__test__/useOptionsMenu.test.ts

@@ -1,20 +1,11 @@
-import { createElement, ReactNode } from 'react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-import type { NotificationInstance } from 'antd/es/notification/interface';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { useQueries } from 'react-query';
+import { renderHook } from '@testing-library/react';
 import { useGetQueryKeySuggestions } from 'hooks/querySuggestions/useGetQueryKeySuggestions';
 import { useNotifications } from 'hooks/useNotifications';
 import useUrlQueryData from 'hooks/useUrlQueryData';
 import { usePreferenceContext } from 'providers/preferences/context/PreferenceContextProvider';
-import {
-	FormattingOptions,
-	PreferenceContextValue,
-	PreferenceSlice,
-} from 'providers/preferences/types';
-import { renderHook } from 'tests/test-utils';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
+import { DataSource } from 'types/common/queryBuilder';
 
-import { FontSize } from '../types';
 import useOptionsMenu from '../useOptionsMenu';
 
 // Mock all dependencies
@@ -22,118 +13,104 @@ jest.mock('hooks/useNotifications');
 jest.mock('providers/preferences/context/PreferenceContextProvider');
 jest.mock('hooks/useUrlQueryData');
 jest.mock('hooks/querySuggestions/useGetQueryKeySuggestions');
-
-const mockUseNotifications = jest.mocked(useNotifications);
-const mockUsePreferenceContext = jest.mocked(usePreferenceContext);
-const mockUseUrlQueryData = jest.mocked(useUrlQueryData);
-const mockUseGetQueryKeySuggestions = jest.mocked(useGetQueryKeySuggestions);
-
-type KeySuggestionsResult = ReturnType<typeof useGetQueryKeySuggestions>;
-
-// The hook reads only `data.data.data.keys` and `isFetching`.
-const keySuggestions = (
-	attributeKeys: Record<string, string>[],
-): KeySuggestionsResult =>
-	({
-		data: { data: { data: { complete: true, keys: { attributeKeys } } } },
-		isFetching: false,
-	}) as unknown as KeySuggestionsResult;
-
-const wrapper = ({ children }: { children: ReactNode }): JSX.Element =>
-	createElement(QueryClientProvider, { client: new QueryClient() }, children);
-
-const toIds = (columns: TelemetryFieldKey[]): string[] =>
-	columns.map((column) => `${column.fieldContext}:${column.name}`);
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
+	useQueries: jest.fn(),
+}));
 
 describe('useOptionsMenu', () => {
-	const mockNotifications = {
-		error: jest.fn() as jest.MockedFunction<NotificationInstance['error']>,
-		success: jest.fn() as jest.MockedFunction<NotificationInstance['success']>,
-	} as Partial<NotificationInstance> as NotificationInstance;
-	const mockUpdateColumns = jest.fn() as jest.MockedFunction<
-		PreferenceSlice['updateColumns']
-	>;
-	const mockUpdateFormatting = jest.fn() as jest.MockedFunction<
-		PreferenceSlice['updateFormatting']
-	>;
-	const mockRedirectWithQuery = jest.fn() as jest.MockedFunction<
-		(newQueryData: unknown) => void
-	>;
-
-	const slice = (
-		columns: TelemetryFieldKey[],
-		formatting: FormattingOptions,
-	): PreferenceSlice => ({
-		preferences: { columns, formatting },
-		loading: false,
-		error: null,
-		updateColumns: mockUpdateColumns,
-		updateFormatting: mockUpdateFormatting,
-	});
-
-	const rawFormatting: FormattingOptions = {
-		format: 'raw',
-		maxLines: 1,
-		fontSize: FontSize.SMALL,
-	};
+	const mockNotifications = { error: jest.fn(), success: jest.fn() };
+	const mockUpdateColumns = jest.fn();
+	const mockUpdateFormatting = jest.fn();
+	const mockRedirectWithQuery = jest.fn();
 
 	beforeEach(() => {
 		jest.clearAllMocks();
 
-		mockUseNotifications.mockReturnValue({
+		(useNotifications as jest.Mock).mockReturnValue({
 			notifications: mockNotifications,
 		});
 
-		mockUsePreferenceContext.mockReturnValue({
-			[SavedviewtypesSourceDTO.traces]: slice([], rawFormatting),
-			[SavedviewtypesSourceDTO.logs]: slice([], rawFormatting),
-		} satisfies PreferenceContextValue);
+		(usePreferenceContext as jest.Mock).mockReturnValue({
+			traces: {
+				preferences: {
+					columns: [],
+					formatting: {
+						format: 'raw',
+						maxLines: 1,
+						fontSize: 'small',
+					},
+				},
+				updateColumns: mockUpdateColumns,
+				updateFormatting: mockUpdateFormatting,
+			},
+			logs: {
+				preferences: {
+					columns: [],
+					formatting: {
+						format: 'raw',
+						maxLines: 1,
+						fontSize: 'small',
+					},
+				},
+				updateColumns: mockUpdateColumns,
+				updateFormatting: mockUpdateFormatting,
+			},
+		});
 
-		mockUseUrlQueryData.mockReturnValue({
+		(useUrlQueryData as jest.Mock).mockReturnValue({
 			query: null,
-			queryData: undefined,
 			redirectWithQuery: mockRedirectWithQuery,
 		});
+
+		(useQueries as jest.Mock).mockReturnValue([]);
 	});
 
-	it('does not show isRoot or isEntryPoint in column options when sourcePage is traces', () => {
+	it('does not show isRoot or isEntryPoint in column options when dataSource is TRACES', () => {
 		// Mock the query key suggestions to return data including isRoot and isEntryPoint
-		mockUseGetQueryKeySuggestions.mockReturnValue(
-			keySuggestions([
-				{
-					name: 'isRoot',
-					signal: 'traces',
-					fieldDataType: 'bool',
-					fieldContext: '',
+		(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+			data: {
+				data: {
+					data: {
+						keys: {
+							attributeKeys: [
+								{
+									name: 'isRoot',
+									signal: 'traces',
+									fieldDataType: 'bool',
+									fieldContext: '',
+								},
+								{
+									name: 'isEntryPoint',
+									signal: 'traces',
+									fieldDataType: 'bool',
+									fieldContext: '',
+								},
+								{
+									name: 'duration',
+									signal: 'traces',
+									fieldDataType: 'float64',
+									fieldContext: '',
+								},
+								{
+									name: 'serviceName',
+									signal: 'traces',
+									fieldDataType: 'string',
+									fieldContext: '',
+								},
+							],
+						},
+					},
 				},
-				{
-					name: 'isEntryPoint',
-					signal: 'traces',
-					fieldDataType: 'bool',
-					fieldContext: '',
-				},
-				{
-					name: 'duration',
-					signal: 'traces',
-					fieldDataType: 'float64',
-					fieldContext: '',
-				},
-				{
-					name: 'serviceName',
-					signal: 'traces',
-					fieldDataType: 'string',
-					fieldContext: '',
-				},
-			]),
-		);
+			},
+			isFetching: false,
+		});
 
-		const { result } = renderHook(
-			() =>
-				useOptionsMenu({
-					sourcePage: SavedviewtypesSourceDTO.traces,
-					aggregateOperator: 'count',
-				}),
-			{ wrapper },
+		const { result } = renderHook(() =>
+			useOptionsMenu({
+				dataSource: DataSource.TRACES,
+				aggregateOperator: 'count',
+			}),
 		);
 
 		// Get the column options from the config
@@ -150,38 +127,98 @@ describe('useOptionsMenu', () => {
 		expect(optionNames).toContain('serviceName');
 	});
 
-	it('shows body in column options when sourcePage is logs', () => {
+	it('does not show body in column options when dataSource is METRICS', () => {
 		// Mock the query key suggestions to return data including body
-		mockUseGetQueryKeySuggestions.mockReturnValue(
-			keySuggestions([
-				{
-					name: 'body',
-					signal: 'logs',
-					fieldDataType: 'string',
-					fieldContext: '',
+		(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+			data: {
+				data: {
+					data: {
+						keys: {
+							attributeKeys: [
+								{
+									name: 'body',
+									signal: 'logs',
+									fieldDataType: 'string',
+									fieldContext: '',
+								},
+								{
+									name: 'status',
+									signal: 'metrics',
+									fieldDataType: 'int64',
+									fieldContext: '',
+								},
+								{
+									name: 'value',
+									signal: 'metrics',
+									fieldDataType: 'float64',
+									fieldContext: '',
+								},
+							],
+						},
+					},
 				},
-				{
-					name: 'level',
-					signal: 'logs',
-					fieldDataType: 'string',
-					fieldContext: '',
-				},
-				{
-					name: 'timestamp',
-					signal: 'logs',
-					fieldDataType: 'int64',
-					fieldContext: '',
-				},
-			]),
+			},
+			isFetching: false,
+		});
+
+		const { result } = renderHook(() =>
+			useOptionsMenu({
+				dataSource: DataSource.METRICS,
+				aggregateOperator: 'count',
+			}),
 		);
 
-		const { result } = renderHook(
-			() =>
-				useOptionsMenu({
-					sourcePage: SavedviewtypesSourceDTO.logs,
-					aggregateOperator: 'count',
-				}),
-			{ wrapper },
+		// Get the column options from the config
+		const columnOptions = result.current.config.addColumn?.options ?? [];
+		const optionNames = columnOptions.map((option) => option.label);
+
+		// body should NOT be in the options
+		expect(optionNames).not.toContain('body');
+
+		// Other attributes should be present
+		expect(optionNames).toContain('status');
+		expect(optionNames).toContain('value');
+	});
+
+	it('does not show body in column options when dataSource is LOGS', () => {
+		// Mock the query key suggestions to return data including body
+		(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+			data: {
+				data: {
+					data: {
+						keys: {
+							attributeKeys: [
+								{
+									name: 'body',
+									signal: 'logs',
+									fieldDataType: 'string',
+									fieldContext: '',
+								},
+								{
+									name: 'level',
+									signal: 'logs',
+									fieldDataType: 'string',
+									fieldContext: '',
+								},
+								{
+									name: 'timestamp',
+									signal: 'logs',
+									fieldDataType: 'int64',
+									fieldContext: '',
+								},
+							],
+						},
+					},
+				},
+			},
+			isFetching: false,
+		});
+
+		const { result } = renderHook(() =>
+			useOptionsMenu({
+				dataSource: DataSource.LOGS,
+				aggregateOperator: 'count',
+			}),
 		);
 
 		// Get the column options from the config
@@ -197,15 +234,15 @@ describe('useOptionsMenu', () => {
 	});
 
 	describe('reorderSelectColumns / handleRemoveSelectedColumn — composite ID lookup', () => {
-		const baseFormatting: FormattingOptions = {
+		const baseFormatting = {
 			format: 'table',
 			maxLines: 1,
-			fontSize: FontSize.SMALL,
+			fontSize: 'small',
 		};
 
 		// Two entries share the same `name` but differ in `fieldContext` — the
 		// exact case composite IDs are meant to disambiguate.
-		const seedColumns: TelemetryFieldKey[] = [
+		const seedColumns = [
 			{
 				name: 'body',
 				fieldContext: 'log',
@@ -227,26 +264,36 @@ describe('useOptionsMenu', () => {
 			{
 				name: 'timestamp',
 				fieldContext: 'log',
+				fieldDataType: '',
 				signal: 'logs',
 			},
 		];
 
 		beforeEach(() => {
-			mockUseGetQueryKeySuggestions.mockReturnValue(keySuggestions([]));
-			mockUsePreferenceContext.mockReturnValue({
-				[SavedviewtypesSourceDTO.traces]: slice([], baseFormatting),
-				[SavedviewtypesSourceDTO.logs]: slice(seedColumns, baseFormatting),
-			} satisfies PreferenceContextValue);
+			(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+				data: { data: { data: { keys: {} } } },
+				isFetching: false,
+			});
+			(usePreferenceContext as jest.Mock).mockReturnValue({
+				traces: {
+					preferences: { columns: [], formatting: baseFormatting },
+					updateColumns: mockUpdateColumns,
+					updateFormatting: mockUpdateFormatting,
+				},
+				logs: {
+					preferences: { columns: seedColumns, formatting: baseFormatting },
+					updateColumns: mockUpdateColumns,
+					updateFormatting: mockUpdateFormatting,
+				},
+			});
 		});
 
 		it('reorders by composite IDs — preserves both same-name variants distinctly', () => {
-			const { result } = renderHook(
-				() =>
-					useOptionsMenu({
-						sourcePage: SavedviewtypesSourceDTO.logs,
-						aggregateOperator: 'count',
-					}),
-				{ wrapper },
+			const { result } = renderHook(() =>
+				useOptionsMenu({
+					dataSource: DataSource.LOGS,
+					aggregateOperator: 'count',
+				}),
 			);
 
 			// New order: [attribute:service.name, log:body, resource:service.name, log:timestamp]
@@ -259,7 +306,12 @@ describe('useOptionsMenu', () => {
 
 			expect(mockUpdateColumns).toHaveBeenCalledTimes(1);
 			const reordered = mockUpdateColumns.mock.calls[0][0];
-			expect(toIds(reordered)).toStrictEqual([
+			expect(
+				reordered.map(
+					(c: { name: string; fieldContext: string }) =>
+						`${c.fieldContext}:${c.name}`,
+				),
+			).toStrictEqual([
 				'attribute:service.name',
 				'log:body',
 				'resource:service.name',
@@ -268,13 +320,11 @@ describe('useOptionsMenu', () => {
 		});
 
 		it('reorder ignores ids that are not columns (e.g. state-indicator) and skips unknown ids', () => {
-			const { result } = renderHook(
-				() =>
-					useOptionsMenu({
-						sourcePage: SavedviewtypesSourceDTO.logs,
-						aggregateOperator: 'count',
-					}),
-				{ wrapper },
+			const { result } = renderHook(() =>
+				useOptionsMenu({
+					dataSource: DataSource.LOGS,
+					aggregateOperator: 'count',
+				}),
 			);
 
 			result.current.config.addColumn?.onReorder([
@@ -288,7 +338,12 @@ describe('useOptionsMenu', () => {
 
 			const reordered = mockUpdateColumns.mock.calls[0][0];
 			// state-indicator + unknown.composite filtered; rest preserved in given order.
-			expect(toIds(reordered)).toStrictEqual([
+			expect(
+				reordered.map(
+					(c: { name: string; fieldContext: string }) =>
+						`${c.fieldContext}:${c.name}`,
+				),
+			).toStrictEqual([
 				'log:timestamp',
 				'log:body',
 				'resource:service.name',
@@ -297,13 +352,11 @@ describe('useOptionsMenu', () => {
 		});
 
 		it('removes only the variant whose composite ID matches', () => {
-			const { result } = renderHook(
-				() =>
-					useOptionsMenu({
-						sourcePage: SavedviewtypesSourceDTO.logs,
-						aggregateOperator: 'count',
-					}),
-				{ wrapper },
+			const { result } = renderHook(() =>
+				useOptionsMenu({
+					dataSource: DataSource.LOGS,
+					aggregateOperator: 'count',
+				}),
 			);
 
 			// Removing 'resource:service.name' should drop ONLY the resource variant.
@@ -311,21 +364,20 @@ describe('useOptionsMenu', () => {
 
 			expect(mockUpdateColumns).toHaveBeenCalledTimes(1);
 			const remaining = mockUpdateColumns.mock.calls[0][0];
-			expect(toIds(remaining)).toStrictEqual([
-				'log:body',
-				'attribute:service.name',
-				'log:timestamp',
-			]);
+			expect(
+				remaining.map(
+					(c: { name: string; fieldContext: string }) =>
+						`${c.fieldContext}:${c.name}`,
+				),
+			).toStrictEqual(['log:body', 'attribute:service.name', 'log:timestamp']);
 		});
 
 		it('removing by a non-matching composite ID is a no-op (filter returns the full list)', () => {
-			const { result } = renderHook(
-				() =>
-					useOptionsMenu({
-						sourcePage: SavedviewtypesSourceDTO.logs,
-						aggregateOperator: 'count',
-					}),
-				{ wrapper },
+			const { result } = renderHook(() =>
+				useOptionsMenu({
+					dataSource: DataSource.LOGS,
+					aggregateOperator: 'count',
+				}),
 			);
 
 			result.current.config.addColumn?.onRemove('unknown.composite');
@@ -338,34 +390,35 @@ describe('useOptionsMenu', () => {
 
 	describe('fieldsSelector.value drops legacy columns without a name', () => {
 		it('excludes entries missing name while keeping valid columns', () => {
-			mockUseGetQueryKeySuggestions.mockReturnValue(keySuggestions([]));
-			mockUsePreferenceContext.mockReturnValue({
-				[SavedviewtypesSourceDTO.traces]: slice(
-					[
-						{ name: 'body', fieldContext: 'log' },
-						// A legacy stored column: `key` only, no `name`.
-						{
-							key: 'legacy-key-no-name',
-							fieldContext: 'log',
-						} as unknown as TelemetryFieldKey,
-						{ name: 'timestamp', fieldContext: 'log' },
-					],
-					{
-						format: 'table',
-						maxLines: 1,
-						fontSize: FontSize.SMALL,
+			(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+				data: { data: { data: { keys: {} } } },
+				isFetching: false,
+			});
+			(usePreferenceContext as jest.Mock).mockReturnValue({
+				traces: {
+					preferences: {
+						columns: [
+							{ name: 'body', fieldContext: 'log' },
+							{ key: 'legacy-key-no-name', fieldContext: 'log' },
+							{ name: 'timestamp', fieldContext: 'log' },
+						],
+						formatting: { format: 'table', maxLines: 1, fontSize: 'small' },
 					},
-				),
-				[SavedviewtypesSourceDTO.logs]: slice([], {}),
-			} satisfies PreferenceContextValue);
+					updateColumns: mockUpdateColumns,
+					updateFormatting: mockUpdateFormatting,
+				},
+				logs: {
+					preferences: { columns: [], formatting: {} },
+					updateColumns: mockUpdateColumns,
+					updateFormatting: mockUpdateFormatting,
+				},
+			});
 
-			const { result } = renderHook(
-				() =>
-					useOptionsMenu({
-						sourcePage: SavedviewtypesSourceDTO.traces,
-						aggregateOperator: 'count',
-					}),
-				{ wrapper },
+			const { result } = renderHook(() =>
+				useOptionsMenu({
+					dataSource: DataSource.TRACES,
+					aggregateOperator: 'count',
+				}),
 			);
 
 			const fields = result.current.config.fieldsSelector?.value ?? [];

frontend/src/container/OptionsMenu/constants.ts

@@ -1,6 +1,4 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { TelemetryFieldKey } from 'api/v5/v5';
-import { PREFERENCE_SOURCE_PAGES } from 'providers/preferences/constants';
 import { DataSource } from 'types/common/queryBuilder';
 
 import { FontSize, OptionsQuery } from './types';
@@ -15,14 +13,6 @@ export const defaultOptionsQuery: OptionsQuery = {
 	fontSize: FontSize.SMALL,
 };
 
-export const SOURCE_PAGE_SIGNAL: Record<
-	(typeof PREFERENCE_SOURCE_PAGES)[number],
-	DataSource
-> = {
-	[SavedviewtypesSourceDTO.logs]: DataSource.LOGS,
-	[SavedviewtypesSourceDTO.traces]: DataSource.TRACES,
-};
-
 export const EXCLUDED_COLUMNS: Record<DataSource, string[]> = {
 	[DataSource.TRACES]: ['body', 'isRoot', 'isEntryPoint'],
 	[DataSource.METRICS]: ['body'],

frontend/src/container/OptionsMenu/useOptionsMenu.ts

@@ -1,7 +1,6 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useQueries } from 'react-query';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { AxiosResponse } from 'axios';
@@ -12,7 +11,6 @@ import useUrlQueryData from 'hooks/useUrlQueryData';
 import { has } from 'lodash-es';
 import { AllTraceFilterKeyValue } from 'constants/traceFilterKeys';
 import { usePreferenceContext } from 'providers/preferences/context/PreferenceContextProvider';
-import { PreferenceSourcePage } from 'providers/preferences/types';
 import {
 	QueryKeyRequestProps,
 	QueryKeySuggestionsResponseProps,
@@ -22,13 +20,13 @@ import {
 	FieldDataType,
 	SignalType,
 } from 'types/api/v5/queryRange';
+import { DataSource } from 'types/common/queryBuilder';
 
 import {
 	defaultLogsSelectedColumns,
 	defaultOptionsQuery,
 	defaultTraceSelectedColumns,
 	EXCLUDED_COLUMNS,
-	SOURCE_PAGE_SIGNAL,
 	URL_OPTIONS,
 } from './constants';
 import {
@@ -42,7 +40,7 @@ import { buildCompositeKey, getOptionsFromKeys } from './utils';
 
 interface UseOptionsMenuProps {
 	storageKey?: string;
-	sourcePage: PreferenceSourcePage;
+	dataSource: DataSource;
 	aggregateOperator?: string;
 	initialOptions?: InitialOptions;
 }
@@ -54,14 +52,15 @@ interface UseOptionsMenu {
 }
 
 const useOptionsMenu = ({
-	sourcePage,
+	dataSource,
+	// aggregateOperator,
 	initialOptions = {},
 }: UseOptionsMenuProps): UseOptionsMenu => {
-	const signal = SOURCE_PAGE_SIGNAL[sourcePage];
 	const { notifications } = useNotifications();
+	const prefCtx = usePreferenceContext();
 	// TODO: send null to updateColumns and updateFormatting if dataSource is not logs or traces
-	const { preferences, updateColumns, updateFormatting } =
-		usePreferenceContext()[sourcePage];
+	const slice = dataSource === DataSource.TRACES ? prefCtx.traces : prefCtx.logs;
+	const { preferences, updateColumns, updateFormatting } = slice;
 
 	const [searchText, setSearchText] = useState<string>('');
 	const [isFocused, setIsFocused] = useState<boolean>(false);
@@ -69,10 +68,10 @@ const useOptionsMenu = ({
 
 	const initialQueryParamsV5: QueryKeyRequestProps = useMemo(
 		() => ({
-			signal,
+			signal: dataSource,
 			searchText: '',
 		}),
-		[signal],
+		[dataSource],
 	);
 
 	const { query: optionsQuery, redirectWithQuery: redirectWithOptionsData } =
@@ -128,7 +127,7 @@ const useOptionsMenu = ({
 			?.map((column) => attributesData.find(({ name }) => name === column))
 			.filter((e) => !!e) || []) as TelemetryFieldKey[];
 
-		if (sourcePage === SavedviewtypesSourceDTO.traces) {
+		if (dataSource === DataSource.TRACES) {
 			initialSelected = initialSelected
 				?.map((col) => {
 					if (col && Object.keys(AllTraceFilterKeyValue).includes(col?.name)) {
@@ -158,7 +157,7 @@ const useOptionsMenu = ({
 		isFetchedInitialAttributes,
 		initialOptions?.selectColumns,
 		initialAttributesResult,
-		sourcePage,
+		dataSource,
 	]);
 
 	const {
@@ -196,7 +195,7 @@ const useOptionsMenu = ({
 				fieldDataType: e.fieldDataType,
 			}));
 		}
-		if (sourcePage === SavedviewtypesSourceDTO.traces) {
+		if (dataSource === DataSource.TRACES) {
 			return defaultTraceSelectedColumns.map((e) => ({
 				...e,
 				name: e.name,
@@ -204,16 +203,16 @@ const useOptionsMenu = ({
 		}
 
 		return [];
-	}, [sourcePage, searchedAttributesDataV5?.data.data.keys]);
+	}, [dataSource, searchedAttributesDataV5?.data.data.keys]);
 
 	const initialOptionsQuery: OptionsQuery = useMemo(() => {
 		let defaultColumns: TelemetryFieldKey[] = defaultOptionsQuery.selectColumns;
-		if (sourcePage === SavedviewtypesSourceDTO.traces) {
+		if (dataSource === DataSource.TRACES) {
 			defaultColumns = defaultTraceSelectedColumns.map((e) => ({
 				...e,
 				name: e.name,
 			}));
-		} else if (sourcePage === SavedviewtypesSourceDTO.logs) {
+		} else if (dataSource === DataSource.LOGS) {
 			// eslint-disable-next-line sonarjs/no-identical-functions
 			defaultColumns = defaultLogsSelectedColumns.map((e) => ({
 				...e,
@@ -233,7 +232,7 @@ const useOptionsMenu = ({
 			...initialOptions,
 			selectColumns: finalSelectColumns,
 		};
-	}, [sourcePage, initialOptions, initialSelectedColumns]);
+	}, [dataSource, initialOptions, initialSelectedColumns]);
 
 	const selectedColumnKeys = useMemo(
 		() => preferences?.columns?.map(({ name }) => name) || [],
@@ -242,7 +241,7 @@ const useOptionsMenu = ({
 
 	const optionsFromAttributeKeys = useMemo(() => {
 		const filteredAttributeKeys = searchedAttributeKeys.filter((item) => {
-			const exclusions = EXCLUDED_COLUMNS[signal];
+			const exclusions = EXCLUDED_COLUMNS[dataSource];
 			if (exclusions) {
 				return !exclusions.includes(item.name);
 			}
@@ -250,7 +249,7 @@ const useOptionsMenu = ({
 		});
 
 		return getOptionsFromKeys(filteredAttributeKeys, selectedColumnKeys);
-	}, [signal, searchedAttributeKeys, selectedColumnKeys]);
+	}, [dataSource, searchedAttributeKeys, selectedColumnKeys]);
 
 	const handleRedirectWithOptionsData = useCallback(
 		(newQueryData: OptionsQuery) => {
@@ -286,10 +285,7 @@ const useOptionsMenu = ({
 					buildCompositeKey(f.name, f.fieldContext, f.fieldDataType) !== columnKey,
 			);
 
-			if (
-				!newSelectedColumns?.length &&
-				sourcePage !== SavedviewtypesSourceDTO.logs
-			) {
+			if (!newSelectedColumns?.length && dataSource !== DataSource.LOGS) {
 				notifications.error({
 					message: 'There must be at least one selected column',
 				});
@@ -298,7 +294,7 @@ const useOptionsMenu = ({
 
 			updateColumns(newSelectedColumns || []);
 		},
-		[sourcePage, notifications, preferences, updateColumns],
+		[dataSource, notifications, preferences, updateColumns],
 	);
 
 	const handleFormatChange = useCallback(

frontend/src/container/SavedViews/__tests__/SavedViewsHeader.columns.test.tsx

@@ -1,9 +1,10 @@
 import { useState } from 'react';
+import { act, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { Button } from '@signozhq/ui/button';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import ROUTES from 'constants/routes';
 import { usePreferenceContext } from 'providers/preferences/context/PreferenceContextProvider';
-import { act, screen, userEvent, waitFor } from 'tests/test-utils';
 
 import SavedViewsHeader from '../SavedViewsHeader';
 import { mockSavedViewsApi } from './savedViewsApiMock';
@@ -27,7 +28,7 @@ const errors = {
 };
 
 function Harness(): JSX.Element {
-	const traces = usePreferenceContext()[SavedviewtypesSourceDTO.traces];
+	const { traces } = usePreferenceContext();
 	const [headerKey, setHeaderKey] = useState(0);
 	const columns = traces.preferences?.columns ?? [];
 
@@ -36,7 +37,7 @@ function Harness(): JSX.Element {
 			<SavedViewsHeader
 				key={headerKey}
 				source={SavedviewtypesSourceDTO.traces}
-				onOpenViews={jest.fn() as jest.MockedFunction<() => void>}
+				onOpenViews={jest.fn()}
 			/>
 			<span data-testid="columns">
 				{columns.map((column) => column.name).join(',')}
@@ -83,14 +84,13 @@ describe('SavedViewsHeader columns', () => {
 	});
 
 	it('keeps edited columns when the view is fetched again', async () => {
-		const user = userEvent.setup();
 		mockSavedViewsApi([errors]);
 		await openView();
 
-		await user.click(screen.getByTestId('add-column'));
+		await userEvent.click(screen.getByTestId('add-column'));
 		await waitFor(() => expect(isDirty()).toBe(true));
 
-		await user.click(screen.getByTestId('remount-header'));
+		await userEvent.click(screen.getByTestId('remount-header'));
 		await act(() => new Promise((resolve) => setTimeout(resolve, 200)));
 
 		expect(columnsText()).toBe('service.name,name,extra-2');
@@ -98,37 +98,35 @@ describe('SavedViewsHeader columns', () => {
 	});
 
 	it('discard puts the saved columns back', async () => {
-		const user = userEvent.setup();
 		mockSavedViewsApi([errors]);
 		await openView();
 
-		await user.click(screen.getByTestId('add-column'));
+		await userEvent.click(screen.getByTestId('add-column'));
 		await waitFor(() => expect(isDirty()).toBe(true));
 
-		await user.click(screen.getByTestId('saved-views-discard'));
+		await userEvent.click(screen.getByTestId('saved-views-discard'));
 
 		await waitFor(() => expect(columnsText()).toBe('service.name,name'));
 		expect(isDirty()).toBe(false);
 	});
 
 	it('discard after an update goes back to the updated columns', async () => {
-		const user = userEvent.setup();
 		mockSavedViewsApi([errors]);
 		await openView();
 
-		await user.click(screen.getByTestId('add-column'));
+		await userEvent.click(screen.getByTestId('add-column'));
 		await waitFor(() => expect(isDirty()).toBe(true));
-		await user.click(screen.getByTestId('saved-views-save-changes'));
+		await userEvent.click(screen.getByTestId('saved-views-save-changes'));
 		const update = await screen.findByTestId(
 			'saved-views-save-changes-item-update',
 		);
 		await waitFor(() => expectRowUsable(update), MENU_CHECK_TIMEOUT);
-		await user.click(update);
+		await userEvent.click(update);
 		await waitFor(() => expect(isDirty()).toBe(false));
 
-		await user.click(screen.getByTestId('add-column'));
+		await userEvent.click(screen.getByTestId('add-column'));
 		await waitFor(() => expect(isDirty()).toBe(true));
-		await user.click(screen.getByTestId('saved-views-discard'));
+		await userEvent.click(screen.getByTestId('saved-views-discard'));
 
 		await waitFor(() => expect(columnsText()).toBe('service.name,name,extra-2'));
 		expect(isDirty()).toBe(false);

frontend/src/container/SavedViews/constants.ts

@@ -1,16 +1,28 @@
 import { Copy, Link, PenLine, Trash2 } from '@signozhq/icons';
-import { SavedviewtypesSchemaVersionDTO } from 'api/generated/services/sigNoz.schemas';
+import {
+	SavedviewtypesSchemaVersionDTO,
+	SavedviewtypesSourceDTO,
+} from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import {
 	buildSavedViewDeletePermission,
 	buildSavedViewUpdatePermission,
 } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { SavedViewRowActionConfig, SaveViewModalMode } from './types';
 
 export const SAVED_VIEW_SCHEMA_VERSION = SavedviewtypesSchemaVersionDTO.v2;
 
+// Only the logs and traces explorers have columns and formatting to save.
+export const SAVED_VIEW_OPTIONS_DATA_SOURCE: Partial<
+	Record<SavedviewtypesSourceDTO, DataSource>
+> = {
+	[SavedviewtypesSourceDTO.logs]: DataSource.LOGS,
+	[SavedviewtypesSourceDTO.traces]: DataSource.TRACES,
+};
+
 // What selecting a view writes to the url, so clearing it removes exactly these.
 export const SAVED_VIEW_URL_PARAMS = [
 	QueryParams.viewKey,

frontend/src/container/SavedViews/hooks/useActiveSavedView.ts

@@ -8,9 +8,10 @@ import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
 import { buildSavedViewReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
 import { useAuthZ } from 'lib/authz/hooks/useAuthZ/useAuthZ';
-import { isPreferenceSourcePage } from 'providers/preferences/utils';
+import { DataSource } from 'types/common/queryBuilder';
 import { toAPIError } from 'utils/errorUtils';
 
+import { SAVED_VIEW_OPTIONS_DATA_SOURCE } from '../constants';
 import { UseActiveSavedViewResult } from '../types';
 import { hasUnsavedViewChanges } from '../utils/hasUnsavedViewChanges';
 
@@ -20,9 +21,9 @@ export function useActiveSavedView(
 	const { viewKey } = useGetSavedViewParams();
 	const { stagedQuery, panelType } = useQueryBuilder();
 
-	const hasOptions = isPreferenceSourcePage(source);
+	const optionsDataSource = SAVED_VIEW_OPTIONS_DATA_SOURCE[source];
 	const { options } = useOptionsMenu({
-		sourcePage: hasOptions ? source : SavedviewtypesSourceDTO.logs,
+		dataSource: optionsDataSource ?? DataSource.LOGS,
 	});
 
 	const { isLoading: isCheckingRead, deniedPermissions } = useAuthZ(
@@ -60,19 +61,17 @@ export function useActiveSavedView(
 		}
 		return hasUnsavedViewChanges({
 			view,
-			source,
 			stagedQuery,
 			panelType: panelType ?? PANEL_TYPES.LIST,
-			options: hasOptions ? options : undefined,
+			options: optionsDataSource ? options : undefined,
 		});
 	}, [
 		view,
-		source,
 		isError,
 		isStagedQueryCurrent,
 		stagedQuery,
 		panelType,
-		hasOptions,
+		optionsDataSource,
 		options,
 	]);
 

frontend/src/container/SavedViews/hooks/useSavedViewActions.ts

@@ -20,12 +20,13 @@ import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
 import { useHandleExplorerTabChange } from 'hooks/useHandleExplorerTabChange';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { useAppLocation } from 'lib/router/useAppLocation';
-import { usePreferenceSlice } from 'providers/preferences/context/usePreferenceSlice';
-import { isPreferenceSourcePage } from 'providers/preferences/utils';
+import { usePreferenceContext } from 'providers/preferences/context/PreferenceContextProvider';
+import { DataSource } from 'types/common/queryBuilder';
 import { toAPIError } from 'utils/errorUtils';
 import { getUnstableCurrentSearchParams } from 'utils/getUnstableCurrentSearchParams';
 
 import {
+	SAVED_VIEW_OPTIONS_DATA_SOURCE,
 	SAVED_VIEW_SCHEMA_VERSION,
 	SAVED_VIEW_TOAST_POSITION,
 	SAVED_VIEW_URL_PARAMS,
@@ -59,11 +60,15 @@ export function useSavedViewActions(
 	const { viewKey } = useGetSavedViewParams();
 	const logSavedViewEvent = useSavedViewLogEvent(source);
 
-	const hasOptions = isPreferenceSourcePage(source);
+	const optionsDataSource = SAVED_VIEW_OPTIONS_DATA_SOURCE[source];
 	const { options } = useOptionsMenu({
-		sourcePage: hasOptions ? source : SavedviewtypesSourceDTO.logs,
+		dataSource: optionsDataSource ?? DataSource.LOGS,
 	});
-	const preferenceSlice = usePreferenceSlice(source);
+	const preferences = usePreferenceContext();
+	const preferencesSlice =
+		optionsDataSource === DataSource.TRACES
+			? preferences.traces
+			: preferences.logs;
 
 	const { mutateAsync: createSavedView, isLoading: isCreating } =
 		useCreateSavedView();
@@ -81,10 +86,10 @@ export function useSavedViewActions(
 				query: stagedQuery ?? currentQuery,
 				panelType: panelType ?? PANEL_TYPES.LIST,
 				displayName,
-				options: hasOptions ? options : undefined,
+				options: optionsDataSource ? options : undefined,
 				color,
 			}),
-		[stagedQuery, currentQuery, panelType, hasOptions, options],
+		[stagedQuery, currentQuery, panelType, optionsDataSource, options],
 	);
 
 	const selectView = useCallback(
@@ -100,14 +105,14 @@ export function useSavedViewActions(
 
 	const revertView = useCallback(
 		(view: SavedviewtypesSavedViewDTO): void => {
-			if (preferenceSlice) {
+			if (optionsDataSource) {
 				const { columns, formatting } = getViewColumnsAndFormatting(
 					view.spec,
-					source,
+					optionsDataSource,
 				);
-				preferenceSlice.updateColumns(columns);
+				preferencesSlice.updateColumns(columns);
 				if (formatting) {
-					preferenceSlice.updateFormatting(formatting);
+					preferencesSlice.updateFormatting(formatting);
 				}
 			}
 			selectView(view);
@@ -115,7 +120,7 @@ export function useSavedViewActions(
 				[SavedViewEventKeys.ViewId]: view.id,
 			});
 		},
-		[source, preferenceSlice, selectView, logSavedViewEvent],
+		[optionsDataSource, preferencesSlice, selectView, logSavedViewEvent],
 	);
 
 	// The query builder redirects only ever add params, so the url is rebuilt

frontend/src/container/SavedViews/types.ts

@@ -8,9 +8,12 @@ import {
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { OptionsQuery } from 'container/OptionsMenu/types';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { SavedViewCreatedFrom } from './events';
 
+export type SavedViewSourcePage = DataSource | 'meter';
+
 export type SavedViewOptions = Pick<
 	OptionsQuery,
 	'selectColumns' | 'format' | 'maxLines' | 'fontSize'
@@ -26,7 +29,6 @@ export interface ToSavedViewSpecArgs {
 
 export interface HasUnsavedViewChangesArgs {
 	view: SavedviewtypesSavedViewDTO;
-	source: SavedviewtypesSourceDTO;
 	stagedQuery: Query | null;
 	panelType: PANEL_TYPES;
 	options?: SavedViewOptions;

frontend/src/container/SavedViews/utils/__tests__/hasUnsavedViewChanges.test.ts

@@ -1,7 +1,6 @@
 import {
 	SavedviewtypesSavedViewDTO,
 	SavedviewtypesSavedViewSpecDTO,
-	SavedviewtypesSourceDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import {
 	initialQueriesMap,
@@ -119,7 +118,6 @@ describe('hasUnsavedViewChanges', () => {
 		expect(
 			hasUnsavedViewChanges({
 				view,
-				source: SavedviewtypesSourceDTO.traces,
 				stagedQuery: staged,
 				panelType: PANEL_TYPES.LIST,
 				options: { ...options, selectColumns: [columns[0]] },
@@ -139,7 +137,6 @@ describe('hasUnsavedViewChanges', () => {
 		expect(
 			hasUnsavedViewChanges({
 				view: bare,
-				source: SavedviewtypesSourceDTO.traces,
 				stagedQuery: stagedFrom(bare, DataSource.TRACES),
 				panelType: PANEL_TYPES.LIST,
 				options: { ...options, selectColumns: defaultTraceSelectedColumns },
@@ -164,7 +161,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: logsView,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: logsStaged,
 					panelType: PANEL_TYPES.LIST,
 					options: { selectColumns: shownColumns, ...formatting },
@@ -176,7 +172,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: logsView,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: logsStaged,
 					panelType: PANEL_TYPES.LIST,
 					options: { selectColumns: shownColumns, ...formatting, maxLines: 5 },
@@ -196,7 +191,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: bare,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: stagedFrom(bare, DataSource.LOGS),
 					panelType: PANEL_TYPES.LIST,
 					options: {
@@ -240,7 +234,6 @@ describe('hasUnsavedViewChanges', () => {
 		expect(
 			hasUnsavedViewChanges({
 				view: olderView,
-				source: SavedviewtypesSourceDTO.metrics,
 				stagedQuery: stagedFrom(olderView, DataSource.METRICS),
 				panelType: PANEL_TYPES.TIME_SERIES,
 			}),
@@ -288,7 +281,6 @@ describe('hasUnsavedViewChanges', () => {
 		expect(
 			hasUnsavedViewChanges({
 				view: storedView,
-				source: SavedviewtypesSourceDTO.metrics,
 				stagedQuery: stagedWithTag,
 				panelType: PANEL_TYPES.TIME_SERIES,
 			}),
@@ -328,7 +320,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: noOrder,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: stagedFrom(noOrder, DataSource.LOGS),
 					panelType: PANEL_TYPES.LIST,
 				}),
@@ -344,7 +335,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: noOrder,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: sorted,
 					panelType: PANEL_TYPES.LIST,
 				}),
@@ -354,7 +344,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: saved,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: stagedFrom(saved, DataSource.LOGS),
 					panelType: PANEL_TYPES.LIST,
 				}),
@@ -371,7 +360,6 @@ describe('hasUnsavedViewChanges', () => {
 			expect(
 				hasUnsavedViewChanges({
 					view: legacy,
-					source: SavedviewtypesSourceDTO.logs,
 					stagedQuery: stagedFrom(legacy, DataSource.LOGS),
 					panelType: PANEL_TYPES.LIST,
 				}),
@@ -383,7 +371,6 @@ describe('hasUnsavedViewChanges', () => {
 		expect(
 			hasUnsavedViewChanges({
 				view,
-				source: SavedviewtypesSourceDTO.traces,
 				stagedQuery: staged,
 				panelType: PANEL_TYPES.LIST,
 				options: { ...options, ...formatting, maxLines: 5 },

frontend/src/container/SavedViews/utils/__tests__/toSavedViewSource.test.ts

@@ -0,0 +1,17 @@
+import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { toSavedViewSource } from '../toSavedViewSource';
+
+describe('toSavedViewSource', () => {
+	it('maps every explorer source page to the v2 source', () => {
+		expect(toSavedViewSource(DataSource.LOGS)).toBe(SavedviewtypesSourceDTO.logs);
+		expect(toSavedViewSource(DataSource.TRACES)).toBe(
+			SavedviewtypesSourceDTO.traces,
+		);
+		expect(toSavedViewSource(DataSource.METRICS)).toBe(
+			SavedviewtypesSourceDTO.metrics,
+		);
+		expect(toSavedViewSource('meter')).toBe(SavedviewtypesSourceDTO.meter);
+	});
+});

frontend/src/container/SavedViews/utils/getViewColumnsAndFormatting.ts

@@ -1,7 +1,4 @@
-import {
-	SavedviewtypesSavedViewSpecDTO,
-	SavedviewtypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { SavedviewtypesSavedViewSpecDTO } from 'api/generated/services/sigNoz.schemas';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import {
 	defaultLogsSelectedColumns,
@@ -10,6 +7,7 @@ import {
 } from 'container/OptionsMenu/constants';
 import { FontSize, LogViewMode } from 'container/OptionsMenu/types';
 import { Preferences } from 'providers/preferences/types';
+import { DataSource } from 'types/common/queryBuilder';
 
 function withColumnNames(
 	columns: TelemetryFieldKey[] | undefined,
@@ -27,11 +25,11 @@ function withColumnNames(
 // defaults filled in where the view has none.
 export function getViewColumnsAndFormatting(
 	spec: SavedviewtypesSavedViewSpecDTO | undefined,
-	sourcePage: SavedviewtypesSourceDTO,
+	dataSource: DataSource,
 ): Preferences {
 	const selectedFields = spec?.selectedFields as TelemetryFieldKey[] | undefined;
 
-	if (sourcePage === SavedviewtypesSourceDTO.logs) {
+	if (dataSource === DataSource.LOGS) {
 		return {
 			columns: ensureLogsRequiredColumns(
 				withColumnNames(selectedFields) || defaultLogsSelectedColumns,
@@ -44,7 +42,7 @@ export function getViewColumnsAndFormatting(
 			},
 		};
 	}
-	if (sourcePage === SavedviewtypesSourceDTO.traces) {
+	if (dataSource === DataSource.TRACES) {
 		return { columns: selectedFields || defaultTraceSelectedColumns };
 	}
 	return { columns: [] };

frontend/src/container/SavedViews/utils/hasUnsavedViewChanges.ts

@@ -1,6 +1,7 @@
 import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
 import { mapCompositeQueryFromQuery } from 'lib/newQueryBuilder/queryBuilderMappers/mapCompositeQueryFromQuery';
 import isEqual from 'lodash-es/isEqual';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { HasUnsavedViewChangesArgs } from '../types';
 import { getSavedViewQuery } from './getSavedViewQuery';
@@ -46,7 +47,6 @@ function withoutEmptyValues(value: unknown): unknown {
 // a graph in older views) drop out; the builder's shape gets different defaults.
 export function hasUnsavedViewChanges({
 	view,
-	source,
 	stagedQuery,
 	panelType,
 	options,
@@ -76,14 +76,18 @@ export function hasUnsavedViewChanges({
 		return false;
 	}
 
-	const { columns, formatting } = getViewColumnsAndFormatting(view.spec, source);
+	const dataSource = stagedQuery.builder.queryData[0]?.dataSource;
+	const { columns, formatting } = getViewColumnsAndFormatting(
+		view.spec,
+		dataSource,
+	);
 	const toNames = (fields: { name?: string; key?: string }[]): unknown[] =>
 		fields.map((field) => field.name ?? field.key);
 	if (!isEqual(toNames(columns), toNames(options.selectColumns ?? []))) {
 		return true;
 	}
 
-	if (!formatting) {
+	if (dataSource !== DataSource.LOGS || !formatting) {
 		return false;
 	}
 	return (

frontend/src/container/SavedViews/utils/toSavedViewSource.ts

@@ -0,0 +1,23 @@
+import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { SavedViewSourcePage } from '../types';
+
+// Explorers and the preferences module are keyed by DataSource (the signal),
+// the api keys views by source page. Same values today, so this is the one
+// place they meet. AI observability views will come with their own source and
+// DataSource cannot tell them apart from traces, so preferences should move to
+// source page at that point and this map goes with it.
+const SAVED_VIEW_SOURCE: Record<SavedViewSourcePage, SavedviewtypesSourceDTO> =
+	{
+		[DataSource.LOGS]: SavedviewtypesSourceDTO.logs,
+		[DataSource.TRACES]: SavedviewtypesSourceDTO.traces,
+		[DataSource.METRICS]: SavedviewtypesSourceDTO.metrics,
+		meter: SavedviewtypesSourceDTO.meter,
+	};
+
+export function toSavedViewSource(
+	sourcePage: SavedViewSourcePage,
+): SavedviewtypesSourceDTO {
+	return SAVED_VIEW_SOURCE[sourcePage];
+}

frontend/src/container/TracesExplorer/ListView/index.tsx

@@ -11,7 +11,6 @@ import {
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
 import logEvent from 'api/common/logEvent';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
 import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
@@ -87,7 +86,7 @@ function ListView({
 
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.TRACES_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.traces,
+		dataSource: DataSource.TRACES,
 		aggregateOperator: 'count',
 		initialOptions: {
 			selectColumns: defaultSelectedColumns,

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/PanelTypeSwitcher.tsx

@@ -5,7 +5,7 @@ import { DrawerWrapper } from '@signozhq/ui/drawer';
 import type { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import type { EQueryType } from 'types/common/dashboard';
 
-import PanelTypeBrowser from '../../../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeBrowser/PanelTypeBrowser';
+import PanelTypeBrowser from '../../../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeBrowser';
 import { getPanelDefinition } from '../../../Panels/registry';
 import type { PanelKind } from '../../../Panels/types/panelKind';
 import { JS_DRIVEN_SLIDE } from '../../../utils/drawerSlide';

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/AddPanelSplitButton.tsx

@@ -3,7 +3,7 @@ import { ChevronUp, Plus } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { Dropdown, type DropdownItemType } from '@signozhq/ui/dropdown';
 
-import type { SectionOption } from '../../types';
+import type { SectionOption } from './types';
 
 import styles from './AddPanelSplitButton.module.scss';
 

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeBrowser.module.scss

@@ -88,6 +88,76 @@
 	gap: 12px;
 }
 
+.tile {
+	display: flex;
+	flex-direction: column;
+	gap: 12px;
+	padding: 12px;
+	border: 1px solid var(--l1-border);
+	border-radius: 6px;
+	background: var(--l2-background);
+	font: inherit;
+	text-align: left;
+	cursor: pointer;
+	transition:
+		background-color 200ms cubic-bezier(0.08, 0.52, 0.52, 1),
+		border-color 200ms cubic-bezier(0.08, 0.52, 0.52, 1);
+
+	&:hover {
+		background: var(--l3-background);
+	}
+}
+
+.tileSelected {
+	border-color: var(--bg-robin-500);
+	box-shadow: inset 0 0 0 1px var(--bg-robin-500);
+	background: var(--l3-background);
+}
+
+.tileDisabled {
+	opacity: 0.45;
+	cursor: not-allowed;
+
+	&:hover {
+		background: var(--l2-background);
+	}
+}
+
+.tileText {
+	display: flex;
+	flex-direction: column;
+	gap: 3px;
+}
+
+.tileTitle {
+	display: flex;
+	align-items: center;
+	gap: 7px;
+}
+
+.tileName {
+	color: var(--l1-foreground);
+	font-size: 13.5px;
+	font-weight: 500;
+}
+
+.newBadge {
+	padding: 2px 6px;
+	border: 1px solid var(--bg-sienna-400);
+	border-radius: 3px;
+	color: var(--bg-sienna-400);
+	font-size: 9.5px;
+	font-weight: 500;
+	letter-spacing: 0.6px;
+	text-transform: uppercase;
+}
+
+.tileDescription {
+	color: var(--l2-foreground);
+	font-size: 12px;
+	line-height: 1.45;
+}
+
 .empty {
 	display: flex;
 	flex-direction: column;

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeBrowser.tsx

@@ -4,12 +4,12 @@ import { Button } from '@signozhq/ui/button';
 import { Input } from '@signozhq/ui/input';
 import cx from 'classnames';
 
-import type { PanelKind } from '../../../../../Panels/types/panelKind';
+import type { PanelKind } from '../../../Panels/types/panelKind';
 import {
 	filterPanelTypeGroups,
 	type PanelTypeGroupId,
 } from './panelTypeCatalog';
-import PanelTypeTile from '../PanelTypeTile/PanelTypeTile';
+import PanelTypeTile from './PanelTypeTile';
 
 import styles from './PanelTypeBrowser.module.scss';
 

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypePreview.tsx

@@ -1,4 +1,4 @@
-import type { PanelKind } from '../../../../../Panels/types/panelKind';
+import type { PanelKind } from '../../../Panels/types/panelKind';
 import { PANEL_TYPE_PREVIEWS } from './panelTypePreviews';
 
 import styles from './PanelTypePreview.module.scss';

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

@@ -7,11 +7,11 @@ import { releasePanelPickerTarget } from '../../../store/usePanelPickerTargetSto
 import type { NewPanelTarget } from '../../../patchOps';
 import type { PanelKind } from '../../../Panels/types/panelKind';
 import { JS_DRIVEN_SLIDE } from '../../../utils/drawerSlide';
-import AddPanelSplitButton from './components/AddPanelSplitButton/AddPanelSplitButton';
-import NewSectionNameInput from './components/NewSectionNameInput/NewSectionNameInput';
-import PanelTypeBrowser from './components/PanelTypeBrowser/PanelTypeBrowser';
-import { usePanelPickerDraftSection } from './hooks/usePanelPickerDraftSection';
-import { usePanelPickerTarget } from './hooks/usePanelPickerTarget';
+import AddPanelSplitButton from './AddPanelSplitButton';
+import NewSectionNameInput from './NewSectionNameInput';
+import PanelTypeBrowser from './PanelTypeBrowser';
+import { usePanelPickerDraftSection } from './usePanelPickerDraftSection';
+import { usePanelPickerTarget } from './usePanelPickerTarget';
 import { buildSectionOptions, resolveDefaultSectionValue } from './utils';
 
 import styles from './PanelTypeSelectionModal.module.scss';

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeTile.tsx

@@ -1,10 +1,10 @@
 import { Tooltip } from '@signozhq/ui/tooltip';
 import cx from 'classnames';
 
-import type { PanelTypeItem } from '../PanelTypeBrowser/panelTypeCatalog';
-import PanelTypePreview from '../PanelTypePreview/PanelTypePreview';
+import type { PanelTypeItem } from './panelTypeCatalog';
+import PanelTypePreview from './PanelTypePreview';
 
-import styles from './PanelTypeTile.module.scss';
+import styles from './PanelTypeBrowser.module.scss';
 
 interface PanelTypeTileProps {
 	item: PanelTypeItem;

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeTile/PanelTypeTile.module.scss

@@ -1,69 +0,0 @@
-.tile {
-	display: flex;
-	flex-direction: column;
-	gap: 12px;
-	padding: 12px;
-	border: 1px solid var(--l1-border);
-	border-radius: 6px;
-	background: var(--l2-background);
-	font: inherit;
-	text-align: left;
-	cursor: pointer;
-	transition:
-		background-color 200ms cubic-bezier(0.08, 0.52, 0.52, 1),
-		border-color 200ms cubic-bezier(0.08, 0.52, 0.52, 1);
-
-	&:hover {
-		background: var(--l3-background);
-	}
-}
-
-.tileSelected {
-	border-color: var(--bg-robin-500);
-	box-shadow: inset 0 0 0 1px var(--bg-robin-500);
-	background: var(--l3-background);
-}
-
-.tileDisabled {
-	opacity: 0.45;
-	cursor: not-allowed;
-
-	&:hover {
-		background: var(--l2-background);
-	}
-}
-
-.tileText {
-	display: flex;
-	flex-direction: column;
-	gap: 3px;
-}
-
-.tileTitle {
-	display: flex;
-	align-items: center;
-	gap: 7px;
-}
-
-.tileName {
-	color: var(--l1-foreground);
-	font-size: 13.5px;
-	font-weight: 500;
-}
-
-.newBadge {
-	padding: 2px 6px;
-	border: 1px solid var(--bg-sienna-400);
-	border-radius: 3px;
-	color: var(--bg-sienna-400);
-	font-size: 9.5px;
-	font-weight: 500;
-	letter-spacing: 0.6px;
-	text-transform: uppercase;
-}
-
-.tileDescription {
-	color: var(--l2-foreground);
-	font-size: 12px;
-	line-height: 1.45;
-}

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/panelTypeCatalog.ts

@@ -1,8 +1,5 @@
-import {
-	PANEL_OPTIONS,
-	type PanelOption,
-} from '../../../../../Panels/registry';
-import type { PanelKind } from '../../../../../Panels/types/panelKind';
+import { PANEL_OPTIONS, type PanelOption } from '../../../Panels/registry';
+import type { PanelKind } from '../../../Panels/types/panelKind';
 
 export type PanelTypeGroupId =
 	| 'trends'

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/panelTypePreviews.tsx

@@ -1,4 +1,4 @@
-import type { PanelKind } from '../../../../../Panels/types/panelKind';
+import type { PanelKind } from '../../../Panels/types/panelKind';
 import PreviewBars from './PreviewBars';
 import PreviewRows, { type PreviewCell } from './PreviewRows';
 

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/usePanelPickerDraftSection.ts

@@ -1,7 +1,7 @@
 import { useEffect } from 'react';
 
-import type { PanelKind } from '../../../../Panels/types/panelKind';
-import { usePanelPickerTargetStore } from '../../../../store/usePanelPickerTargetStore';
+import type { PanelKind } from '../../../Panels/types/panelKind';
+import { usePanelPickerTargetStore } from '../../../store/usePanelPickerTargetStore';
 
 export function usePanelPickerDraftSection(
 	title: string | null,

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/usePanelPickerTarget.ts

@@ -1,7 +1,7 @@
 import { useEffect } from 'react';
 
-import type { PanelKind } from '../../../../Panels/types/panelKind';
-import { usePanelPickerTargetStore } from '../../../../store/usePanelPickerTargetStore';
+import type { PanelKind } from '../../../Panels/types/panelKind';
+import { usePanelPickerTargetStore } from '../../../store/usePanelPickerTargetStore';
 
 interface UsePanelPickerTargetArgs {
 	open: boolean;

frontend/src/pages/TracesExplorer/index.tsx

@@ -73,7 +73,7 @@ function TracesExplorer(): JSX.Element {
 
 	const { options } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.TRACES_LIST_OPTIONS,
-		sourcePage: SavedviewtypesSourceDTO.traces,
+		dataSource: DataSource.TRACES,
 		aggregateOperator: 'noop',
 		initialOptions: {
 			selectColumns: defaultSelectedColumns,

frontend/src/providers/preferences/__tests__/PreferencesProvider.integration.test.tsx

@@ -1,15 +1,15 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { LOCALSTORAGE } from 'constants/localStorage';
-import { LogViewMode, FontSize } from 'container/OptionsMenu/types';
+import { LogViewMode } from 'container/OptionsMenu/types';
 import {
 	defaultLogsSelectedColumns,
 	defaultTraceSelectedColumns,
 } from 'container/OptionsMenu/constants';
+import { FontSize } from 'container/OptionsMenu/types';
 import { render, screen, userEvent } from 'tests/test-utils';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { usePreferenceContext } from '../context/PreferenceContextProvider';
-import { PreferenceSourcePage } from '../types';
 
 const ROUTE_LOGS = '/logs';
 const ROUTE_TRACES = '/traces';
@@ -38,13 +38,14 @@ function getLocalStorageJSON<T>(key: string): T | null {
 }
 
 function Consumer({
-	sourcePage,
+	dataSource,
 	testIdPrefix,
 }: {
-	sourcePage: PreferenceSourcePage;
+	dataSource: DataSource;
 	testIdPrefix: string;
 }): JSX.Element {
-	const slice = usePreferenceContext()[sourcePage];
+	const ctx = usePreferenceContext();
+	const slice = dataSource === DataSource.TRACES ? ctx.traces : ctx.logs;
 
 	return (
 		<div>
@@ -57,7 +58,7 @@ function Consumer({
 				type="button"
 				onClick={(): void => {
 					const newCols: TelemetryFieldKey[] =
-						sourcePage === SavedviewtypesSourceDTO.traces
+						dataSource === DataSource.TRACES
 							? (defaultTraceSelectedColumns.slice(0, 1) as TelemetryFieldKey[])
 							: (defaultLogsSelectedColumns.slice(0, 1) as TelemetryFieldKey[]);
 					slice.updateColumns(newCols);
@@ -77,10 +78,7 @@ describe('PreferencesProvider integration', () => {
 	describe('Logs', () => {
 		it('loads defaults when no localStorage or url provided', () => {
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.logs}
-					testIdPrefix={TESTID_LOGS}
-				/>,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix={TESTID_LOGS} />,
 				undefined,
 				{
 					initialRoute: ROUTE_LOGS,
@@ -103,10 +101,7 @@ describe('PreferencesProvider integration', () => {
 			});
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.logs}
-					testIdPrefix={TESTID_LOGS}
-				/>,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix={TESTID_LOGS} />,
 				undefined,
 				{
 					initialRoute: ROUTE_LOGS,
@@ -121,10 +116,7 @@ describe('PreferencesProvider integration', () => {
 		it('direct mode updateColumns persists to localStorage', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.logs}
-					testIdPrefix={TESTID_LOGS}
-				/>,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix={TESTID_LOGS} />,
 				undefined,
 				{
 					initialRoute: ROUTE_LOGS,
@@ -150,7 +142,7 @@ describe('PreferencesProvider integration', () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 			render(
-				<Consumer sourcePage={SavedviewtypesSourceDTO.logs} testIdPrefix="logs" />,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix="logs" />,
 				undefined,
 				{
 					initialRoute: initialEntry,
@@ -183,10 +175,7 @@ describe('PreferencesProvider integration', () => {
 			});
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.logs}
-					testIdPrefix={TESTID_LOGS}
-				/>,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix={TESTID_LOGS} />,
 				undefined,
 				{
 					initialRoute: ROUTE_LOGS,
@@ -208,7 +197,7 @@ describe('PreferencesProvider integration', () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 			function FormattingConsumer(): JSX.Element {
-				const logs = usePreferenceContext()[SavedviewtypesSourceDTO.logs];
+				const { logs } = usePreferenceContext();
 				return (
 					<button
 						data-testid="logs-update-formatting"
@@ -246,10 +235,7 @@ describe('PreferencesProvider integration', () => {
 			const initialEntry = `/logs?viewKey=${encodeURIComponent(viewKey)}`;
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.logs}
-					testIdPrefix={TESTID_LOGS}
-				/>,
+				<Consumer dataSource={DataSource.LOGS} testIdPrefix={TESTID_LOGS} />,
 				undefined,
 				{ initialRoute: initialEntry },
 			);
@@ -268,10 +254,7 @@ describe('PreferencesProvider integration', () => {
 	describe('Traces', () => {
 		it('loads defaults when no localStorage or url provided', () => {
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix={TESTID_TRACES}
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix={TESTID_TRACES} />,
 				undefined,
 				{
 					initialRoute: ROUTE_TRACES,
@@ -290,10 +273,7 @@ describe('PreferencesProvider integration', () => {
 			});
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix={TESTID_TRACES}
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix={TESTID_TRACES} />,
 				undefined,
 				{
 					initialRoute: ROUTE_TRACES,
@@ -306,10 +286,7 @@ describe('PreferencesProvider integration', () => {
 		it('direct mode updateColumns persists to localStorage', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix={TESTID_TRACES}
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix={TESTID_TRACES} />,
 				undefined,
 				{
 					initialRoute: ROUTE_TRACES,
@@ -332,10 +309,7 @@ describe('PreferencesProvider integration', () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix="traces"
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix="traces" />,
 				undefined,
 				{
 					initialRoute: initialEntry,
@@ -364,10 +338,7 @@ describe('PreferencesProvider integration', () => {
 			});
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix={TESTID_TRACES}
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix={TESTID_TRACES} />,
 				undefined,
 				{ initialRoute: ROUTE_TRACES },
 			);
@@ -384,7 +355,7 @@ describe('PreferencesProvider integration', () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 			function TracesFormattingConsumer(): JSX.Element {
-				const traces = usePreferenceContext()[SavedviewtypesSourceDTO.traces];
+				const { traces } = usePreferenceContext();
 				return (
 					<button
 						data-testid="traces-update-formatting"
@@ -419,10 +390,7 @@ describe('PreferencesProvider integration', () => {
 			const initialEntry = `/traces?viewKey=${encodeURIComponent(viewKey)}`;
 
 			render(
-				<Consumer
-					sourcePage={SavedviewtypesSourceDTO.traces}
-					testIdPrefix={TESTID_TRACES}
-				/>,
+				<Consumer dataSource={DataSource.TRACES} testIdPrefix={TESTID_TRACES} />,
 				undefined,
 				{ initialRoute: initialEntry },
 			);

frontend/src/providers/preferences/__tests__/usePreferenceLoader.test.tsx

@@ -1,9 +1,6 @@
-import { Dispatch, SetStateAction } from 'react';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { renderHook, waitFor } from '@testing-library/react';
 import { defaultLogsSelectedColumns } from 'container/OptionsMenu/constants';
-import { FontSize } from 'container/OptionsMenu/types';
-import { renderHook, waitFor } from 'tests/test-utils';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { DataSource } from 'types/common/queryBuilder';
 
 import logsLoaderConfig from '../configs/logsLoaderConfig';
 import { usePreferenceLoader } from '../loader/usePreferenceLoader';
@@ -45,18 +42,15 @@ jest.mock('../configs/tracesLoaderConfig', () => ({
 }));
 
 describe('usePreferenceLoader', () => {
-	const setReSync = jest.fn() as jest.MockedFunction<
-		Dispatch<SetStateAction<boolean>>
-	>;
-
 	beforeEach(() => {
 		jest.clearAllMocks();
 	});
 
 	it('should load logs preferences based on priority order', async () => {
+		const setReSync = jest.fn();
 		const { result } = renderHook(() =>
 			usePreferenceLoader({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				reSync: false,
 				setReSync,
 			}),
@@ -77,9 +71,10 @@ describe('usePreferenceLoader', () => {
 	});
 
 	it('should load traces preferences', async () => {
+		const setReSync = jest.fn();
 		const { result } = renderHook(() =>
 			usePreferenceLoader({
-				sourcePage: SavedviewtypesSourceDTO.traces,
+				dataSource: DataSource.TRACES,
 				reSync: false,
 				setReSync,
 			}),
@@ -98,11 +93,13 @@ describe('usePreferenceLoader', () => {
 	});
 
 	it('should call setReSync when reSync is true', async () => {
+		const setReSync = jest.fn();
+
 		// Test that the hook calls setReSync(false) when reSync is true
 		// We'll unmount quickly to avoid the infinite loop
 		const { unmount } = renderHook(() =>
 			usePreferenceLoader({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				reSync: true,
 				setReSync,
 			}),
@@ -121,25 +118,19 @@ describe('usePreferenceLoader', () => {
 
 	it('should handle errors during loading', async () => {
 		// Make first call succeed (initial state), second call throw in reSync effect
-		const localSpy = jest.spyOn(logsLoaderConfig, 'local');
-		// The loader reads stored columns by name, though `local()` types them as
-		// the older key-based shape.
+		const localSpy: jest.SpyInstance = jest.spyOn(logsLoaderConfig, 'local');
 		localSpy.mockImplementationOnce(() => ({
-			columns: [{ name: 'local-column' }] as unknown as BaseAutocompleteData[],
-			formatting: {
-				maxLines: 5,
-				format: 'table',
-				fontSize: FontSize.MEDIUM,
-				version: 1,
-			},
+			columns: [{ name: 'local-column' }],
+			formatting: { maxLines: 5, format: 'table', fontSize: 'medium', version: 1 },
 		}));
 		localSpy.mockImplementationOnce(() => {
 			throw new Error('Loading failed');
 		});
 
+		const setReSync = jest.fn();
 		const { result } = renderHook(() =>
 			usePreferenceLoader({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				reSync: true,
 				setReSync,
 			}),

frontend/src/providers/preferences/__tests__/usePreferenceSync.test.tsx

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { useGetSavedView } from 'api/generated/services/saved-view';
 import {
 	SavedviewtypesSavedViewDTO,
@@ -8,21 +9,32 @@ import {
 	defaultTraceSelectedColumns,
 	ensureLogsRequiredColumns,
 } from 'container/OptionsMenu/constants';
-import { renderHook } from 'tests/test-utils';
+import { DataSource } from 'types/common/queryBuilder';
 
-import { usePreferenceLoader } from '../loader/usePreferenceLoader';
 import { usePreferenceSync } from '../sync/usePreferenceSync';
-import { PreferenceMode, Preferences } from '../types';
-import { usePreferenceUpdater } from '../updater/usePreferenceUpdater';
+import { PreferenceMode } from '../types';
 
 jest.mock('api/generated/services/saved-view');
 
-jest.mock('../loader/usePreferenceLoader');
-jest.mock('../updater/usePreferenceUpdater');
+const loaderPreferences = { columns: [{ name: 'from-loader' }] };
+jest.mock('../loader/usePreferenceLoader', () => ({
+	usePreferenceLoader: jest.fn(() => ({
+		preferences: loaderPreferences,
+		loading: false,
+		error: null,
+	})),
+}));
 
-const loaderPreferences: Preferences = { columns: [{ name: 'from-loader' }] };
+jest.mock('../updater/usePreferenceUpdater', () => ({
+	usePreferenceUpdater: jest.fn(() => ({
+		updateColumns: jest.fn(),
+		updateFormatting: jest.fn(),
+	})),
+}));
 
-const mockedUseGetSavedView = jest.mocked(useGetSavedView);
+const mockedUseGetSavedView = useGetSavedView as jest.MockedFunction<
+	typeof useGetSavedView
+>;
 
 function makeView(
 	id: string,
@@ -64,19 +76,6 @@ function mockViews(views: SavedviewtypesSavedViewDTO[]): void {
 describe('usePreferenceSync in saved view mode', () => {
 	beforeEach(() => {
 		mockedUseGetSavedView.mockReset();
-		jest.mocked(usePreferenceLoader).mockReturnValue({
-			preferences: loaderPreferences,
-			loading: false,
-			error: null,
-		});
-		jest.mocked(usePreferenceUpdater).mockReturnValue({
-			updateColumns: jest.fn() as jest.MockedFunction<
-				ReturnType<typeof usePreferenceUpdater>['updateColumns']
-			>,
-			updateFormatting: jest.fn() as jest.MockedFunction<
-				ReturnType<typeof usePreferenceUpdater>['updateFormatting']
-			>,
-		});
 	});
 
 	it('fetches the view only in saved view mode with a view id', () => {
@@ -85,7 +84,7 @@ describe('usePreferenceSync in saved view mode', () => {
 		renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.DIRECT,
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				savedViewId: undefined,
 			}),
 		);
@@ -102,7 +101,7 @@ describe('usePreferenceSync in saved view mode', () => {
 		const { result } = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.DIRECT,
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				savedViewId: undefined,
 			}),
 		);
@@ -121,7 +120,7 @@ describe('usePreferenceSync in saved view mode', () => {
 		const { result } = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.SAVED_VIEW,
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				savedViewId: 'view-1',
 			}),
 		);
@@ -148,7 +147,7 @@ describe('usePreferenceSync in saved view mode', () => {
 		const { result } = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.SAVED_VIEW,
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				savedViewId: 'view-1',
 			}),
 		);
@@ -175,14 +174,14 @@ describe('usePreferenceSync in saved view mode', () => {
 		const withFields = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.SAVED_VIEW,
-				sourcePage: SavedviewtypesSourceDTO.traces,
+				dataSource: DataSource.TRACES,
 				savedViewId: 'with-fields',
 			}),
 		);
 		const withoutFields = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.SAVED_VIEW,
-				sourcePage: SavedviewtypesSourceDTO.traces,
+				dataSource: DataSource.TRACES,
 				savedViewId: 'without-fields',
 			}),
 		);
@@ -203,7 +202,7 @@ describe('usePreferenceSync in saved view mode', () => {
 		const { result } = renderHook(() =>
 			usePreferenceSync({
 				mode: PreferenceMode.SAVED_VIEW,
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				savedViewId: 'missing',
 			}),
 		);

frontend/src/providers/preferences/__tests__/usePreferenceUpdater.test.tsx

@@ -1,39 +1,45 @@
-import { Dispatch, SetStateAction } from 'react';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
+import { act } from 'react-dom/test-utils';
+import { renderHook } from '@testing-library/react';
 import { TelemetryFieldKey } from 'api/v5/v5';
-import { LogViewMode, FontSize } from 'container/OptionsMenu/types';
-import useUrlQueryData from 'hooks/useUrlQueryData';
+import { LogViewMode } from 'container/OptionsMenu/types';
+import { FontSize } from 'container/OptionsMenu/types';
 import {
 	FormattingOptions,
 	PreferenceMode,
 	Preferences,
 } from 'providers/preferences/types';
-import { act, renderHook } from 'tests/test-utils';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { DataSource } from 'types/common/queryBuilder';
 
-import getLogsUpdaterConfig from '../configs/logsUpdaterConfig';
-import getTracesUpdaterConfig from '../configs/tracesUpdaterConfig';
 import { usePreferenceUpdater } from '../updater/usePreferenceUpdater';
 
-jest.mock('../configs/logsUpdaterConfig');
-jest.mock('../configs/tracesUpdaterConfig');
-jest.mock('hooks/useUrlQueryData');
+// Mock the config updaters
+const mockUpdateColumns = jest.fn();
+const mockUpdateFormatting = jest.fn();
 
-type LogsUpdater = ReturnType<typeof getLogsUpdaterConfig>;
-type TracesUpdater = ReturnType<typeof getTracesUpdaterConfig>;
+jest.mock('../configs/logsUpdaterConfig', () => ({
+	__esModule: true,
+	default: jest.fn().mockImplementation(() => ({
+		updateColumns: mockUpdateColumns,
+		updateFormatting: mockUpdateFormatting,
+	})),
+}));
 
-const mockLogsUpdateColumns = jest.fn() as jest.MockedFunction<
-	LogsUpdater['updateColumns']
->;
-const mockLogsUpdateFormatting = jest.fn() as jest.MockedFunction<
-	LogsUpdater['updateFormatting']
->;
-const mockTracesUpdateColumns = jest.fn() as jest.MockedFunction<
-	TracesUpdater['updateColumns']
->;
-const mockTracesUpdateFormatting = jest.fn() as jest.MockedFunction<
-	TracesUpdater['updateFormatting']
->;
+jest.mock('../configs/tracesUpdaterConfig', () => ({
+	__esModule: true,
+	default: jest.fn().mockImplementation(() => ({
+		updateColumns: mockUpdateColumns,
+		updateFormatting: mockUpdateFormatting,
+	})),
+}));
+
+// Mock the URL query hook
+jest.mock('hooks/useUrlQueryData', () => ({
+	__esModule: true,
+	default: jest.fn().mockReturnValue({
+		redirectWithQuery: jest.fn(),
+	}),
+}));
 
 describe('usePreferenceUpdater', () => {
 	const mockPreferences: Preferences = {
@@ -45,36 +51,18 @@ describe('usePreferenceUpdater', () => {
 			version: 1,
 		},
 	};
-	const setReSync = jest.fn() as jest.MockedFunction<
-		Dispatch<SetStateAction<boolean>>
-	>;
-	const setSavedViewPreferences = jest.fn() as jest.MockedFunction<
-		Dispatch<SetStateAction<Preferences | null>>
-	>;
 
 	beforeEach(() => {
 		jest.clearAllMocks();
-		jest.mocked(getLogsUpdaterConfig).mockReturnValue({
-			updateColumns: mockLogsUpdateColumns,
-			updateFormatting: mockLogsUpdateFormatting,
-		});
-		jest.mocked(getTracesUpdaterConfig).mockReturnValue({
-			updateColumns: mockTracesUpdateColumns,
-			updateFormatting: mockTracesUpdateFormatting,
-		});
-		jest.mocked(useUrlQueryData).mockReturnValue({
-			query: null,
-			queryData: undefined,
-			redirectWithQuery: jest.fn() as jest.MockedFunction<
-				(newQueryData: unknown) => void
-			>,
-		});
 	});
 
 	it('should return updateColumns and updateFormatting functions', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
+
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,
@@ -87,7 +75,9 @@ describe('usePreferenceUpdater', () => {
 		expect(typeof result.current.updateFormatting).toBe('function');
 	});
 
-	it('should call the logs updater for updateColumns with the logs list key', () => {
+	it('should call the logs updater for updateColumns with logs dataSource', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
 		const newColumns: TelemetryFieldKey[] = [
 			{
 				name: 'new-column',
@@ -98,7 +88,7 @@ describe('usePreferenceUpdater', () => {
 
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,
@@ -111,15 +101,16 @@ describe('usePreferenceUpdater', () => {
 		});
 
 		// Should call the logs updater
-		expect(mockLogsUpdateColumns).toHaveBeenCalledWith(
+		expect(mockUpdateColumns).toHaveBeenCalledWith(
 			newColumns,
 			PreferenceMode.DIRECT,
 		);
-		expect(mockTracesUpdateColumns).not.toHaveBeenCalled();
 		expect(setReSync).toHaveBeenCalledWith(true);
 	});
 
-	it('should call the logs updater for updateFormatting with the logs list key', () => {
+	it('should call the logs updater for updateFormatting with logs dataSource', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
 		const newFormatting: FormattingOptions = {
 			maxLines: 10,
 			format: 'table' as LogViewMode,
@@ -129,7 +120,7 @@ describe('usePreferenceUpdater', () => {
 
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,
@@ -142,15 +133,16 @@ describe('usePreferenceUpdater', () => {
 		});
 
 		// Should call the logs updater
-		expect(mockLogsUpdateFormatting).toHaveBeenCalledWith(
+		expect(mockUpdateFormatting).toHaveBeenCalledWith(
 			newFormatting,
 			PreferenceMode.DIRECT,
 		);
-		expect(mockTracesUpdateFormatting).not.toHaveBeenCalled();
 		expect(setReSync).toHaveBeenCalledWith(true);
 	});
 
-	it('should call the traces updater for updateColumns with the traces list key', () => {
+	it('should call the traces updater for updateColumns with traces dataSource', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
 		const newColumns: TelemetryFieldKey[] = [
 			{
 				name: 'new-trace-column',
@@ -161,7 +153,7 @@ describe('usePreferenceUpdater', () => {
 
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.traces,
+				dataSource: DataSource.TRACES,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,
@@ -174,15 +166,16 @@ describe('usePreferenceUpdater', () => {
 		});
 
 		// Should call the traces updater
-		expect(mockTracesUpdateColumns).toHaveBeenCalledWith(
+		expect(mockUpdateColumns).toHaveBeenCalledWith(
 			newColumns,
 			PreferenceMode.DIRECT,
 		);
-		expect(mockLogsUpdateColumns).not.toHaveBeenCalled();
 		expect(setReSync).toHaveBeenCalledWith(true);
 	});
 
-	it('should call the traces updater for updateFormatting with the traces list key', () => {
+	it('should call the traces updater for updateFormatting with traces dataSource', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
 		const newFormatting: FormattingOptions = {
 			maxLines: 10,
 			format: 'table' as LogViewMode,
@@ -192,7 +185,7 @@ describe('usePreferenceUpdater', () => {
 
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.traces,
+				dataSource: DataSource.TRACES,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,
@@ -205,18 +198,20 @@ describe('usePreferenceUpdater', () => {
 		});
 
 		// Should call the traces updater
-		expect(mockTracesUpdateFormatting).toHaveBeenCalledWith(
+		expect(mockUpdateFormatting).toHaveBeenCalledWith(
 			newFormatting,
 			PreferenceMode.DIRECT,
 		);
-		expect(mockLogsUpdateFormatting).not.toHaveBeenCalled();
 		expect(setReSync).toHaveBeenCalledWith(true);
 	});
 
 	it('should increment reSync counter when updates are called', () => {
+		const setReSync = jest.fn();
+		const setSavedViewPreferences = jest.fn();
+
 		const { result } = renderHook(() =>
 			usePreferenceUpdater({
-				sourcePage: SavedviewtypesSourceDTO.logs,
+				dataSource: DataSource.LOGS,
 				mode: PreferenceMode.DIRECT,
 				preferences: mockPreferences,
 				setReSync,

frontend/src/providers/preferences/__tests__/utils.test.ts

@@ -1,20 +0,0 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { isPreferenceSourcePage } from '../utils';
-
-describe('isPreferenceSourcePage', () => {
-	it.each([SavedviewtypesSourceDTO.logs, SavedviewtypesSourceDTO.traces])(
-		'is true for %s',
-		(source) => {
-			expect(isPreferenceSourcePage(source)).toBe(true);
-		},
-	);
-
-	it.each([
-		SavedviewtypesSourceDTO.metrics,
-		SavedviewtypesSourceDTO.meter,
-		SavedviewtypesSourceDTO.ai_observability,
-	])('is false for %s', (source) => {
-		expect(isPreferenceSourcePage(source)).toBe(false);
-	});
-});

frontend/src/providers/preferences/constants.ts

@@ -1,7 +0,0 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
-
-// Only the logs and traces explorers keep column and formatting preferences.
-export const PREFERENCE_SOURCE_PAGES = [
-	SavedviewtypesSourceDTO.logs,
-	SavedviewtypesSourceDTO.traces,
-] as const;

frontend/src/providers/preferences/context/PreferenceContextProvider.tsx

@@ -5,12 +5,12 @@ import React, {
 	useContext,
 	useMemo,
 } from 'react';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import useUrlQuery from 'hooks/useUrlQuery';
 import {
 	PreferenceContextValue,
 	PreferenceMode,
 } from 'providers/preferences/types';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { usePreferenceSync } from '../sync/usePreferenceSync';
 
@@ -38,19 +38,19 @@ export function PreferenceContextProvider({
 	const logsSlice = usePreferenceSync({
 		mode: savedViewId ? PreferenceMode.SAVED_VIEW : PreferenceMode.DIRECT,
 		savedViewId: savedViewId || undefined,
-		sourcePage: SavedviewtypesSourceDTO.logs,
+		dataSource: DataSource.LOGS,
 	});
 
 	const tracesSlice = usePreferenceSync({
 		mode: savedViewId ? PreferenceMode.SAVED_VIEW : PreferenceMode.DIRECT,
 		savedViewId: savedViewId || undefined,
-		sourcePage: SavedviewtypesSourceDTO.traces,
+		dataSource: DataSource.TRACES,
 	});
 
 	const value = useMemo<PreferenceContextValue>(
 		() => ({
-			[SavedviewtypesSourceDTO.logs]: logsSlice,
-			[SavedviewtypesSourceDTO.traces]: tracesSlice,
+			logs: logsSlice,
+			traces: tracesSlice,
 		}),
 		[logsSlice, tracesSlice],
 	);

frontend/src/providers/preferences/context/usePreferenceSlice.ts

@@ -1,12 +0,0 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { PreferenceSlice } from '../types';
-import { isPreferenceSourcePage } from '../utils';
-import { usePreferenceContext } from './PreferenceContextProvider';
-
-export function usePreferenceSlice(
-	sourcePage: SavedviewtypesSourceDTO,
-): PreferenceSlice | undefined {
-	const context = usePreferenceContext();
-	return isPreferenceSourcePage(sourcePage) ? context[sourcePage] : undefined;
-}

frontend/src/providers/preferences/loader/usePreferenceLoader.ts

@@ -1,12 +1,12 @@
 import { useEffect, useState } from 'react';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { ensureLogsRequiredColumns } from 'container/OptionsMenu/constants';
 import { has } from 'lodash-es';
+import { DataSource } from 'types/common/queryBuilder';
 
 import logsLoaderConfig from '../configs/logsLoaderConfig';
 import tracesLoaderConfig from '../configs/tracesLoaderConfig';
-import { FormattingOptions, Preferences, PreferenceSourcePage } from '../types';
+import { FormattingOptions, Preferences } from '../types';
 
 const migrateColumns = (columns: any): any =>
 	columns.map((column: any) => {
@@ -62,21 +62,15 @@ function logsPreferencesLoader(): {
 function tracesPreferencesLoader(): {
 	columns: TelemetryFieldKey[];
 } {
-	const { columns } = preferencesLoader<Preferences>(tracesLoaderConfig);
-	return { columns };
+	return preferencesLoader(tracesLoaderConfig);
 }
 
-const PREFERENCE_LOADERS: Record<PreferenceSourcePage, () => Preferences> = {
-	[SavedviewtypesSourceDTO.logs]: logsPreferencesLoader,
-	[SavedviewtypesSourceDTO.traces]: tracesPreferencesLoader,
-};
-
 export function usePreferenceLoader({
-	sourcePage,
+	dataSource,
 	reSync,
 	setReSync,
 }: {
-	sourcePage: PreferenceSourcePage;
+	dataSource: DataSource;
 	reSync: boolean;
 	setReSync: (value: boolean) => void;
 }): {
@@ -84,10 +78,17 @@ export function usePreferenceLoader({
 	loading: boolean;
 	error: Error | null;
 } {
-	const loadSlicePreferences = PREFERENCE_LOADERS[sourcePage];
-	const [preferences, setPreferences] = useState<Preferences | null>(
-		loadSlicePreferences,
-	);
+	const [preferences, setPreferences] = useState<Preferences | null>(() => {
+		if (dataSource === DataSource.LOGS) {
+			const { columns, formatting } = logsPreferencesLoader();
+			return { columns, formatting };
+		}
+		if (dataSource === DataSource.TRACES) {
+			const { columns } = tracesPreferencesLoader();
+			return { columns };
+		}
+		return null;
+	});
 	const [error, setError] = useState<Error | null>(null);
 
 	useEffect((): void => {
@@ -95,7 +96,15 @@ export function usePreferenceLoader({
 			setError(null);
 
 			try {
-				setPreferences(loadSlicePreferences());
+				if (dataSource === DataSource.LOGS) {
+					const { columns, formatting } = logsPreferencesLoader();
+					setPreferences({ columns, formatting });
+				}
+
+				if (dataSource === DataSource.TRACES) {
+					const { columns } = tracesPreferencesLoader();
+					setPreferences({ columns });
+				}
 			} catch (e) {
 				setError(e as Error);
 			} finally {
@@ -110,7 +119,7 @@ export function usePreferenceLoader({
 		if (reSync) {
 			loadPreferences();
 		}
-	}, [loadSlicePreferences, reSync, setReSync]);
+	}, [dataSource, reSync, setReSync]);
 
 	return { preferences, loading: false, error };
 }

frontend/src/providers/preferences/sync/usePreferenceSync.ts

@@ -3,23 +3,19 @@ import { useEffect, useRef, useState } from 'react';
 import { useGetSavedView } from 'api/generated/services/saved-view';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { getViewColumnsAndFormatting } from 'container/SavedViews/utils/getViewColumnsAndFormatting';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { usePreferenceLoader } from '../loader/usePreferenceLoader';
-import {
-	FormattingOptions,
-	PreferenceMode,
-	Preferences,
-	PreferenceSourcePage,
-} from '../types';
+import { FormattingOptions, PreferenceMode, Preferences } from '../types';
 import { usePreferenceUpdater } from '../updater/usePreferenceUpdater';
 
 export function usePreferenceSync({
 	mode,
-	sourcePage,
+	dataSource,
 	savedViewId,
 }: {
 	mode: PreferenceMode;
-	sourcePage: PreferenceSourcePage;
+	dataSource: DataSource;
 	savedViewId: string | undefined;
 }): {
 	preferences: Preferences | null;
@@ -45,25 +41,25 @@ export function usePreferenceSync({
 		if (view && view.id === savedViewId) {
 			if (seededViewId.current !== savedViewId) {
 				seededViewId.current = savedViewId;
-				setSavedViewPreferences(getViewColumnsAndFormatting(view.spec, sourcePage));
+				setSavedViewPreferences(getViewColumnsAndFormatting(view.spec, dataSource));
 			}
 			return;
 		}
 		seededViewId.current = undefined;
-		setSavedViewPreferences(getViewColumnsAndFormatting(undefined, sourcePage));
-	}, [viewData, sourcePage, savedViewId]);
+		setSavedViewPreferences(getViewColumnsAndFormatting(undefined, dataSource));
+	}, [viewData, dataSource, savedViewId]);
 
 	// We are using a reSync state because we have URL updates as well as local storage updates
 	// and we want to make sure we are always using the latest preferences
 	const [reSync, setReSync] = useState(false);
 	const { preferences, loading, error } = usePreferenceLoader({
-		sourcePage,
+		dataSource,
 		reSync,
 		setReSync,
 	});
 
 	const { updateColumns, updateFormatting } = usePreferenceUpdater({
-		sourcePage,
+		dataSource,
 		mode,
 		preferences,
 		setReSync,

frontend/src/providers/preferences/types/index.ts

@@ -1,15 +1,12 @@
 import { TelemetryFieldKey } from 'api/v5/v5';
-import { LogViewMode, FontSize } from 'container/OptionsMenu/types';
-
-import { PREFERENCE_SOURCE_PAGES } from '../constants';
+import { LogViewMode } from 'container/OptionsMenu/types';
+import { FontSize } from 'container/OptionsMenu/types';
 
 export enum PreferenceMode {
 	SAVED_VIEW = 'savedView',
 	DIRECT = 'direct',
 }
 
-export type PreferenceSourcePage = (typeof PREFERENCE_SOURCE_PAGES)[number];
-
 export interface PreferenceSlice {
 	preferences: Preferences | null;
 	loading: boolean;
@@ -18,10 +15,10 @@ export interface PreferenceSlice {
 	updateFormatting: (newFormatting: FormattingOptions) => void;
 }
 
-export type PreferenceContextValue = Record<
-	PreferenceSourcePage,
-	PreferenceSlice
->;
+export interface PreferenceContextValue {
+	logs: PreferenceSlice;
+	traces: PreferenceSlice;
+}
 
 export interface FormattingOptions {
 	maxLines?: number;

frontend/src/providers/preferences/updater/usePreferenceUpdater.ts

@@ -1,5 +1,4 @@
 import { Dispatch, SetStateAction } from 'react';
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import {
 	defaultOptionsQuery,
@@ -7,41 +6,48 @@ import {
 } from 'container/OptionsMenu/constants';
 import { OptionsQuery } from 'container/OptionsMenu/types';
 import useUrlQueryData from 'hooks/useUrlQueryData';
+import { DataSource } from 'types/common/queryBuilder';
 
 import getLogsUpdaterConfig from '../configs/logsUpdaterConfig';
 import getTracesUpdaterConfig from '../configs/tracesUpdaterConfig';
-import { FormattingOptions, Preferences, PreferenceSourcePage } from '../types';
+import { FormattingOptions, Preferences } from '../types';
+
+const metricsUpdater = {
+	updateColumns: (): void => {}, // no-op for metrics
+	updateFormatting: (): void => {}, // no-op for metrics
+};
 
 const getUpdaterConfig = (
 	preferences: Preferences | null,
 	redirectWithOptionsData: (options: OptionsQuery) => void,
 	setSavedViewPreferences: Dispatch<SetStateAction<Preferences | null>>,
 ): Record<
-	PreferenceSourcePage,
+	DataSource,
 	{
 		updateColumns: (newColumns: TelemetryFieldKey[], mode: string) => void;
 		updateFormatting: (newFormatting: FormattingOptions, mode: string) => void;
 	}
 > => ({
-	[SavedviewtypesSourceDTO.logs]: getLogsUpdaterConfig(
+	[DataSource.LOGS]: getLogsUpdaterConfig(
 		preferences,
 		redirectWithOptionsData,
 		setSavedViewPreferences,
 	),
-	[SavedviewtypesSourceDTO.traces]: getTracesUpdaterConfig(
+	[DataSource.TRACES]: getTracesUpdaterConfig(
 		redirectWithOptionsData,
 		setSavedViewPreferences,
 	),
+	[DataSource.METRICS]: metricsUpdater,
 });
 
 export function usePreferenceUpdater({
-	sourcePage,
+	dataSource,
 	mode,
 	preferences,
 	setReSync,
 	setSavedViewPreferences,
 }: {
-	sourcePage: PreferenceSourcePage;
+	dataSource: DataSource;
 	mode: string;
 	preferences: Preferences | null;
 	setReSync: Dispatch<SetStateAction<boolean>>;
@@ -56,7 +62,7 @@ export function usePreferenceUpdater({
 		preferences,
 		redirectWithOptionsData,
 		setSavedViewPreferences,
-	)[sourcePage];
+	)[dataSource];
 
 	return {
 		updateColumns: (newColumns: TelemetryFieldKey[]): void => {

frontend/src/providers/preferences/utils.ts

@@ -1,12 +0,0 @@
-import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { PREFERENCE_SOURCE_PAGES } from './constants';
-import { PreferenceSourcePage } from './types';
-
-export function isPreferenceSourcePage(
-	sourcePage: SavedviewtypesSourceDTO,
-): sourcePage is PreferenceSourcePage {
-	return (
-		PREFERENCE_SOURCE_PAGES as readonly SavedviewtypesSourceDTO[]
-	).includes(sourcePage);
-}

frontend/src/storybook/msw/__story_mockdata__/queryBuilderMetrics.ts

@@ -1,33 +0,0 @@
-/**
- * AI-owned. Generated and maintained by the `signoz-page-story` skill.
- * Do not hand-edit: regenerate instead.
- */
-
-import {
-	MetrictypesTemporalityDTO,
-	MetrictypesTypeDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-import { type MetricSeed, metricSeed } from './metrics';
-
-/**
- * One metric per type the query builder treats differently: the type decides
- * the default time and space aggregation and which add-ons are offered.
- */
-export const QUERY_BUILDER_METRICS: readonly MetricSeed[] = [
-	metricSeed('signoz_calls_total', 'Calls per operation'),
-	metricSeed('signoz_latency_count', 'Latency sample count'),
-	metricSeed(
-		'container_cpu_utilization',
-		'Container CPU utilisation',
-		'percent',
-		MetrictypesTypeDTO.gauge,
-		MetrictypesTemporalityDTO.unspecified,
-	),
-	metricSeed(
-		'signoz_latency_bucket',
-		'Latency histogram',
-		'ms',
-		MetrictypesTypeDTO.histogram,
-	),
-];

frontend/src/storybook/msw/queryBuilderHandlers.ts

@@ -8,16 +8,10 @@ import { rest } from 'msw';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { DataSource, SIGNAL_TO_DATA_SOURCE } from 'types/common/queryBuilder';
 
-import { fieldValuesResponse } from './__story_mockdata__/fields';
-import {
-	listMetricsResponse,
-	metricMetadataResponse,
-} from './__story_mockdata__/metrics';
 import {
 	autocompleteKeysResponse,
 	autocompleteValuesResponse,
 } from './__story_mockdata__/queryBuilderAutocomplete';
-import { QUERY_BUILDER_METRICS } from './__story_mockdata__/queryBuilderMetrics';
 
 /**
  * The v5 keys list, served from the same per-signal fixture as the v3 pair so
@@ -105,61 +99,6 @@ export const queryBuilderHandlers = [
 			),
 		),
 	),
-	// The AI query builder pins traces and reads the same shapes from its own
-	// endpoints.
-	rest.get(
-		'http://localhost/api/v1/ai_observability/fields/keys',
-		(req, res, ctx) =>
-			res(
-				ctx.status(200),
-				ctx.json(
-					fieldKeysResponseForSignal(
-						TelemetrytypesSignalDTO.traces,
-						req.url.searchParams.get('searchText') ?? '',
-					),
-				),
-			),
-	),
-	...[
-		'http://localhost/api/v1/fields/values',
-		'http://localhost/api/v1/ai_observability/fields/values',
-	].map((url) =>
-		rest.get(url, (req, res, ctx) =>
-			res(
-				ctx.status(200),
-				ctx.json(
-					fieldValuesResponse(
-						autocompleteValuesResponse(
-							req.url.searchParams.get('name'),
-							req.url.searchParams.get('searchText') ?? '',
-						).data.stringAttributeValues ?? [],
-					),
-				),
-			),
-		),
-	),
-	rest.get('http://localhost/api/v2/metrics', (req, res, ctx) =>
-		res(
-			ctx.status(200),
-			ctx.json(
-				listMetricsResponse(
-					QUERY_BUILDER_METRICS,
-					req.url.searchParams.get('searchText') ?? '',
-				),
-			),
-		),
-	),
-	rest.get('http://localhost/api/v2/metrics/metadata', (req, res, ctx) =>
-		res(
-			ctx.status(200),
-			ctx.json(
-				metricMetadataResponse(
-					QUERY_BUILDER_METRICS,
-					req.url.searchParams.get('metricName') ?? '',
-				),
-			),
-		),
-	),
 	rest.get(
 		'http://localhost/api/v3/autocomplete/attribute_keys',
 		(req, res, ctx) => {

go.mod

@@ -9,7 +9,7 @@ require (
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/clickhouse-go-mock v0.14.0
 	github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd
-	github.com/SigNoz/signoz-otel-collector v0.144.6
+	github.com/SigNoz/signoz-otel-collector v0.144.16-0.20261102045710-f531882cb133
 	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/antonmedv/expr v1.15.3
 	github.com/cespare/xxhash/v2 v2.3.0

go.sum

@@ -100,8 +100,8 @@ github.com/SigNoz/expr v1.17.7-beta h1:FyZkleM5dTQ0O6muQfwGpoH5A2ohmN/XTasRCO72g
 github.com/SigNoz/expr v1.17.7-beta/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd h1:Bk43AsDYe0fhkbj57eGXx8H3ZJ4zhmQXBnrW523ktj8=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd/go.mod h1:nxRcH/OEdM8QxzH37xkGzomr1O0JpYBRS6pwjsWW6Pc=
-github.com/SigNoz/signoz-otel-collector v0.144.6 h1:AgblCIDlLKGtssS4ywvyEByH9fbJ7hFqZvPvUVJKwp8=
-github.com/SigNoz/signoz-otel-collector v0.144.6/go.mod h1:YRQw6ETaq7fm8ts4Itgb6wC0bVhc0+nC6PFI0MaiH9k=
+github.com/SigNoz/signoz-otel-collector v0.144.16-0.20261102045710-f531882cb133 h1:45SI7q1cTPE/rjDfLevdlTprXHiKcT5YiH5b48WdXCU=
+github.com/SigNoz/signoz-otel-collector v0.144.16-0.20261102045710-f531882cb133/go.mod h1:aOTO7iet9Ga9d3v/EkgeSZdSXEkjgVq2L0pK4tjgTEE=
 github.com/Yiling-J/theine-go v0.6.2 h1:1GeoXeQ0O0AUkiwj2S9Jc0Mzx+hpqzmqsJ4kIC4M9AY=
 github.com/Yiling-J/theine-go v0.6.2/go.mod h1:08QpMa5JZ2pKN+UJCRrCasWYO1IKCdl54Xa836rpmDU=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=

pkg/types/llmpricingruletypes/pricing.go

@@ -3,9 +3,9 @@ package llmpricingruletypes
 import (
 	"database/sql/driver"
 	"encoding/json"
-	"path"
 	"time"
 
+	"github.com/SigNoz/signoz-otel-collector/pkg/llmpricing"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -220,18 +220,14 @@ func (u *UpdatableLLMPricingRule) UnmarshalJSON(data []byte) error {
 	return u.Validate()
 }
 
-// Validate mirrors the collector's pattern check: at least one pattern, none
-// empty, all valid path.Match globs.
+// Validate requires at least one pattern and holds each to the collector's rules.
 func (u *UpdatableLLMPricingRule) Validate() error {
 	if len(u.ModelPattern) == 0 {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern must contain at least one pattern", u.Model)
 	}
 	for _, p := range u.ModelPattern {
-		if p == "" {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern must not contain an empty pattern", u.Model)
-		}
-		if _, err := path.Match(p, ""); err != nil {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern %q is not a valid glob", u.Model, p)
+		if err := llmpricing.ValidatePattern(p); err != nil {
+			return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: %v", u.Model, err)
 		}
 	}
 	return nil
@@ -270,7 +266,7 @@ func NewLLMPricingRuleFromUpdatable(u *UpdatableLLMPricingRule, orgID valuer.UUI
 func ModelMatchesAnyRule(model string, rules []*LLMPricingRule) bool {
 	for _, r := range rules {
 		for _, pattern := range r.ModelPattern {
-			if ok, err := path.Match(pattern, model); err == nil && ok {
+			if llmpricing.ParsePattern(pattern).Matches(model) {
 				return true
 			}
 		}

pkg/types/llmpricingruletypes/pricing_test.go

@@ -0,0 +1,32 @@
+package llmpricingruletypes
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestModelMatchesAnyRule(t *testing.T) {
+	opus5 := &LLMPricingRule{ModelPattern: StringSlice{"anthropic/claude-opus-5", "claude-opus-5"}}
+	opus55 := &LLMPricingRule{ModelPattern: StringSlice{"anthropic/claude-opus-5.5", "claude-opus-5.5", "claude-opus-5-5"}}
+	gpt5 := &LLMPricingRule{ModelPattern: StringSlice{"openai/gpt-5", "gpt-5"}}
+
+	testCases := []struct {
+		name  string
+		rules []*LLMPricingRule
+		model string
+		want  bool
+	}{
+		{name: "ProviderQualifiedModel", rules: []*LLMPricingRule{opus55}, model: "anthropic/claude-opus-5.5", want: true},
+		{name: "DatedSnapshot", rules: []*LLMPricingRule{opus55}, model: "claude-opus-5-5-20260921", want: true},
+		{name: "SiblingModel_NoMatch", rules: []*LLMPricingRule{gpt5}, model: "gpt-5-mini-2025-08-07", want: false},
+		{name: "SecondRuleMatches", rules: []*LLMPricingRule{opus5, opus55}, model: "claude-opus-5-5", want: true},
+		{name: "NoRules", rules: nil, model: "claude-opus-5-5", want: false},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, testCase.want, ModelMatchesAnyRule(testCase.model, testCase.rules))
+		})
+	}
+}

pkg/types/llmpricingruletypes/processorconfig_test.go

@@ -138,8 +138,7 @@ func TestUpdatableLLMPricingRuleUnmarshalJSON(t *testing.T) {
 		{name: "missing", pattern: ``, wantErr: true},
 		{name: "null", pattern: `null`, wantErr: true},
 		{name: "empty_list", pattern: `[]`, wantErr: true},
-		{name: "empty_entry", pattern: `["gpt-4o*", ""]`, wantErr: true},
-		{name: "bad_glob", pattern: `["gpt-["]`, wantErr: true},
+		{name: "mid_star", pattern: `["gpt-*-turbo"]`, wantErr: true},
 	}
 
 	for _, tc := range tests {