Merge branch 'main' into nv/cache-grid

docs/contributing/go/spanmapper.md

@@ -17,7 +17,7 @@ Condition: `model`, `llm.input_messages` (OpenInference sets `llm.model_name` fr
 | `gen_ai.response.model`, last source for the request model | vLLM, which writes only the response model |
 | `ai.model.id`, `ai.model.provider`, `ai.response.model`, `ai.response.finishReason`, `ai.prompt.messages`, `ai.response.text`, `ai.response.toolCalls`, `ai.usage.promptTokens`, `ai.usage.completionTokens` | Vercel AI SDK v4, Mastra |
 | `ai.usage.inputTokens`, `ai.usage.outputTokens`, `ai.usage.cachedInputTokens`, `ai.usage.reasoningTokens` | Vercel AI SDK v5 |
-| `langfuse.observation.model.name`, `langfuse.observation.input`, `langfuse.observation.output`, `langfuse.observation.type`, `langfuse.session.id` | Langfuse SDK v3 (Python) and v4 (JS), LiteLLM `langfuse_otel` callback |
+| `langfuse.observation.model.name`, `langfuse.session.id` | Langfuse SDK v3 |
 | `session.id` | OpenInference, Langfuse, Claude Code |
 | `gen_ai.client.session_id` | opentelemetry-hooks runner (Cursor, Copilot, Claude Code hooks) |
 | `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`, `cache_creation_tokens` | Claude Code `claude_code.llm_request` spans ([docs](https://code.claude.com/docs/en/monitoring-usage#span-attributes)) |

frontend/package.json

@@ -70,7 +70,7 @@
     "antd": "5.11.0",
     "antd-table-saveas-excel": "2.2.1",
     "antlr4": "4.13.2",
-    "axios": "1.21.0",
+    "axios": "1.18.0",
     "babel-jest": "^29.6.4",
     "chart.js": "3.9.1",
     "chartjs-adapter-date-fns": "^2.0.0",

frontend/pnpm-lock.yaml

@@ -127,8 +127,8 @@ importers:
         specifier: 4.13.2
         version: 4.13.2
       axios:
-        specifier: 1.21.0
-        version: 1.21.0
+        specifier: 1.18.0
+        version: 1.18.0
       babel-jest:
         specifier: ^29.6.4
         version: 29.6.4(@babel/core@7.29.7)
@@ -4593,8 +4593,8 @@ packages:
     resolution: {integrity: sha512-UzGt8zg7Ny8djbYMhxl2zuEevVa7r2gJjYY5Lwr1xM7+XU2nd6CkIWFTVcCIbAP63vSz71NaVyyuSk9lHKcy0A==}
     engines: {node: '>=4'}
 
-  axios@1.21.0:
-    resolution: {integrity: sha512-YCzXMB53Q9PZBsh7yN7wtapit4WepwcHS2fP8QhGsBxSz5YtgYobV7GGlWlAJi+RxfU77GQTQi2DSLUma42EYA==}
+  axios@1.18.0:
+    resolution: {integrity: sha512-E32NzpYKp++W7XRe52rHiXV2ehxmh3wbdgO7MHeFM+vqxLBYHzt0ElkiImtOBxtOmyp0yoC8C6uESVV84Y2/hw==}
 
   babel-jest@29.6.4:
     resolution: {integrity: sha512-meLj23UlSLddj6PC+YTOFRgDAtjnZom8w/ACsrx0gtPtv5cJZk0A5Unk5bV4wixD7XaPCN1fQvpww8czkZURmw==}
@@ -14283,7 +14283,7 @@ snapshots:
 
   axe-core@4.13.0: {}
 
-  axios@1.21.0:
+  axios@1.18.0:
     dependencies:
       follow-redirects: 1.16.0
       form-data: 4.0.6
@@ -20310,7 +20310,7 @@ snapshots:
 
   wait-on@7.2.0:
     dependencies:
-      axios: 1.21.0
+      axios: 1.18.0
       joi: 17.13.7
       lodash: 4.18.1
       minimist: 1.2.8

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useState } from 'react';
 import { useAppLocation } from 'lib/router/useAppLocation';
-import { Dot, Globe, Inbox, SquarePen } from '@signozhq/icons';
+import { Dot } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { Tooltip } from '@signozhq/ui/tooltip';
 import Noz from 'components/Noz/Noz';
@@ -16,6 +16,7 @@ import {
 import { selectPendingUserInputStreamCount } from 'container/AIAssistant/store/pendingInputSelectors';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
+import { Globe, Inbox, SquarePen } from '@signozhq/icons';
 
 import AnnouncementsModal from './AnnouncementsModal';
 import FeedbackModal from './FeedbackModal';

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/container/AIAssistant/components/ActionsSection/utils/__tests__/openSavedView.test.ts

@@ -18,14 +18,17 @@ import {
 import ROUTES from 'constants/routes';
 import { navigate } from 'lib/router/navigation';
 import { QueryParams } from 'constants/query';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { DataSource } from 'types/common/queryBuilder';
 
 import {
+	buildExplorerNavigationUrl,
 	findSavedViewInLists,
 	openSavedView,
 	openSavedViewByKey,
 } from '../openSavedView';
 import {
-	entityToSavedViewSource,
+	entityToDataSource,
 	isSavedViewOpenAction,
 	resolveActionEntity,
 	resolveOpenResourceType,
@@ -129,14 +132,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 +146,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 +156,7 @@ describe('resolveOpenResource', () => {
 				label: 'Open view',
 				signal: ApplyFilterSignalDTO.metrics,
 			}),
-		).toBe(SavedviewtypesSourceDTO.metrics);
+		).toBe(DataSource.METRICS);
 	});
 
 	it('normalises saved-view resource types', () => {
@@ -210,10 +209,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);
@@ -236,6 +232,23 @@ describe('findSavedViewInLists', () => {
 	});
 });
 
+describe('buildExplorerNavigationUrl', () => {
+	it('encodes composite query and view selectors', () => {
+		const url = buildExplorerNavigationUrl(
+			ROUTES.LOGS_EXPLORER,
+			{ queryType: 'builder' } as never,
+			{
+				[QueryParams.panelTypes]: PANEL_TYPES.LIST,
+				[QueryParams.viewKey]: 'view-1',
+			},
+		);
+
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+		expect(url).toContain(`${QueryParams.compositeQuery}=`);
+		expect(url).toContain(`${QueryParams.viewKey}=`);
+	});
+});
+
 describe('openSavedView', () => {
 	beforeEach(() => {
 		mockedNavigate.mockClear();
@@ -281,7 +294,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 +306,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 +318,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';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
-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 });
@@ -69,6 +72,26 @@ export function explorerRouteForSourcePage(
 	return SOURCEPAGE_VS_ROUTES[sourcePage] ?? null;
 }
 
+/**
+ * Builds an explorer URL the same way `redirectWithQueryBuilderData` does —
+ * without inheriting stale query params from the current page's `urlQuery`.
+ */
+export function buildExplorerNavigationUrl(
+	route: string,
+	query: Query,
+	searchParams: Record<string, unknown>,
+): string {
+	const params = new URLSearchParams();
+	params.set(
+		QueryParams.compositeQuery,
+		encodeURIComponent(JSON.stringify(query)),
+	);
+	Object.entries(searchParams).forEach(([key, value]) => {
+		params.set(key, JSON.stringify(value));
+	});
+	return `${route}?${params.toString()}`;
+}
+
 export function openSavedView(view: SavedviewtypesSavedViewDTO): void {
 	const route = view.source ? explorerRouteForSourcePage(view.source) : null;
 	if (!route) {
@@ -89,7 +112,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/Home/Home.tsx

@@ -38,7 +38,8 @@ import { useAppContext } from 'providers/App/App';
 import { UserPreference } from 'types/api/preferences/preference';
 import { DataSource } from 'types/common/queryBuilder';
 import { USER_ROLES } from 'types/roles';
-import { isIngestionActive, isModifierKeyPressed } from 'utils/app';
+import { isIngestionActive } from 'utils/app';
+import { isModifierKeyPressed } from 'utils/app';
 import { popupContainer } from 'utils/selectPopupContainer';
 
 import crackerUrl from '@/assets/Icons/cracker.svg';

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/SavedViewHoverCard.module.scss

@@ -77,11 +77,6 @@
 	word-break: break-all;
 }
 
-.error {
-	color: var(--l2-foreground);
-	font-size: var(--periscope-font-size-base);
-}
-
 .noFilters {
 	color: var(--l3-foreground);
 	font-size: var(--periscope-font-size-base);

frontend/src/container/SavedViews/SavedViewHoverCard.tsx

@@ -1,8 +1,13 @@
+import { CalendarClock } from '@signozhq/icons';
 import { Popover, PopoverAnchor, PopoverContent } from '@signozhq/ui/popover';
-import { SavedViewReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
-import { useAuthZ } from 'lib/authz/hooks/useAuthZ/useAuthZ';
+import { useMemo } from 'react';
+import { Typography } from '@signozhq/ui/typography';
+import CopyButton from 'periscope/components/CopyButton/CopyButton';
+import { useTimezone } from 'providers/Timezone';
 
-import SavedViewHoverCardDetails from './SavedViewHoverCardDetails';
+import { SAVED_VIEW_UPDATED_AT_FORMAT } from './constants';
+import SavedViewHighlightedExpression from './SavedViewHighlightedExpression';
+import { getSavedViewQuerySummaries } from './utils/getSavedViewQuerySummaries';
 import { SavedViewHoverCardProps } from './types';
 
 import styles from './SavedViewHoverCard.module.scss';
@@ -13,11 +18,23 @@ function SavedViewHoverCard({
 	onCardLeave,
 	onClose,
 }: SavedViewHoverCardProps): JSX.Element {
-	const { allowed: canReadAll } = useAuthZ([SavedViewReadPermission]);
+	const { formatTimezoneAdjustedTimestamp } = useTimezone();
+	const view = target?.view;
+	const querySummaries = useMemo(
+		() => (view ? getSavedViewQuerySummaries(view) : []),
+		[view],
+	);
+	const hasQueryNames = querySummaries.length > 1;
+	const copyValue = querySummaries
+		.filter(({ expression }) => expression.length > 0)
+		.map(({ queryName, expression }) =>
+			hasQueryNames ? `${queryName}: ${expression}` : expression,
+		)
+		.join('\n');
 
 	return (
 		<Popover
-			open={!!target}
+			open={!!view}
 			onOpenChange={(isOpen): void => {
 				if (!isOpen) {
 					onClose();
@@ -38,17 +55,71 @@ function SavedViewHoverCard({
 				onOpenAutoFocus={(event): void => event.preventDefault()}
 				onCloseAutoFocus={(event): void => event.preventDefault()}
 			>
-				{target && (
+				{view && (
 					<div
 						className={styles.content}
 						onMouseEnter={onCardEnter}
 						onMouseLeave={onCardLeave}
 						data-testid="saved-view-hover-card"
 					>
-						<SavedViewHoverCardDetails
-							viewId={target.viewId}
-							canReadAll={canReadAll}
-						/>
+						<div className={styles.header}>
+							<Typography.Text className={styles.name}>
+								{view.spec.displayName}
+							</Typography.Text>
+							{copyValue && (
+								<CopyButton
+									value={copyValue}
+									ariaLabel="Copy query"
+									testId="saved-view-hover-card-copy"
+								/>
+							)}
+						</div>
+						<div className={styles.query} data-testid="saved-view-hover-card-query">
+							{querySummaries.length === 0 ? (
+								<Typography.Text className={styles.noFilters}>
+									No filters
+								</Typography.Text>
+							) : (
+								querySummaries.map(({ queryName, expression, metric }) => (
+									<div key={queryName} className={styles.queryItem}>
+										{hasQueryNames && (
+											<Typography.Text className={styles.queryName}>
+												{queryName}
+											</Typography.Text>
+										)}
+										{metric && (
+											<Typography.Text className={styles.metric}>{metric}</Typography.Text>
+										)}
+										{expression && (
+											<Typography.Text className={styles.expression}>
+												<SavedViewHighlightedExpression expression={expression} />
+											</Typography.Text>
+										)}
+									</div>
+								))
+							)}
+						</div>
+						<div className={styles.updated}>
+							<Typography.Text className={styles.sectionTitle}>
+								Last updated
+							</Typography.Text>
+							{view.updatedBy && (
+								<Typography.Text className={styles.metaText}>
+									{view.updatedBy}
+								</Typography.Text>
+							)}
+							{view.updatedAt && (
+								<div className={styles.meta}>
+									<CalendarClock size={14} />
+									<Typography.Text className={styles.metaText}>
+										{formatTimezoneAdjustedTimestamp(
+											view.updatedAt,
+											SAVED_VIEW_UPDATED_AT_FORMAT,
+										)}
+									</Typography.Text>
+								</div>
+							)}
+						</div>
 					</div>
 				)}
 			</PopoverContent>

frontend/src/container/SavedViews/SavedViewHoverCardDetails.tsx

@@ -1,121 +0,0 @@
-import { useMemo } from 'react';
-import { CalendarClock } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-import { useGetSavedView } from 'api/generated/services/saved-view';
-import { withAuthZContent } from 'lib/authz/components/withAuthZ/withAuthZContent';
-import { buildSavedViewReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
-import CopyButton from 'periscope/components/CopyButton/CopyButton';
-import { useTimezone } from 'providers/Timezone';
-
-import {
-	SAVED_VIEW_LOAD_FAILED_NAME,
-	SAVED_VIEW_UPDATED_AT_FORMAT,
-} from './constants';
-import SavedViewHighlightedExpression from './SavedViewHighlightedExpression';
-import SavedViewHoverCardSkeleton from './SavedViewHoverCardSkeleton';
-import { SavedViewHoverCardDetailsProps } from './types';
-import { getSavedViewQuerySummaries } from './utils/getSavedViewQuerySummaries';
-
-import styles from './SavedViewHoverCard.module.scss';
-
-function SavedViewHoverCardDetails({
-	viewId,
-}: SavedViewHoverCardDetailsProps): JSX.Element {
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-	const { data, isLoading, isError } = useGetSavedView({ id: viewId });
-	const view = data?.data;
-	const querySummaries = useMemo(
-		() => (view ? getSavedViewQuerySummaries(view) : []),
-		[view],
-	);
-
-	if (isLoading) {
-		return <SavedViewHoverCardSkeleton />;
-	}
-
-	if (isError || !view) {
-		return (
-			<Typography.Text
-				className={styles.error}
-				data-testid="saved-view-hover-card-error"
-			>
-				{SAVED_VIEW_LOAD_FAILED_NAME}
-			</Typography.Text>
-		);
-	}
-
-	const hasQueryNames = querySummaries.length > 1;
-	const copyValue = querySummaries
-		.filter(({ expression }) => expression.length > 0)
-		.map(({ queryName, expression }) =>
-			hasQueryNames ? `${queryName}: ${expression}` : expression,
-		)
-		.join('\n');
-
-	return (
-		<>
-			<div className={styles.header}>
-				<Typography.Text className={styles.name}>
-					{view.spec.displayName}
-				</Typography.Text>
-				{copyValue && (
-					<CopyButton
-						value={copyValue}
-						ariaLabel="Copy query"
-						testId="saved-view-hover-card-copy"
-					/>
-				)}
-			</div>
-			<div className={styles.query} data-testid="saved-view-hover-card-query">
-				{querySummaries.length === 0 ? (
-					<Typography.Text className={styles.noFilters}>No filters</Typography.Text>
-				) : (
-					querySummaries.map(({ queryName, expression, metric }) => (
-						<div key={queryName} className={styles.queryItem}>
-							{hasQueryNames && (
-								<Typography.Text className={styles.queryName}>
-									{queryName}
-								</Typography.Text>
-							)}
-							{metric && (
-								<Typography.Text className={styles.metric}>{metric}</Typography.Text>
-							)}
-							{expression && (
-								<Typography.Text className={styles.expression}>
-									<SavedViewHighlightedExpression expression={expression} />
-								</Typography.Text>
-							)}
-						</div>
-					))
-				)}
-			</div>
-			<div className={styles.updated}>
-				<Typography.Text className={styles.sectionTitle}>
-					Last updated
-				</Typography.Text>
-				{view.updatedBy && (
-					<Typography.Text className={styles.metaText}>
-						{view.updatedBy}
-					</Typography.Text>
-				)}
-				{view.updatedAt && (
-					<div className={styles.meta}>
-						<CalendarClock size={14} />
-						<Typography.Text className={styles.metaText}>
-							{formatTimezoneAdjustedTimestamp(
-								view.updatedAt,
-								SAVED_VIEW_UPDATED_AT_FORMAT,
-							)}
-						</Typography.Text>
-					</div>
-				)}
-			</div>
-		</>
-	);
-}
-
-export default withAuthZContent(SavedViewHoverCardDetails, {
-	checks: ({ viewId, canReadAll }) =>
-		canReadAll ? [] : [buildSavedViewReadPermission(viewId)],
-	fallbackOnLoading: <SavedViewHoverCardSkeleton />,
-});

frontend/src/container/SavedViews/SavedViewHoverCardSkeleton.tsx

@@ -1,13 +0,0 @@
-import { Skeleton } from '@signozhq/ui/skeleton';
-
-function SavedViewHoverCardSkeleton(): JSX.Element {
-	return (
-		<Skeleton
-			active
-			paragraph={{ rows: 3, width: ['100%', '80%', '60%'] }}
-			testId="saved-view-hover-card-loading"
-		/>
-	);
-}
-
-export default SavedViewHoverCardSkeleton;

frontend/src/container/SavedViews/SavedViewsList.module.scss

@@ -54,8 +54,9 @@
 	&.isActive {
 		background-color: var(--l3-background);
 
-		.rowLink {
-			color: var(--l1-foreground);
+		.rowName {
+			--button-variant-ghost-color: var(--l1-foreground);
+			--button-variant-ghost-hover-color: var(--l1-foreground);
 		}
 	}
 }
@@ -75,32 +76,18 @@
 	opacity: 1;
 }
 
-.rowLink {
-	display: flex;
+.rowName {
+	--button-height: 100%;
+	--button-padding: 0 var(--spacing-6);
+	--button-justify-content: flex-start;
+	--button-font-size: var(--periscope-font-size-base);
+	--button-variant-ghost-color: var(--l2-foreground);
+	--button-variant-ghost-hover-color: var(--l2-foreground);
+	--button-variant-ghost-hover-background-color: transparent;
+
 	flex: 1;
-	align-items: center;
 	min-width: 0;
 	height: 100%;
-	padding: 0 var(--spacing-6);
-	border-radius: var(--radius-1);
-	color: var(--l2-foreground);
-	text-decoration: none;
-
-	&:focus-visible {
-		outline: 1px solid var(--button-focus-ring);
-		outline-offset: -1px;
-	}
-
-	&:hover {
-		color: var(--l2-foreground-hover);
-	}
-}
-
-// nowrap fills the row before the ellipsis; line clamping alone stops at the last whole word.
-.rowLinkLabel {
-	min-width: 0;
-	letter-spacing: -0.005em;
-	white-space: nowrap;
 }
 
 .loading {

frontend/src/container/SavedViews/SavedViewsList.tsx

@@ -65,11 +65,11 @@ function SavedViewsList({
 
 	const rowHover = useMemo<SavedViewsListRowHoverProps>(
 		() => ({
-			onRowEnter: (viewId, row): void => {
+			onRowEnter: (view, row): void => {
 				const listTop = listRef.current?.getBoundingClientRect().top ?? 0;
 				const rowRect = row.getBoundingClientRect();
 				onHoverCardRowEnter({
-					viewId,
+					view,
 					anchorTop: rowRect.top - listTop,
 					anchorHeight: rowRect.height,
 				});

frontend/src/container/SavedViews/SavedViewsListRow.tsx

@@ -1,8 +1,10 @@
 import cx from 'classnames';
 import { Undo2 } from '@signozhq/icons';
+import AuthZButton from 'lib/authz/components/AuthZButton/AuthZButton';
+import { buildSavedViewReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
+import { useAuthZ } from 'lib/authz/hooks/useAuthZ/useAuthZ';
 
 import SavedViewsRowButton from './SavedViewsRowButton';
-import SavedViewsRowLink from './SavedViewsRowLink';
 import SavedViewsRowMenu from './SavedViewsRowMenu';
 import { SavedViewsListRowProps } from './types';
 
@@ -16,17 +18,42 @@ function SavedViewsListRow({
 	onAction,
 	hover,
 }: SavedViewsListRowProps): JSX.Element {
+	const name = view.spec.displayName;
+	const readPermission = buildSavedViewReadPermission(view.id);
+	// Same cached check as the button; gates the hover card.
+	const { isLoading, deniedPermissions } = useAuthZ([readPermission]);
+	const canRead = !isLoading && deniedPermissions.length === 0;
+
 	return (
 		<div
 			className={cx(styles.row, { [styles.isActive]: isActive })}
 			data-testid="saved-views-row"
 			data-view-id={view.id}
-			onMouseEnter={(event): void =>
-				hover.onRowEnter(view.id, event.currentTarget)
-			}
+			onMouseEnter={(event): void => {
+				if (canRead) {
+					hover.onRowEnter(view, event.currentTarget);
+				}
+			}}
 			onMouseLeave={hover.onRowLeave}
 		>
-			<SavedViewsRowLink view={view} isActive={isActive} onSelect={onSelect} />
+			<div className={styles.rowName}>
+				<AuthZButton
+					checks={[readPermission]}
+					size="md"
+					variant="ghost"
+					color="secondary"
+					width="100%"
+					textOverflow="ellipsis"
+					onClick={(): void => {
+						if (!isActive) {
+							onSelect(view);
+						}
+					}}
+					testId="saved-views-row-name"
+				>
+					{name}
+				</AuthZButton>
+			</div>
 			{isActive && (
 				<SavedViewsRowButton
 					icon={<Undo2 size={14} />}

frontend/src/container/SavedViews/SavedViewsPanel.tsx

@@ -5,11 +5,7 @@ import { Typography } from '@signozhq/ui/typography';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 
 import { AuthZGuardContent } from 'lib/authz/components/AuthZGuard/AuthZGuardContent';
-import {
-	SavedViewListPermission,
-	SavedViewReadPermission,
-} from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
-import { useAuthZ } from 'lib/authz/hooks/useAuthZ/useAuthZ';
+import { SavedViewListPermission } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
 
 import SavedViewsIconButton from './SavedViewsIconButton';
 import SavedViewsList from './SavedViewsList';
@@ -25,8 +21,6 @@ function SavedViewsPanel({
 	onClose?: () => void;
 }): JSX.Element {
 	const [search, setSearch] = useState('');
-	// Batched with the list check, so the hover card reads it from cache.
-	useAuthZ([SavedViewReadPermission]);
 
 	return (
 		<div

frontend/src/container/SavedViews/SavedViewsRowLink.tsx

@@ -1,57 +0,0 @@
-import { MouseEvent, useMemo } from 'react';
-import { Typography } from '@signozhq/ui/typography';
-import { AppLink } from 'lib/router/AppLink';
-import { useAppLocation } from 'lib/router/useAppLocation';
-import { isModifierKeyPressed } from 'utils/app';
-import { useTimeSearchParams } from 'hooks/useTimeSearchParams';
-
-import { SavedViewsRowLinkProps } from './types';
-import { getSavedViewPath } from './utils/getSavedViewPath';
-
-import styles from './SavedViewsList.module.scss';
-
-function SavedViewsRowLink({
-	view,
-	isActive,
-	onSelect,
-}: SavedViewsRowLinkProps): JSX.Element {
-	const { pathname } = useAppLocation();
-	const timeSearch = useTimeSearchParams();
-	const path = useMemo(
-		() => getSavedViewPath(pathname, view, timeSearch),
-		[pathname, view, timeSearch],
-	);
-
-	// Opening in a new tab or window is left to the browser.
-	const handleClick = (event: MouseEvent<HTMLAnchorElement>): void => {
-		if (isModifierKeyPressed(event) || event.shiftKey) {
-			return;
-		}
-		event.preventDefault();
-		if (!isActive) {
-			onSelect(view);
-		}
-	};
-
-	return (
-		<AppLink
-			to={path}
-			className={styles.rowLink}
-			aria-current={isActive ? 'page' : undefined}
-			onClick={handleClick}
-			data-testid="saved-views-row-name"
-		>
-			<Typography.Text
-				as="span"
-				size="base"
-				weight="normal"
-				truncate={1}
-				className={styles.rowLinkLabel}
-			>
-				{view.spec.displayName}
-			</Typography.Text>
-		</AppLink>
-	);
-}
-
-export default SavedViewsRowLink;

frontend/src/container/SavedViews/__tests__/SavedViewHoverCard.test.tsx

@@ -8,8 +8,6 @@ import {
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
@@ -18,7 +16,7 @@ import {
 	SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS,
 } from '../constants';
 import SavedViewsPanel from '../SavedViewsPanel';
-import { API, mockSavedViewsApi } from './savedViewsApiMock';
+import { mockSavedViewsApi } from './savedViewsApiMock';
 import {
 	expectUsable,
 	explorerUrl,
@@ -141,11 +139,9 @@ function advance(ms: number): void {
 	});
 }
 
-// Resolves once the card has fetched its view.
-async function openCard(name: string): Promise<HTMLElement> {
+function openCard(name: string): void {
 	fireEvent.mouseEnter(row(name));
 	advance(SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS);
-	return screen.findByTestId('saved-view-hover-card-query');
 }
 
 describe('SavedViewHoverCard', () => {
@@ -172,8 +168,7 @@ describe('SavedViewHoverCard', () => {
 			expect(card()).toBeNull();
 
 			advance(1);
-			expect(card()).toBeInTheDocument();
-			await waitFor(() => expect(card()).toHaveTextContent('Errors'));
+			expect(card()).toHaveTextContent('Errors');
 		});
 
 		it('does not open when the pointer leaves before the delay', async () => {
@@ -189,7 +184,7 @@ describe('SavedViewHoverCard', () => {
 
 		it('stays open while the pointer moves into the card', async () => {
 			await renderPanel();
-			await openCard('Errors');
+			openCard('Errors');
 
 			fireEvent.mouseLeave(row('Errors'));
 			fireEvent.mouseEnter(card() as HTMLElement);
@@ -203,7 +198,7 @@ describe('SavedViewHoverCard', () => {
 
 		it('closes on leaving the row and reopens for the next row after the delay', async () => {
 			await renderPanel();
-			await openCard('Errors');
+			openCard('Errors');
 
 			fireEvent.mouseLeave(row('Errors'));
 			fireEvent.mouseEnter(row('Slow spans'));
@@ -211,12 +206,12 @@ describe('SavedViewHoverCard', () => {
 			expect(card()).toBeNull();
 
 			advance(SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS);
-			await waitFor(() => expect(card()).toHaveTextContent('Slow spans'));
+			expect(card()).toHaveTextContent('Slow spans');
 		});
 
 		it('closes when the row menu is pressed', async () => {
 			await renderPanel();
-			await openCard('Errors');
+			openCard('Errors');
 
 			fireEvent.click(within(row('Errors')).getByTestId('saved-views-row-menu'));
 
@@ -227,17 +222,19 @@ describe('SavedViewHoverCard', () => {
 	describe('content', () => {
 		it('shows the filter, the updater and the update time', async () => {
 			await renderPanel();
-			const query = await openCard('Errors');
+			openCard('Errors');
 
 			const content = card() as HTMLElement;
-			expect(query).toHaveTextContent('has_error = true');
+			expect(
+				within(content).getByTestId('saved-view-hover-card-query'),
+			).toHaveTextContent('has_error = true');
 			expect(content).toHaveTextContent('editor@signoz.io');
 			expect(content).toHaveTextContent('Sep 28, 2026');
 		});
 
 		it('copies the filter expression', async () => {
 			await renderPanel();
-			await openCard('Errors');
+			openCard('Errors');
 
 			fireEvent.click(screen.getByTestId('saved-view-hover-card-copy'));
 
@@ -246,8 +243,9 @@ describe('SavedViewHoverCard', () => {
 
 		it('names each query when there are several, and copies them per line', async () => {
 			await renderPanel();
-			const query = await openCard('Errors and slow');
+			openCard('Errors and slow');
 
+			const query = screen.getByTestId('saved-view-hover-card-query');
 			expect(query).toHaveTextContent('A');
 			expect(query).toHaveTextContent('B');
 			fireEvent.click(screen.getByTestId('saved-view-hover-card-copy'));
@@ -259,74 +257,21 @@ describe('SavedViewHoverCard', () => {
 
 		it('says there are no filters, with nothing to copy', async () => {
 			await renderPanel();
-			const query = await openCard('Everything');
+			openCard('Everything');
 
-			expect(query).toHaveTextContent('No filters');
+			expect(screen.getByTestId('saved-view-hover-card-query')).toHaveTextContent(
+				'No filters',
+			);
 			expect(screen.queryByTestId('saved-view-hover-card-copy')).toBeNull();
 		});
 
 		it('shows the metric of a metrics query', async () => {
 			await renderPanel(SavedviewtypesSourceDTO.metrics, DataSource.METRICS);
-			const query = await openCard('Request rate');
+			openCard('Request rate');
 
+			const query = screen.getByTestId('saved-view-hover-card-query');
 			expect(query).toHaveTextContent('app.requests · rate · sum');
 			expect(query).not.toHaveTextContent('No filters');
 		});
 	});
-
-	describe('fetching', () => {
-		it('shows the query from the view fetch, not from the list', async () => {
-			server.use(
-				rest.get(API, (_req, res, ctx) =>
-					res(
-						ctx.json({
-							status: 'success',
-							data: [{ ...errors, spec: { ...errors.spec, queries: [] } }],
-						}),
-					),
-				),
-			);
-			await renderPanel();
-
-			const query = await openCard('Errors');
-
-			expect(query).toHaveTextContent('has_error = true');
-		});
-
-		it('fetches the view again on every open', async () => {
-			let fetches = 0;
-			server.use(
-				rest.get(`${API}/:id`, (_req, res, ctx) => {
-					fetches += 1;
-					return res(ctx.json({ status: 'success', data: errors }));
-				}),
-			);
-			await renderPanel();
-
-			await openCard('Errors');
-			fireEvent.mouseLeave(row('Errors'));
-			advance(SAVED_VIEW_HOVER_CARD_CLOSE_DELAY_MS);
-			expect(card()).toBeNull();
-			await openCard('Errors');
-
-			await waitFor(() => expect(fetches).toBe(2));
-		});
-
-		it('says the view failed to load when its fetch fails', async () => {
-			server.use(
-				rest.get(`${API}/:id`, (_req, res, ctx) =>
-					res(ctx.status(500), ctx.json({ status: 'error' })),
-				),
-			);
-			await renderPanel();
-
-			fireEvent.mouseEnter(row('Errors'));
-			advance(SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS);
-
-			await expect(
-				screen.findByTestId('saved-view-hover-card-error'),
-			).resolves.toHaveTextContent('View failed to load');
-			expect(screen.queryByTestId('saved-view-hover-card-copy')).toBeNull();
-		});
-	});
 });

frontend/src/container/SavedViews/__tests__/SavedViews.authz.test.tsx

@@ -1,10 +1,6 @@
 import { fireEvent, screen, waitFor, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import {
-	AuthtypesTransactionDTO,
-	SavedviewtypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { QueryParams } from 'constants/query';
+import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import {
@@ -13,42 +9,34 @@ import {
 	buildSavedViewUpdatePermission,
 	SavedViewCreatePermission,
 	SavedViewListPermission,
-	SavedViewReadPermission,
 } from 'lib/authz/hooks/useAuthZ/permissions/saved-view.permissions';
 import {
 	AUTHZ_CHECK_URL,
-	authzMockResponse,
 	setupAuthzDeny,
 } from 'lib/authz/utils/authz-test-utils';
 import { server } from 'mocks-server/server';
 import { rest } from 'msw';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS } from '../constants';
 import SavedViewsHeader from '../SavedViewsHeader';
 import SavedViewsPanel from '../SavedViewsPanel';
 import { API, mockSavedViewsApi } from './savedViewsApiMock';
 import {
-	expectUsable,
 	explorerUrl,
 	makeView,
 	MENU_CHECK_TIMEOUT,
 	queryWith,
 	renderWithExplorerProviders,
-	urlParam,
 	viewUrl,
 } from './savedViewsTestUtils';
 
 const PATH = ROUTES.TRACES_EXPLORER;
-const HOVER_CARD_TIMEOUT = { timeout: SAVED_VIEW_HOVER_CARD_OPEN_DELAY_MS * 3 };
 
 const errors = makeView({ id: 'view-1', displayName: 'Errors' });
 const slow = makeView({ id: 'view-2', displayName: 'Slow spans' });
 
-function renderPanel(
-	url = explorerUrl(PATH, {}),
-): ReturnType<typeof renderWithExplorerProviders> {
-	return renderWithExplorerProviders(
+function renderPanel(url = explorerUrl(PATH, {})): void {
+	renderWithExplorerProviders(
 		<SavedViewsPanel
 			source={SavedviewtypesSourceDTO.traces}
 			onClose={jest.fn()}
@@ -80,37 +68,6 @@ async function openRowMenu(name: string): Promise<void> {
 	fireEvent.click(within(rowNamed(name)).getByTestId('saved-views-row-menu'));
 }
 
-// Records every check, answered by `isGranted`.
-function recordChecks(
-	isGranted: (transaction: AuthtypesTransactionDTO) => boolean = (): boolean =>
-		true,
-): AuthtypesTransactionDTO[] {
-	const checks: AuthtypesTransactionDTO[] = [];
-	server.use(
-		rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-			const payload = (await req.json()) as AuthtypesTransactionDTO[];
-			checks.push(...payload);
-			return res(ctx.json(authzMockResponse(payload, payload.map(isGranted))));
-		}),
-	);
-	return checks;
-}
-
-const readSelectors = (checks: AuthtypesTransactionDTO[]): string[] =>
-	checks
-		.filter((transaction) => transaction.relation === 'read')
-		.map((transaction) => transaction.object.selector);
-
-async function hoverRow(name: string): Promise<HTMLElement> {
-	await screen.findAllByTestId('saved-views-row');
-	fireEvent.mouseEnter(rowNamed(name));
-	return screen.findByTestId(
-		'saved-view-hover-card',
-		undefined,
-		HOVER_CARD_TIMEOUT,
-	);
-}
-
 // Resolves once the row's check is back, so its state is final.
 async function settledRow(testId: string): Promise<HTMLElement> {
 	await waitFor(
@@ -141,51 +98,21 @@ describe('SavedViews - AuthZ', () => {
 		expect(screen.queryByTestId('saved-views-search')).toBeNull();
 	});
 
-	it('runs no read check per row', async () => {
+	it('disables only the views it cannot read', async () => {
 		mockSavedViewsApi([errors, slow]);
-		const checks = recordChecks();
+		server.use(setupAuthzDeny(buildSavedViewReadPermission(errors.id)));
 		renderPanel();
 
-		// The menu checks go out after any check the rows made on mount.
-		await openRowMenu('Errors');
-		await settledRow('saved-views-row-menu-item-delete');
-		expect(checks.map((transaction) => transaction.relation)).toContain('delete');
-		expect(readSelectors(checks)).toStrictEqual(['*']);
-	});
-
-	it('opens a view it cannot read, then the header says no access', async () => {
-		mockSavedViewsApi([errors]);
-		server.use(setupAuthzDeny(buildSavedViewReadPermission(errors.id)));
-		const { history } = renderWithExplorerProviders(
-			<>
-				<SavedViewsHeader
-					source={SavedviewtypesSourceDTO.traces}
-					onOpenViews={jest.fn()}
-					onToggleViews={jest.fn()}
-				/>
-				<SavedViewsPanel
-					source={SavedviewtypesSourceDTO.traces}
-					onClose={jest.fn()}
-				/>
-			</>,
-			explorerUrl(PATH, {}),
-		);
-
 		await screen.findAllByTestId('saved-views-row');
-		const name = within(rowNamed('Errors')).getByTestId('saved-views-row-name');
-		expectUsable(name);
-		await userEvent.click(name);
-
+		const nameOf = (view: string): HTMLElement =>
+			within(rowNamed(view)).getByTestId('saved-views-row-name');
 		await waitFor(() =>
-			expect(urlParam(history, QueryParams.viewKey)).toBe(
-				JSON.stringify(errors.id),
-			),
+			expect(nameOf('Errors')).toHaveAttribute('aria-disabled', 'true'),
 		);
 		await waitFor(() =>
-			expect(screen.getByTestId('saved-views-name')).toHaveTextContent(
-				'No view access',
-			),
+			expect(nameOf('Slow spans')).not.toHaveAttribute('aria-busy'),
 		);
+		expect(nameOf('Slow spans')).not.toHaveAttribute('aria-disabled', 'true');
 	});
 
 	it('keeps the row menu on a view it cannot read', async () => {
@@ -206,58 +133,6 @@ describe('SavedViews - AuthZ', () => {
 		).resolves.not.toHaveAttribute('data-disabled');
 	});
 
-	it('shows the denied callout in the hover card of a view it cannot read, without fetching it', async () => {
-		let fetches = 0;
-		mockSavedViewsApi([errors]);
-		server.use(
-			setupAuthzDeny(
-				SavedViewReadPermission,
-				buildSavedViewReadPermission(errors.id),
-			),
-			rest.get(`${API}/:id`, (_req, res, ctx) => {
-				fetches += 1;
-				return res(ctx.json({ status: 'success', data: errors }));
-			}),
-		);
-		renderPanel();
-
-		const card = await hoverRow('Errors');
-		await expect(
-			within(card).findByText(/not authorized/i),
-		).resolves.toBeInTheDocument();
-		expect(within(card).queryByTestId('saved-view-hover-card-query')).toBeNull();
-		expect(fetches).toBe(0);
-	});
-
-	it('skips the read check of the hovered view with read on every view', async () => {
-		mockSavedViewsApi([errors]);
-		const checks = recordChecks();
-		renderPanel();
-
-		const card = await hoverRow('Errors');
-
-		await expect(
-			within(card).findByTestId('saved-view-hover-card-query'),
-		).resolves.toHaveTextContent('has_error = true');
-		expect(readSelectors(checks)).toStrictEqual(['*']);
-	});
-
-	it('checks read on the hovered view without read on every view', async () => {
-		mockSavedViewsApi([errors]);
-		const checks = recordChecks(
-			(transaction) =>
-				transaction.relation !== 'read' || transaction.object.selector !== '*',
-		);
-		renderPanel();
-
-		const card = await hoverRow('Errors');
-
-		await expect(
-			within(card).findByTestId('saved-view-hover-card-query'),
-		).resolves.toHaveTextContent('has_error = true');
-		expect(readSelectors(checks)).toStrictEqual(['*', errors.id]);
-	});
-
 	it('disables creating without create', async () => {
 		mockSavedViewsApi([]);
 		server.use(setupAuthzDeny(SavedViewCreatePermission));

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/__tests__/SavedViewsPanel.list.test.tsx

@@ -1,14 +1,9 @@
+import { screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { toast } from '@signozhq/ui/sonner';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
-import {
-	fireEvent,
-	screen,
-	userEvent,
-	waitFor,
-	within,
-} from 'tests/test-utils';
 
 import SavedViewsPanel from '../SavedViewsPanel';
 import { mockSavedViewsApi } from './savedViewsApiMock';
@@ -19,7 +14,6 @@ import {
 	renderWithExplorerProviders,
 	urlParam,
 	viewUrl,
-	withGlobalTime,
 } from './savedViewsTestUtils';
 
 jest.mock('@signozhq/ui/sonner', () => ({
@@ -59,9 +53,6 @@ const row = (name: string): HTMLElement =>
 		.getAllByTestId('saved-views-row')
 		.find((element) => element.textContent?.includes(name)) as HTMLElement;
 
-const rowName = (name: string): HTMLElement =>
-	within(row(name)).getByTestId('saved-views-row-name');
-
 describe('SavedViewsPanel list', () => {
 	beforeEach(() => {
 		localStorage.clear();
@@ -94,8 +85,9 @@ describe('SavedViewsPanel list', () => {
 		const { history } = renderPanel();
 
 		await screen.findByTestId('saved-views-list');
-		await waitFor(() => expectUsable(rowName('Slow spans')));
-		await userEvent.click(rowName('Slow spans'));
+		const name = within(row('Slow spans')).getByTestId('saved-views-row-name');
+		await waitFor(() => expectUsable(name));
+		await userEvent.click(name);
 
 		await waitFor(() =>
 			expect(urlParam(history, QueryParams.viewKey)).toBe(
@@ -104,60 +96,6 @@ describe('SavedViewsPanel list', () => {
 		);
 	});
 
-	it('links each row to its view in the current time range', async () => {
-		mockSavedViewsApi([mine, alsoMine]);
-		renderWithExplorerProviders(
-			withGlobalTime(
-				<SavedViewsPanel
-					source={SavedviewtypesSourceDTO.traces}
-					onClose={jest.fn()}
-				/>,
-				{ selectedTime: '1h' },
-			),
-			explorerUrl(PATH, {}),
-		);
-
-		await screen.findByTestId('saved-views-list');
-		const url = new URL(
-			rowName('Slow spans').getAttribute('href') as string,
-			window.location.origin,
-		);
-
-		expect(url.pathname).toBe(PATH);
-		expect(url.searchParams.get(QueryParams.viewKey)).toBe(
-			JSON.stringify(alsoMine.id),
-		);
-		expect(url.searchParams.get(QueryParams.panelTypes)).toBe(
-			JSON.stringify(alsoMine.spec.panelType),
-		);
-		expect(url.searchParams.has(QueryParams.compositeQuery)).toBe(true);
-		expect(url.searchParams.get(QueryParams.relativeTime)).toBe('1h');
-	});
-
-	it.each([
-		['Ctrl', { ctrlKey: true }],
-		['Cmd', { metaKey: true }],
-		['Shift', { shiftKey: true }],
-	])('leaves a %s click on a row to the browser', async (_key, modifiers) => {
-		mockSavedViewsApi([mine, alsoMine]);
-		const { history } = renderPanel();
-		await screen.findByTestId('saved-views-list');
-		const before = history.location.search;
-
-		let defaultPrevented: boolean | undefined;
-		const recordClick = (event: MouseEvent): void => {
-			defaultPrevented = event.defaultPrevented;
-			// jsdom cannot open a new tab.
-			event.preventDefault();
-		};
-		document.addEventListener('click', recordClick);
-		fireEvent.click(rowName('Slow spans'), modifiers);
-		document.removeEventListener('click', recordClick);
-
-		expect(defaultPrevented).toBe(false);
-		expect(history.location.search).toBe(before);
-	});
-
 	it('marks the open view and clears it from its row', async () => {
 		mockSavedViewsApi([mine, alsoMine]);
 		const { history } = renderPanel(viewUrl(PATH, mine));
@@ -182,8 +120,9 @@ describe('SavedViewsPanel list', () => {
 		await screen.findByTestId('saved-views-list');
 		const before = history.location.search;
 
-		expect(rowName('Errors')).toHaveAttribute('aria-current', 'page');
-		await userEvent.click(rowName('Errors'));
+		await userEvent.click(
+			within(row('Errors')).getByTestId('saved-views-row-name'),
+		);
 
 		expect(history.location.search).toBe(before);
 	});

frontend/src/container/SavedViews/__tests__/SavedViewsPanel.rowMenu.test.tsx

@@ -4,7 +4,6 @@ import { toast } from '@signozhq/ui/sonner';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
 
 import SavedViewsHeader from '../SavedViewsHeader';
 import SavedViewsPanel from '../SavedViewsPanel';
@@ -17,7 +16,6 @@ import {
 	renderWithExplorerProviders,
 	urlParam,
 	viewUrl,
-	withGlobalTime,
 } from './savedViewsTestUtils';
 
 const mockCopy = jest.fn();
@@ -34,8 +32,6 @@ jest.mock('@signozhq/ui/sonner', () => ({
 }));
 
 const PATH = ROUTES.TRACES_EXPLORER;
-const START_MS = 1700000000000;
-const END_MS = 1700003600000;
 
 const errors = makeView({ id: 'view-1', displayName: 'Errors' });
 const slow = makeView({
@@ -123,22 +119,9 @@ describe('SavedViewsPanel row menu', () => {
 		);
 	});
 
-	it('copies a link that opens the view with its query, tab and time range', async () => {
+	it('copies a link that opens the view with its query and tab', async () => {
 		mockSavedViewsApi([errors, slow]);
-		renderWithExplorerProviders(
-			withGlobalTime(
-				<SavedViewsPanel
-					source={SavedviewtypesSourceDTO.traces}
-					onClose={jest.fn()}
-				/>,
-				{
-					selectedTime: 'custom',
-					minTime: START_MS * NANO_SECOND_MULTIPLIER,
-					maxTime: END_MS * NANO_SECOND_MULTIPLIER,
-				},
-			),
-			explorerUrl(PATH, {}),
-		);
+		renderPanelWithHeader();
 
 		await chooseFromRowMenu('Slow spans', 'Copy link');
 
@@ -154,9 +137,6 @@ describe('SavedViewsPanel row menu', () => {
 		expect(
 			decodeURIComponent(link.searchParams.get(QueryParams.compositeQuery) ?? ''),
 		).toContain('duration_nano > 1000');
-		expect(link.searchParams.get(QueryParams.startTime)).toBe(String(START_MS));
-		expect(link.searchParams.get(QueryParams.endTime)).toBe(String(END_MS));
-		expect(link.searchParams.has(QueryParams.relativeTime)).toBe(false);
 		expect(toast.success).toHaveBeenCalledWith('Link copied', expect.anything());
 	});
 

frontend/src/container/SavedViews/__tests__/savedViewsTestUtils.tsx

@@ -28,7 +28,6 @@ import { TestRouter } from 'tests/router';
 import { getAppContextMock } from 'tests/test-utils';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
 import { __setSearchParamsGetterForTest } from 'utils/getUnstableCurrentSearchParams';
 
 import { getSavedViewQuery } from '../utils/getSavedViewQuery';
@@ -161,23 +160,6 @@ export function viewUrl(
 
 const mockStore = configureStore([thunk]);
 
-export function withGlobalTime(
-	ui: ReactElement,
-	globalTime: Partial<GlobalReducer>,
-): ReactElement {
-	const state = store.getState();
-	return (
-		<Provider
-			store={mockStore({
-				...state,
-				globalTime: { ...state.globalTime, ...globalTime },
-			})}
-		>
-			{ui}
-		</Provider>
-	);
-}
-
 // What the explorer page does around the header: writes its default query to a
 // bare url, and sets the provider's tab from the url (the provider alone seeds
 // it from the raw, still JSON-quoted param).

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/hooks/useSavedViewRowActions.ts

@@ -12,10 +12,11 @@ import {
 	SavedviewtypesSourceDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import { ErrorType } from 'api/generatedAPIInstance';
+import { QueryParams } from 'constants/query';
+import { buildExplorerNavigationUrl } from 'container/AIAssistant/components/ActionsSection/utils/openSavedView';
 import { useAppLocation } from 'lib/router/useAppLocation';
 import { getAbsoluteUrl } from 'utils/basePath';
 import { toAPIError } from 'utils/errorUtils';
-import { useTimeSearchParams } from 'hooks/useTimeSearchParams';
 
 import {
 	SAVED_VIEW_SCHEMA_VERSION,
@@ -23,7 +24,7 @@ import {
 } from '../constants';
 import { SavedViewEventKeys, SavedViewEvents } from '../events';
 import { UseSavedViewRowActionsResult } from '../types';
-import { getSavedViewPath } from '../utils/getSavedViewPath';
+import { getSavedViewQuery } from '../utils/getSavedViewQuery';
 import { invalidateSavedViews } from '../utils/invalidateSavedViews';
 import { useSavedViewLogEvent } from './useSavedViewLogEvent';
 
@@ -42,7 +43,6 @@ export function useSavedViewRowActions(
 ): UseSavedViewRowActionsResult {
 	const queryClient = useQueryClient();
 	const { pathname } = useAppLocation();
-	const timeSearch = useTimeSearchParams();
 	const [, copyToClipboard] = useCopyToClipboard();
 	const logSavedViewEvent = useSavedViewLogEvent(source);
 	const { mutateAsync: updateSavedView, isLoading: isRenaming } =
@@ -52,15 +52,17 @@ export function useSavedViewRowActions(
 
 	const copyViewLink = useCallback(
 		(view: SavedviewtypesSavedViewDTO): void => {
-			copyToClipboard(
-				getAbsoluteUrl(getSavedViewPath(pathname, view, timeSearch)),
-			);
+			const path = buildExplorerNavigationUrl(pathname, getSavedViewQuery(view), {
+				[QueryParams.panelTypes]: view.spec.panelType,
+				[QueryParams.viewKey]: view.id,
+			});
+			copyToClipboard(getAbsoluteUrl(path));
 			toast.success('Link copied', { position: SAVED_VIEW_TOAST_POSITION });
 			logSavedViewEvent(SavedViewEvents.LinkCopied, {
 				[SavedViewEventKeys.ViewId]: view.id,
 			});
 		},
-		[pathname, timeSearch, copyToClipboard, logSavedViewEvent],
+		[pathname, copyToClipboard, logSavedViewEvent],
 	);
 
 	const copyViewId = useCallback(

frontend/src/container/SavedViews/stories/SavedViews.stories.mocks.tsx

@@ -45,7 +45,6 @@ import {
 	savedViewsListResponse,
 	type SavedViewSource,
 	unreadableViewId,
-	withLongName,
 } from './__story_mockdata__/savedViews';
 
 import SavedViewsHeader from '../SavedViewsHeader';
@@ -74,13 +73,7 @@ const controls = {
 	unreadableView: toggleControl('Unreadable view', {
 		group: VIEW,
 		description:
-			'Denies `read` on the first view created by others, and so on `saved-view:*`, on top of the Access controls: its row still opens it, and the header then shows No view access, as with Open view on `created-by-others`. Its hover card shows the permission callout in place of the query.',
-		value: false,
-	}),
-	viewPending: toggleControl('View fetch pending', {
-		group: VIEW,
-		description:
-			'Holds every `GET /saved_views/:id` open, so a hover card stays on its loading skeleton.',
+			'Denies `read` on the first view created by others alone, on top of the Access controls: its row greys out, and with Open view on `created-by-others` the header shows No view access.',
 		value: false,
 	}),
 	createdByMe: countControl('Created by me', {
@@ -94,12 +87,6 @@ const controls = {
 		value: 4,
 		max: SAVED_VIEWS_MAX,
 	}),
-	longNames: toggleControl('Long names', {
-		group: LIST,
-		description:
-			'Lengthens every view name past the sidebar width, so rows and the open view name truncate.',
-		value: false,
-	}),
 };
 
 type SavedViewsValues = MockControlValues<typeof controls>;
@@ -112,7 +99,7 @@ const viewDenied = (
 ): boolean =>
 	transaction.relation === 'read' &&
 	transaction.object.resource.kind === 'saved-view' &&
-	[deniedId, '*'].includes(transaction.object.selector);
+	transaction.object.selector === deniedId;
 
 const definition = defineStoryMocks({
 	controls,
@@ -120,14 +107,7 @@ const definition = defineStoryMocks({
 		values: SavedViewsValues & AuthzArgs,
 		response,
 	): RequestHandler[] => {
-		const {
-			source,
-			openView,
-			viewPending,
-			createdByMe,
-			createdByOthers,
-			longNames,
-		} = values;
+		const { source, openView, createdByMe, createdByOthers } = values;
 
 		// What the panel writes stays in this handler set until a control changes.
 		const created: SavedviewtypesSavedViewDTO[] = [];
@@ -138,14 +118,8 @@ const definition = defineStoryMocks({
 			view: SavedviewtypesSavedViewDTO,
 		): SavedviewtypesSavedViewDTO => ({ ...view, ...updated.get(view.id) });
 
-		const named = (
-			view: SavedviewtypesSavedViewDTO,
-		): SavedviewtypesSavedViewDTO => (longNames ? withLongName(view) : view);
-
 		const findView = (id: string): SavedviewtypesSavedViewDTO | undefined => {
-			const stored = savedViewById(id);
-			const view =
-				created.find((item) => item.id === id) ?? (stored && named(stored));
+			const view = created.find((item) => item.id === id) ?? savedViewById(id);
 
 			return view && !deleted.has(id) ? current(view) : undefined;
 		};
@@ -169,7 +143,7 @@ const definition = defineStoryMocks({
 
 					return {
 						...list,
-						data: [...(list.data ?? []).map(named), ...created]
+						data: [...(list.data ?? []), ...created]
 							.filter((view) => !deleted.has(view.id))
 							.map(current),
 					};
@@ -177,10 +151,6 @@ const definition = defineStoryMocks({
 			),
 
 			rest.get(`${API}/:id`, (req, res, ctx) => {
-				if (viewPending) {
-					return res(ctx.delay('infinite'));
-				}
-
 				if (openError) {
 					return res(ctx.status(openError.status), ctx.json(openError.body));
 				}
@@ -304,9 +274,7 @@ const isPending = (element: HTMLElement): boolean =>
 	element.hasAttribute('data-loading');
 
 const isDisabled = (element: HTMLElement): boolean =>
-	element.hasAttribute('disabled') ||
-	element.hasAttribute('data-disabled') ||
-	element.getAttribute('aria-disabled') === 'true';
+	element.hasAttribute('disabled') || element.hasAttribute('data-disabled');
 
 export const expectDisabled = (
 	find: FindElement,
@@ -334,30 +302,6 @@ export const rowName =
 	(): HTMLElement =>
 		within(row).getByTestId('saved-views-row-name');
 
-const hoverRow = async (row: HTMLElement): Promise<HTMLElement> => {
-	await userEvent.hover(row);
-
-	return screen.findByTestId('saved-view-hover-card', undefined, UNTIL_LOADED);
-};
-
-const searchViews = async (
-	canvasElement: HTMLElement,
-	text: string,
-): Promise<void> => {
-	const search = await within(canvasElement).findByTestId(
-		'saved-views-search',
-		undefined,
-		UNTIL_LOADED,
-	);
-
-	await userEvent.type(search, text);
-};
-
-const clickWhenEnabled = async (find: FindElement): Promise<void> => {
-	await expectDisabled(find, false);
-	await userEvent.click(find());
-};
-
 export const openRowMenu = async (row: HTMLElement): Promise<void> => {
 	await userEvent.click(within(row).getByTestId('saved-views-row-menu'));
 	await screen.findByRole('menu', undefined, UNTIL_LOADED);
@@ -383,115 +327,3 @@ export const openSaveChangesMenu = async (
 
 export const saveChangesItem = (key: 'save-as-new' | 'update'): FindElement =>
 	byTestId(`saved-views-save-changes-item-${key}`);
-
-type PlayContext = {
-	canvasElement: HTMLElement;
-	args: { source: SavedViewSource };
-};
-
-export const hoverFirstRow = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	const [row] = await findRows(canvasElement);
-	const card = await hoverRow(row);
-
-	await within(card).findByTestId(
-		'saved-view-hover-card-query',
-		undefined,
-		UNTIL_LOADED,
-	);
-};
-
-export const hoverFirstRowLoading = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	const [row] = await findRows(canvasElement);
-	const card = await hoverRow(row);
-
-	await within(card).findByTestId(
-		'saved-view-hover-card-loading',
-		undefined,
-		UNTIL_LOADED,
-	);
-};
-
-export const searchWithNoResults = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	await searchViews(canvasElement, 'nothing like this');
-	await screen.findByTestId('saved-views-list-no-results');
-};
-
-export const openCreateModal = async (): Promise<void> => {
-	await clickWhenEnabled(byTestId('saved-views-create'));
-	await screen.findByTestId('save-view-modal');
-};
-
-export const openEditDetailsModal = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	const [row] = await findRows(canvasElement);
-
-	await openRowMenu(row);
-	await clickWhenEnabled(rowMenuItem('editDetails'));
-	await screen.findByTestId('save-view-modal');
-};
-
-export const openSaveAsNewModal = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	await openSaveChangesMenu(canvasElement);
-	await clickWhenEnabled(saveChangesItem('save-as-new'));
-	await screen.findByTestId('save-view-modal');
-};
-
-export const openDeleteDialog = async ({
-	canvasElement,
-}: PlayContext): Promise<void> => {
-	const [row] = await findRows(canvasElement);
-
-	await openRowMenu(row);
-	await clickWhenEnabled(rowMenuItem('delete'));
-	await screen.findByTestId('delete-saved-view-confirm');
-};
-
-const findUnreadableRow = async ({
-	canvasElement,
-	args,
-}: PlayContext): Promise<HTMLElement> => {
-	const rows = await findRows(canvasElement);
-	const deniedId = unreadableViewId(args.source);
-
-	return rows.find(
-		(row) => row.getAttribute('data-view-id') === deniedId,
-	) as HTMLElement;
-};
-
-export const hoverUnreadableRow = async (
-	context: PlayContext,
-): Promise<void> => {
-	const card = await hoverRow(await findUnreadableRow(context));
-
-	await expect(
-		await within(card).findByText(/not authorized/i, undefined, UNTIL_LOADED),
-	).toBeVisible();
-	await expect(
-		within(card).queryByTestId('saved-view-hover-card-query'),
-	).toBeNull();
-};
-
-export const openUnreadableView = async (
-	context: PlayContext,
-): Promise<void> => {
-	const { canvasElement } = context;
-	const denied = await findUnreadableRow(context);
-
-	await userEvent.click(rowName(denied)());
-	await expect(
-		await within(canvasElement).findByText(
-			'No view access',
-			undefined,
-			UNTIL_LOADED,
-		),
-	).toBeVisible();
-};

frontend/src/container/SavedViews/stories/SavedViews.stories.tsx

@@ -6,17 +6,10 @@ import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 import SavedViewsPanel from '../SavedViewsPanel';
 import {
 	findRows,
-	hoverFirstRow,
-	hoverFirstRowLoading,
-	openCreateModal,
-	openDeleteDialog,
-	openEditDetailsModal,
 	openRowMenu,
-	openSaveAsNewModal,
 	openSaveChangesMenu,
 	SavedViewsSidebar,
 	savedViewsMocks,
-	searchWithNoResults,
 	sidebarCanvas,
 } from './SavedViews.stories.mocks';
 
@@ -85,48 +78,3 @@ export const SaveChangesMenu: Story = {
 		await openSaveChangesMenu(canvasElement);
 	},
 };
-
-/**
- * Views whose names run past the sidebar, with one of them open: each row and
- * the open view name truncate.
- */
-export const LongNames: Story = {
-	args: { longNames: true, openView: 'created-by-me' },
-};
-
-/** The hover card of the first row: its query, who updated it and when. */
-export const HoverCard: Story = {
-	play: hoverFirstRow,
-};
-
-/** The hover card while its view is still loading: a skeleton in place of the query. */
-export const HoverCardLoading: Story = {
-	args: { viewPending: true },
-	play: hoverFirstRowLoading,
-};
-
-/** A search that matches no view: the list says so in place of the rows. */
-export const SearchNoResults: Story = {
-	play: searchWithNoResults,
-};
-
-/** The + in the header opens Save view for the current query. */
-export const CreateModal: Story = {
-	play: openCreateModal,
-};
-
-/** Edit details from a row's menu: the modal starts on the view's name. */
-export const EditDetailsModal: Story = {
-	play: openEditDetailsModal,
-};
-
-/** Save as new view from the ✓ menu on unsaved changes. */
-export const SaveAsNewModal: Story = {
-	args: { openView: 'unsaved-changes' },
-	play: openSaveAsNewModal,
-};
-
-/** Delete from a row's menu asks to confirm before the view goes. */
-export const DeleteDialog: Story = {
-	play: openDeleteDialog,
-};

frontend/src/container/SavedViews/stories/__story_mockdata__/savedViews.ts

@@ -209,18 +209,6 @@ export const createdSavedView = (
 	spec,
 });
 
-const LONG_NAME_SUFFIX = ', every environment and region, last 30 days';
-
-export const withLongName = (
-	view: SavedviewtypesSavedViewDTO,
-): SavedviewtypesSavedViewDTO => ({
-	...view,
-	spec: {
-		...view.spec,
-		displayName: `${view.spec.displayName}${LONG_NAME_SUFFIX}`,
-	},
-});
-
 export const savedViewResponse = (
 	view: SavedviewtypesSavedViewDTO,
 ): GetSavedView200 => ({ status: 'success', data: view });

frontend/src/container/SavedViews/stories/authz/SavedViews.authz.stories.tsx

@@ -4,15 +4,14 @@ import { expect, waitFor, within } from 'storybook/test';
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
+import { unreadableViewId } from '../__story_mockdata__/savedViews';
 import {
 	byTestId,
 	expectDisabled,
 	expectPending,
 	findRows,
-	hoverUnreadableRow,
 	openRowMenu,
 	openSaveChangesMenu,
-	openUnreadableView,
 	rowMenuItem,
 	rowName,
 	saveChangesItem,
@@ -100,18 +99,21 @@ export const NoCreateSaveMenu: Story = {
 };
 
 /**
- * `read` denied on one view made by someone else: the list checks no `read`, so
- * its row opens it like any other, and the header then says No view access.
+ * `read` denied on one view made by someone else: its name is disabled and its
+ * hover card never opens, while every other view still opens.
  */
 export const NoRead: Story = {
 	args: { unreadableView: true },
-	play: openUnreadableView,
-};
+	play: async ({ canvasElement, args }) => {
+		const rows = await findRows(canvasElement);
+		const deniedId = unreadableViewId(args.source);
 
-/** The hover card of the unreadable view: the permission callout in place of its query. */
-export const NoReadHoverCard: Story = {
-	args: { unreadableView: true },
-	play: hoverUnreadableRow,
+		await Promise.all(
+			rows.map((row) =>
+				expectDisabled(rowName(row), row.getAttribute('data-view-id') === deniedId),
+			),
+		);
+	},
 };
 
 /** The unreadable view open from its link: the header names it No view access. */

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;
@@ -126,11 +128,6 @@ export interface SavedViewsListRowProps {
 	hover: SavedViewsListRowHoverProps;
 }
 
-export type SavedViewsRowLinkProps = Pick<
-	SavedViewsListRowProps,
-	'view' | 'isActive' | 'onSelect'
->;
-
 export type SavedViewRowActionKey =
 	| 'copyLink'
 	| 'copyId'
@@ -184,7 +181,7 @@ export interface UseSavedViewRowActionsResult {
 }
 
 export interface SavedViewHoverCardTarget {
-	viewId: string;
+	view: SavedviewtypesSavedViewDTO;
 	anchorTop: number;
 	anchorHeight: number;
 }
@@ -205,14 +202,8 @@ export interface SavedViewHoverCardProps {
 	onClose: () => void;
 }
 
-export interface SavedViewHoverCardDetailsProps {
-	viewId: string;
-	/** `read` is granted on every view, so the view needs no check of its own. */
-	canReadAll: boolean;
-}
-
 export interface SavedViewsListRowHoverProps {
-	onRowEnter: (viewId: string, row: HTMLElement) => void;
+	onRowEnter: (view: SavedviewtypesSavedViewDTO, row: HTMLElement) => void;
 	onRowLeave: () => void;
 	onMenuOpen: () => void;
 }

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

@@ -1,34 +0,0 @@
-import { QueryParams } from 'constants/query';
-import ROUTES from 'constants/routes';
-
-import { makeView } from '../../__tests__/savedViewsTestUtils';
-import { getSavedViewPath } from '../getSavedViewPath';
-
-const view = makeView({ id: 'view-1', displayName: 'Errors' });
-
-function paramsOf(path: string): URLSearchParams {
-	return new URL(path, window.location.origin).searchParams;
-}
-
-describe('getSavedViewPath', () => {
-	it('opens the view on the given explorer in the given time range', () => {
-		const path = getSavedViewPath(
-			ROUTES.TRACES_EXPLORER,
-			view,
-			'startTime=1700000000000&endTime=1700003600000',
-		);
-		const params = paramsOf(path);
-
-		expect(path.startsWith(`${ROUTES.TRACES_EXPLORER}?`)).toBe(true);
-		expect(params.get(QueryParams.viewKey)).toBe(JSON.stringify(view.id));
-		expect(params.get(QueryParams.startTime)).toBe('1700000000000');
-		expect(params.get(QueryParams.endTime)).toBe('1700003600000');
-	});
-
-	it('adds no time range when there is none', () => {
-		const path = getSavedViewPath(ROUTES.TRACES_EXPLORER, view, '');
-
-		expect(path.endsWith('&')).toBe(false);
-		expect(paramsOf(path).has(QueryParams.relativeTime)).toBe(false);
-	});
-});

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/getSavedViewPath.ts

@@ -1,17 +0,0 @@
-import { SavedviewtypesSavedViewDTO } from 'api/generated/services/sigNoz.schemas';
-import { QueryParams } from 'constants/query';
-import { buildExplorerNavigationUrl } from 'utils/buildExplorerNavigationUrl';
-
-import { getSavedViewQuery } from './getSavedViewQuery';
-
-export function getSavedViewPath(
-	pathname: string,
-	view: SavedviewtypesSavedViewDTO,
-	timeSearch: string,
-): string {
-	const path = buildExplorerNavigationUrl(pathname, getSavedViewQuery(view), {
-		[QueryParams.panelTypes]: view.spec.panelType,
-		[QueryParams.viewKey]: view.id,
-	});
-	return timeSearch ? `${path}&${timeSearch}` : path;
-}

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/hooks/useResourceAttribute/utils.ts

@@ -12,13 +12,12 @@ import {
 	IOption,
 	IResourceAttribute,
 	IResourceAttributeProps,
-	OperatorValues,
-	Tags,
 } from 'hooks/useResourceAttribute/types';
 import { decode } from 'js-base64';
 import { getCurrentLocation } from 'lib/router/navigation';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
+import { OperatorValues, Tags } from 'hooks/useResourceAttribute/types';
 import { v4 as uuid } from 'uuid';
 
 import { whilelistedKeys } from './config';

frontend/src/lib/authz/hooks/useAuthZ/permissions/saved-view.permissions.ts

@@ -6,7 +6,6 @@ export const SavedViewCreatePermission = buildPermission(
 	'create',
 	'saved-view:*',
 );
-export const SavedViewReadPermission = buildPermission('read', 'saved-view:*');
 
 export const buildSavedViewReadPermission = (id: string): BrandedPermission =>
 	buildPermission('read', `saved-view:${id}`);

frontend/src/pages/DashboardPage/DashboardContainer/hooks/__tests__/useTimeSearchParams.test.ts

@@ -1,7 +1,7 @@
 import { renderHook } from '@testing-library/react';
 import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
 
-import { useTimeSearchParams } from 'hooks/useTimeSearchParams';
+import { useTimeSearchParams } from '../useTimeSearchParams';
 
 let mockGlobalTime = {
 	selectedTime: '30m',

frontend/src/pages/DashboardPage/DashboardContainer/hooks/useOpenPanelEditor.ts

@@ -9,7 +9,7 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import type { PanelEditorHandoffState } from '../PanelEditor/panelEditorHandoff';
 import { getPanelBuilderQuery } from '../Panels/utils/getPanelBuilderQuery';
 import { useDashboardStore } from '../store/useDashboardStore';
-import { useTimeSearchParams } from 'hooks/useTimeSearchParams';
+import { useTimeSearchParams } from './useTimeSearchParams';
 import logEvent from '@/api/common/logEvent';
 import { DashboardDetailEvents } from '../../constants/events';
 

frontend/src/pages/DashboardPage/DashboardContainer/hooks/useTimeSearchParams.ts

@@ -4,7 +4,7 @@ import { useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
 import type { GlobalReducer } from 'types/reducer/globalTime';
 
-import { timeParamsFromGlobalTime } from 'utils/timeUrlParams';
+import { timeParamsFromGlobalTime } from '../utils/timeUrlParams';
 
 /** Active time window as a query string (no leading `?`), or `''` when unset. */
 export function useTimeSearchParams(): string {

frontend/src/pages/DashboardPage/DashboardContainer/utils/__tests__/timeUrlParams.test.ts

@@ -1,6 +1,6 @@
 import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
 
-import { timeParamsFromGlobalTime } from 'utils/timeUrlParams';
+import { timeParamsFromGlobalTime } from '../timeUrlParams';
 
 describe('timeParamsFromGlobalTime', () => {
 	it('emits relativeTime for a relative selection', () => {

frontend/src/pages/DashboardPage/PanelEditorPage/PanelEditorPage.tsx

@@ -24,7 +24,7 @@ import {
 	parseNewPanelTarget,
 } from '../DashboardContainer/PanelEditor/newPanelRoute';
 import { useSyncVariablesForSuggestions } from '../DashboardContainer/hooks/useSyncVariablesForSuggestions';
-import { useTimeSearchParams } from 'hooks/useTimeSearchParams';
+import { useTimeSearchParams } from '../DashboardContainer/hooks/useTimeSearchParams';
 import { createDefaultPanel } from '../DashboardContainer/patchOps';
 import { useDashboardStore } from '../DashboardContainer/store/useDashboardStore';
 import { useSeedVariableSelection } from '../DashboardContainer/VariablesBar/hooks/useSeedVariableSelection';

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/utils/__tests__/buildExplorerNavigationUrl.test.ts

@@ -1,22 +0,0 @@
-import ROUTES from 'constants/routes';
-import { QueryParams } from 'constants/query';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-
-import { buildExplorerNavigationUrl } from '../buildExplorerNavigationUrl';
-
-describe('buildExplorerNavigationUrl', () => {
-	it('encodes composite query and view selectors', () => {
-		const url = buildExplorerNavigationUrl(
-			ROUTES.LOGS_EXPLORER,
-			{ queryType: 'builder' } as never,
-			{
-				[QueryParams.panelTypes]: PANEL_TYPES.LIST,
-				[QueryParams.viewKey]: 'view-1',
-			},
-		);
-
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-		expect(url).toContain(`${QueryParams.compositeQuery}=`);
-		expect(url).toContain(`${QueryParams.viewKey}=`);
-	});
-});

frontend/src/utils/buildExplorerNavigationUrl.ts

@@ -1,22 +0,0 @@
-import { QueryParams } from 'constants/query';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-/**
- * Builds an explorer URL the same way `redirectWithQueryBuilderData` does —
- * without inheriting stale query params from the current page's `urlQuery`.
- */
-export function buildExplorerNavigationUrl(
-	route: string,
-	query: Query,
-	searchParams: Record<string, unknown>,
-): string {
-	const params = new URLSearchParams();
-	params.set(
-		QueryParams.compositeQuery,
-		encodeURIComponent(JSON.stringify(query)),
-	);
-	Object.entries(searchParams).forEach(([key, value]) => {
-		params.set(key, JSON.stringify(value));
-	});
-	return `${route}?${params.toString()}`;
-}

pkg/cache/cache.go

@@ -16,6 +16,11 @@ type Cache interface {
 	// Get gets the cacheble entity in the dest entity passed.
 	Get(ctx context.Context, orgID valuer.UUID, cacheKey string, dest cachetypes.Cacheable) error
 
+	// GetMany gets the cacheable entities of cacheKeys into dests, one per key in
+	// the same order. A key that is not found or could not be read sets its dest
+	// to nil. The returned error joins the read failures; a miss alone is not one.
+	GetMany(ctx context.Context, orgID valuer.UUID, cacheKeys []string, dests []cachetypes.Cacheable) error
+
 	// Delete deletes the cacheable entity from cache
 	Delete(ctx context.Context, orgID valuer.UUID, cacheKey string)
 

pkg/cache/memorycache/provider.go

@@ -196,6 +196,28 @@ func (provider *provider) Get(ctx context.Context, orgID valuer.UUID, cacheKey s
 	return errors.NewInternalf(errors.CodeInternal, "unrecognized: (value: \"%s\")", reflect.TypeOf(cachedData).String())
 }
 
+func (provider *provider) GetMany(ctx context.Context, orgID valuer.UUID, cacheKeys []string, dests []cachetypes.Cacheable) error {
+	if len(dests) != len(cacheKeys) {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "got %d destinations for %d keys", len(dests), len(cacheKeys))
+	}
+
+	var errs []error
+	for i, cacheKey := range cacheKeys {
+		err := provider.Get(ctx, orgID, cacheKey, dests[i])
+		if err == nil {
+			continue
+		}
+		dests[i] = nil
+		if !errors.Ast(err, errors.TypeNotFound) {
+			errs = append(errs, err)
+		}
+	}
+	if len(errs) == 0 {
+		return nil
+	}
+	return errors.Join(errs...)
+}
+
 func (provider *provider) Delete(ctx context.Context, orgID valuer.UUID, cacheKey string) {
 	_, span := provider.settings.Tracer().Start(ctx, "memory.delete", trace.WithAttributes(
 		attribute.String(semconv.AttributeDBSystem, "memory"),

pkg/cache/memorycache/provider_test.go

@@ -260,3 +260,27 @@ func TestCloneableConcurrentSetGet(t *testing.T) {
 		assert.NotSame(t, cachedCloneable, cloneables[i])
 	}
 }
+
+func TestGetMany(t *testing.T) {
+	cache, err := New(context.Background(), factorytest.NewSettings(), cache.Config{Provider: "memory", Memory: cache.Memory{
+		NumCounters: 10 * 1000,
+		MaxCost:     1 << 26,
+	}})
+	require.NoError(t, err)
+
+	orgID := valuer.GenerateUUID()
+	require.NoError(t, cache.Set(context.Background(), orgID, "first", &CloneableA{Key: "first", Value: 1}, 10*time.Second))
+	require.NoError(t, cache.Set(context.Background(), orgID, "third", &CloneableA{Key: "third", Value: 3}, 10*time.Second))
+
+	// bytes that are not JSON cannot be read into a CloneableA
+	memory := cache.(*provider)
+	memory.cc.SetWithTTL(strings.Join([]string{orgID.StringValue(), "fourth"}, "::"), []byte("not json"), 1, 10*time.Second)
+	memory.cc.Wait()
+
+	dests := []cachetypes.Cacheable{new(CloneableA), new(CloneableA), new(CloneableA), new(CloneableA)}
+	err = cache.GetMany(context.Background(), orgID, []string{"first", "second", "third", "fourth"}, dests)
+
+	// the unreadable key is reported and nilled, the readable ones are still served
+	assert.Error(t, err)
+	assert.Equal(t, []cachetypes.Cacheable{&CloneableA{Key: "first", Value: 1}, nil, &CloneableA{Key: "third", Value: 3}, nil}, dests)
+}

pkg/cache/rediscache/provider.go

@@ -66,6 +66,49 @@ func (c *provider) Get(ctx context.Context, orgID valuer.UUID, cacheKey string,
 	return nil
 }
 
+func (c *provider) GetMany(ctx context.Context, orgID valuer.UUID, cacheKeys []string, dests []cachetypes.Cacheable) error {
+	if len(dests) != len(cacheKeys) {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "got %d destinations for %d keys", len(dests), len(cacheKeys))
+	}
+	if len(cacheKeys) == 0 {
+		return nil
+	}
+
+	updatedCacheKeys := make([]string, len(cacheKeys))
+	for i, cacheKey := range cacheKeys {
+		updatedCacheKeys[i] = strings.Join([]string{orgID.StringValue(), cacheKey}, "::")
+	}
+
+	values, err := c.client.MGet(ctx, updatedCacheKeys...).Result()
+	if err != nil {
+		for i := range dests {
+			dests[i] = nil
+		}
+		return err
+	}
+
+	var errs []error
+	for i, value := range values {
+		// MGET answers a missing key with nil and a present one with its string
+		switch stored := value.(type) {
+		case nil:
+			dests[i] = nil
+		case string:
+			if err := dests[i].UnmarshalBinary([]byte(stored)); err != nil {
+				dests[i] = nil
+				errs = append(errs, err)
+			}
+		default:
+			dests[i] = nil
+			errs = append(errs, errors.NewInternalf(errors.CodeInternal, "unexpected value of type %T for key %s", value, cacheKeys[i]))
+		}
+	}
+	if len(errs) == 0 {
+		return nil
+	}
+	return errors.Join(errs...)
+}
+
 func (c *provider) Delete(ctx context.Context, orgID valuer.UUID, cacheKey string) {
 	c.DeleteMany(ctx, orgID, []string{cacheKey})
 }

pkg/cache/rediscache/provider_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/go-redis/redismock/v9"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type CacheableA struct {
@@ -58,3 +59,28 @@ func TestSet(t *testing.T) {
 	assert.NoError(t, cache.Set(context.Background(), orgID, "key", cacheable, 10*time.Second))
 	assert.NoError(t, mock.ExpectationsWereMet())
 }
+
+func TestGetMany(t *testing.T) {
+	db, mock := redismock.NewClientMock()
+	providerSettings := instrumentationtest.New().ToProviderSettings()
+	cache := &provider{client: db, settings: factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/cache/rediscache")}
+
+	orgID := valuer.GenerateUUID()
+	stored, err := json.Marshal(&CacheableA{Key: "first", Value: 1, Expiry: time.Microsecond})
+	require.NoError(t, err)
+	// one round trip for all keys, with the missing one answered as nil and
+	// the third holding something that is not a CacheableA
+	mock.ExpectMGet(
+		strings.Join([]string{orgID.StringValue(), "first"}, "::"),
+		strings.Join([]string{orgID.StringValue(), "second"}, "::"),
+		strings.Join([]string{orgID.StringValue(), "third"}, "::"),
+	).SetVal([]any{string(stored), nil, "not json"})
+
+	dests := []cachetypes.Cacheable{new(CacheableA), new(CacheableA), new(CacheableA)}
+	err = cache.GetMany(context.Background(), orgID, []string{"first", "second", "third"}, dests)
+
+	// the unreadable key is reported and nilled, the readable one is still served
+	assert.Error(t, err)
+	assert.Equal(t, []cachetypes.Cacheable{&CacheableA{Key: "first", Value: 1, Expiry: time.Microsecond}, nil, nil}, dests)
+	assert.NoError(t, mock.ExpectationsWereMet())
+}

pkg/modules/spanmapper/implspanmapper/fs/definitions/gen_ai.llm.json

@@ -1,5 +1,5 @@
 {
-  "version": 5,
+  "version": 4,
   "definition": {
     "name": "gen_ai.llm",
     "condition": {
@@ -134,12 +134,6 @@
         "fieldContext": "attribute",
         "config": {
           "sources": [
-            {
-              "key": "langfuse.observation.type",
-              "context": "attribute",
-              "operation": "copy",
-              "priority": 40
-            },
             {
               "key": "openinference.span.kind",
               "context": "attribute",
@@ -362,12 +356,6 @@
         "fieldContext": "attribute",
         "config": {
           "sources": [
-            {
-              "key": "langfuse.observation.input",
-              "context": "attribute",
-              "operation": "move",
-              "priority": 40
-            },
             {
               "key": "gen_ai.prompt",
               "context": "attribute",
@@ -394,12 +382,6 @@
         "fieldContext": "attribute",
         "config": {
           "sources": [
-            {
-              "key": "langfuse.observation.output",
-              "context": "attribute",
-              "operation": "move",
-              "priority": 40
-            },
             {
               "key": "gen_ai.completion",
               "context": "attribute",

pkg/querier/bucket_cache.go

@@ -1,6 +1,7 @@
 package querier
 
 import (
+	"cmp"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -11,11 +12,16 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/types/cachetypes"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
+// bucketCacheCellSteps is the grid cell width in steps; no cached bucket
+// crosses a cell boundary.
+const bucketCacheCellSteps = 60
+
 // BucketCache is the interface for bucket-based caching.
 type BucketCache interface {
 	// cached portion + list of gaps to fetch
@@ -58,44 +64,59 @@ func (bc *bucketCache) GetMissRanges(
 
 	bc.logger.DebugContext(ctx, "getting miss ranges", slog.String("fingerprint", q.Fingerprint()), slog.Uint64("start", startMs), slog.Uint64("end", endMs))
 
-	// Generate cache key
-	cacheKey := bc.generateCacheKey(q)
-
-	bc.logger.DebugContext(ctx, "cache key", slog.String("cache_key", cacheKey))
-
-	// Try to get cached data
-	var data qbtypes.CachedData
-	err := bc.cache.Get(ctx, orgID, cacheKey, &data)
-	if err != nil {
-		if !errors.Ast(err, errors.TypeNotFound) {
-			bc.logger.ErrorContext(ctx, "error getting cached data", errors.Attr(err))
-		}
-		// No cached data, need to fetch entire range
-		missing = []*qbtypes.TimeRange{{From: startMs, To: endMs}}
-		return nil, missing
-	}
-
 	// Extract step interval if this is a builder query
 	stepMs := uint64(step.Milliseconds())
 
-	// Find missing ranges with step alignment
-	missing = bc.findMissingRangesWithStep(data.Buckets, startMs, endMs, stepMs)
-	bc.logger.DebugContext(ctx, "missing ranges", slog.Any("missing", missing), slog.Uint64("step", stepMs))
+	// No cached data, need to fetch entire range
+	missing = []*qbtypes.TimeRange{{From: startMs, To: endMs}}
 
-	// If no cached data overlaps with requested range, return empty result
-	if len(data.Buckets) == 0 {
+	if endMs <= startMs {
+		return nil, missing
+	}
+	cellWidthMs := bucketCacheCellSteps * stepMs
+	firstCellIdx, lastCellIdx := deriveCellIdx(startMs, cellWidthMs), deriveCellIdx(endMs-1, cellWidthMs)
+
+	// Gather the buckets of every cell the window touches
+	cellKeys := make([]string, 0, lastCellIdx-firstCellIdx+1)
+	cellEntries := make([]cachetypes.Cacheable, 0, lastCellIdx-firstCellIdx+1)
+	for cellIdx := firstCellIdx; cellIdx <= lastCellIdx; cellIdx++ {
+		cellKeys = append(cellKeys, bc.generateCacheKey(q, cellIdx))
+		cellEntries = append(cellEntries, &qbtypes.CachedData{})
+	}
+
+	// A cell that could not be read comes back nil like a miss, so the rest
+	// are still worth serving
+	if err := bc.cache.GetMany(ctx, orgID, cellKeys, cellEntries); err != nil {
+		bc.logger.ErrorContext(ctx, "error getting cached data", errors.Attr(err))
+	}
+
+	cachedBuckets := []*qbtypes.CachedBucket{}
+	cachedWarnings := []string{}
+	for _, cellEntry := range cellEntries {
+		if cellEntry == nil {
+			continue
+		}
+		cellData := cellEntry.(*qbtypes.CachedData)
+		cachedBuckets = append(cachedBuckets, cellData.Buckets...)
+		cachedWarnings = append(cachedWarnings, cellData.Warnings...)
+	}
+	if len(cachedBuckets) == 0 {
 		return nil, missing
 	}
 
+	// Find missing ranges with step alignment
+	missing = bc.findMissingRangesWithStep(cachedBuckets, startMs, endMs, stepMs)
+	bc.logger.DebugContext(ctx, "missing ranges", slog.Any("missing", missing), slog.Uint64("step", stepMs))
+
 	// Extract relevant buckets and merge them
-	relevantBuckets := bc.filterRelevantBuckets(data.Buckets, startMs, endMs)
+	relevantBuckets := bc.filterRelevantBuckets(cachedBuckets, startMs, endMs)
 	if len(relevantBuckets) == 0 {
 		// nothing cached overlaps the window, so all of it has to be fetched.
 		return nil, []*qbtypes.TimeRange{{From: startMs, To: endMs}}
 	}
 
 	// Merge buckets into a single result
-	mergedResult := bc.mergeBuckets(ctx, relevantBuckets, data.Warnings)
+	mergedResult := bc.mergeBuckets(ctx, relevantBuckets, cachedWarnings)
 
 	// Filter the merged result to only include values within the requested time range
 	mergedResult = bc.filterResultToTimeRange(mergedResult, q, startMs, endMs, stepMs)
@@ -130,15 +151,6 @@ func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Que
 			slog.Uint64("cachable_end", cachableEndMs))
 	}
 
-	// Generate cache key
-	cacheKey := bc.generateCacheKey(q)
-
-	// Get existing cached data
-	var existingData qbtypes.CachedData
-	if err := bc.cache.Get(ctx, orgID, cacheKey, &existingData); err != nil {
-		existingData = qbtypes.CachedData{}
-	}
-
 	// Trim the result to exclude data within flux interval
 	trimmedResult := bc.trimResultToFluxBoundary(fresh, cachableEndMs)
 	if trimmedResult == nil {
@@ -174,38 +186,44 @@ func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Que
 		}
 	}
 
-	// Convert trimmed result to buckets with adjusted boundaries
-	freshBuckets := bc.resultToBuckets(ctx, trimmedResult, cachableStartMs, cachableEndMs)
+	// Convert trimmed result to buckets, one per grid cell it spans
+	cellWidthMs := bucketCacheCellSteps * stepMs
+	freshBuckets := bc.resultToBuckets(ctx, trimmedResult, cachableStartMs, cachableEndMs, cellWidthMs)
 
-	// If no fresh buckets and no existing data, don't cache
-	if len(freshBuckets) == 0 && len(existingData.Buckets) == 0 {
-		return
-	}
+	// Each cell is its own cache entry, rewritten only when the fresh bucket
+	// changes what it holds, so an entry's TTL runs from its last new data
+	for _, freshBucket := range freshBuckets {
+		cellKey := bc.generateCacheKey(q, deriveCellIdx(freshBucket.StartMs, cellWidthMs))
 
-	// Merge with existing buckets
-	mergedBuckets := bc.mergeAndDeduplicateBuckets(existingData.Buckets, freshBuckets)
+		var cellEntry qbtypes.CachedData
+		if err := bc.cache.Get(ctx, orgID, cellKey, &cellEntry); err != nil {
+			cellEntry = qbtypes.CachedData{}
+		}
 
-	// Update warnings
-	allWarnings := append(existingData.Warnings, trimmedResult.Warnings...)
-	uniqueWarnings := bc.deduplicateWarnings(allWarnings)
-
-	// Create updated cached data
-	updatedData := qbtypes.CachedData{
-		Buckets:  mergedBuckets,
-		Warnings: uniqueWarnings,
-	}
-
-	// Marshal and store in cache
-	if err := bc.cache.Set(ctx, orgID, cacheKey, &updatedData, bc.cacheTTL); err != nil {
-		bc.logger.ErrorContext(ctx, "error setting cached data", errors.Attr(err))
+		cellBuckets, changed := bc.mergeFreshBucketIntoCell(ctx, cellEntry.Buckets, freshBucket)
+		if !changed {
+			continue
+		}
+		cellEntry.Buckets = cellBuckets
+		cellEntry.Warnings = bc.deduplicateWarnings(append(cellEntry.Warnings, trimmedResult.Warnings...))
+		if err := bc.cache.Set(ctx, orgID, cellKey, &cellEntry, bc.cacheTTL); err != nil {
+			bc.logger.ErrorContext(ctx, "error setting cached data", errors.Attr(err))
+		}
 	}
 }
 
-// generateCacheKey creates a unique cache key based on query fingerprint.
-func (bc *bucketCache) generateCacheKey(q qbtypes.Query) string {
-	fingerprint := q.Fingerprint()
+// generateCacheKey names the cache entry holding one grid cell of a query.
+func (bc *bucketCache) generateCacheKey(q qbtypes.Query, cellIdx uint64) string {
+	return fmt.Sprintf("v6:query:%s:cellidx:%d", q.Fingerprint(), cellIdx)
+}
 
-	return fmt.Sprintf("v5:query:%s", fingerprint)
+// deriveCellIdx returns the index of the grid cell holding startMs; with no grid
+// every bucket shares cell 0.
+func deriveCellIdx(startMs, cellWidthMs uint64) uint64 {
+	if cellWidthMs == 0 {
+		return 0
+	}
+	return startMs / cellWidthMs
 }
 
 // findMissingRangesWithStep identifies time ranges not covered by cached buckets with step alignment.
@@ -646,7 +664,7 @@ func (bc *bucketCache) isEmptyResult(result *qbtypes.Result) (isEmpty bool, isFi
 }
 
 // resultToBuckets converts a query result into time-based buckets.
-func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Result, startMs, endMs uint64) []*qbtypes.CachedBucket {
+func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Result, startMs, endMs, cellWidthMs uint64) []*qbtypes.CachedBucket {
 	// Check if result is empty
 	isEmpty, isFiltered := bc.isEmptyResult(result)
 
@@ -657,62 +675,74 @@ func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Resu
 		return nil
 	}
 
-	// For now, create a single bucket for the entire range
-	// In the future, we could split large ranges into smaller buckets
-	valueBytes, err := json.Marshal(result.Value)
+	// Empty filtered results still become buckets, so the range is not re-queried
+	perCellBuckets, err := result.SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs)
 	if err != nil {
-		bc.logger.ErrorContext(ctx, "failed to marshal result value", errors.Attr(err))
+		bc.logger.ErrorContext(ctx, "failed to convert result to buckets", errors.Attr(err))
 		return nil
 	}
-
-	// Always create a bucket, even for empty filtered results
-	// This ensures we don't re-query for data that doesn't exist
-	return []*qbtypes.CachedBucket{
-		{
-			StartMs: startMs,
-			EndMs:   endMs,
-			Type:    result.Type,
-			Value:   valueBytes,
-			Stats:   result.Stats,
-		},
-	}
+	return perCellBuckets
 }
 
-// mergeAndDeduplicateBuckets combines and deduplicates bucket lists.
-func (bc *bucketCache) mergeAndDeduplicateBuckets(existing, fresh []*qbtypes.CachedBucket) []*qbtypes.CachedBucket {
-	// Create a map to deduplicate by time range
-	bucketMap := make(map[string]*qbtypes.CachedBucket)
-
-	// Add existing buckets
-	for _, bucket := range existing {
-		key := fmt.Sprintf("%d-%d", bucket.StartMs, bucket.EndMs)
-		bucketMap[key] = bucket
-	}
-
-	// Add/update with fresh buckets
-	for _, bucket := range fresh {
-		key := fmt.Sprintf("%d-%d", bucket.StartMs, bucket.EndMs)
-		bucketMap[key] = bucket
-	}
-
-	// Convert back to slice with pre-allocated capacity
-	result := make([]*qbtypes.CachedBucket, 0, len(bucketMap))
-	for _, bucket := range bucketMap {
-		result = append(result, bucket)
-	}
-
-	// Sort by start time
-	slices.SortFunc(result, func(a, b *qbtypes.CachedBucket) int {
-		if a.StartMs < b.StartMs {
-			return -1
+// mergeFreshBucketIntoCell folds a fresh bucket into the buckets of its cell
+// and reports whether the cell changed: a bucket already covering the fresh
+// one leaves it as is, buckets inside the fresh one are replaced, buckets
+// overlapping or edge to edge with it are unioned, and the rest are kept apart.
+func (bc *bucketCache) mergeFreshBucketIntoCell(ctx context.Context, cellBuckets []*qbtypes.CachedBucket, freshBucket *qbtypes.CachedBucket) ([]*qbtypes.CachedBucket, bool) {
+	keptBuckets := make([]*qbtypes.CachedBucket, 0, len(cellBuckets)+1)
+	touchingBuckets := []*qbtypes.CachedBucket{}
+	for _, cellBucket := range cellBuckets {
+		switch {
+		case cellBucket.Contains(freshBucket):
+			return cellBuckets, false
+		case cellBucket.Touches(freshBucket):
+			touchingBuckets = append(touchingBuckets, cellBucket)
+		default:
+			keptBuckets = append(keptBuckets, cellBucket)
 		}
-		if a.StartMs > b.StartMs {
-			return 1
-		}
-		return 0
+	}
+	keptBuckets = append(keptBuckets, bc.unionBuckets(ctx, freshBucket, touchingBuckets))
+
+	slices.SortFunc(keptBuckets, func(a, b *qbtypes.CachedBucket) int {
+		return cmp.Compare(a.StartMs, b.StartMs)
 	})
+	return keptBuckets, true
+}
 
-	return result
+// unionBuckets widens the fresh bucket by the buckets it touches. Buckets
+// inside it are replaced outright, so only a genuine partial overlap decodes
+// anything.
+func (bc *bucketCache) unionBuckets(ctx context.Context, freshBucket *qbtypes.CachedBucket, touchingBuckets []*qbtypes.CachedBucket) *qbtypes.CachedBucket {
+	bucketsToMerge := []*qbtypes.CachedBucket{freshBucket}
+	for _, touchingBucket := range touchingBuckets {
+		if !freshBucket.Contains(touchingBucket) {
+			bucketsToMerge = append(bucketsToMerge, touchingBucket)
+		}
+	}
+	if len(bucketsToMerge) == 1 {
+		return freshBucket
+	}
+
+	value, err := json.Marshal(bc.mergeTimeSeriesValues(ctx, bucketsToMerge))
+	if err != nil {
+		bc.logger.ErrorContext(ctx, "failed to marshal unioned bucket", errors.Attr(err))
+		return freshBucket
+	}
+	unionBucket := &qbtypes.CachedBucket{
+		StartMs: freshBucket.StartMs,
+		EndMs:   freshBucket.EndMs,
+		Type:    freshBucket.Type,
+		Value:   value,
+		Stats:   qbtypes.ExecStats{StepIntervals: freshBucket.Stats.StepIntervals},
+	}
+	for _, mergedBucket := range bucketsToMerge {
+		unionBucket.StartMs = min(unionBucket.StartMs, mergedBucket.StartMs)
+		unionBucket.EndMs = max(unionBucket.EndMs, mergedBucket.EndMs)
+		unionBucket.Stats.RowsScanned += mergedBucket.Stats.RowsScanned
+		unionBucket.Stats.BytesScanned += mergedBucket.Stats.BytesScanned
+		unionBucket.Stats.DurationMS += mergedBucket.Stats.DurationMS
+	}
+	return unionBucket
 }
 
 // deduplicateWarnings removes duplicate warnings.

pkg/querier/bucket_cache_test.go

@@ -2,6 +2,7 @@ package querier
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"log/slog"
 	"testing"
@@ -1465,3 +1466,161 @@ func TestBucketCache_NoCache(t *testing.T) {
 	// The actual NoCache logic is implemented in querier.run(), not in bucket cache
 	// This test verifies that the cache works normally and NoCache bypasses it at a higher level
 }
+
+func TestBucketCachePutSlicesAtCellBoundaries(t *testing.T) {
+	bc := createTestBucketCache(t)
+	ctx := context.Background()
+	orgID := valuer.UUID{}
+	step := qbtypes.Step{Duration: time.Second}
+
+	// a 1s step gives 60s cells, so 30s to 150s spans three of them
+	query := &mockQuery{fingerprint: "sliced-query", startMs: 30000, endMs: 150000}
+	bc.Put(ctx, orgID, query, step, &qbtypes.Result{
+		Type:  qbtypes.RequestTypeTimeSeries,
+		Value: createTestTimeSeries("A", 30000, 150000, 1000),
+		Stats: qbtypes.ExecStats{RowsScanned: 120, BytesScanned: 1200, DurationMS: 12},
+	})
+
+	type bucketShape struct {
+		cell, startMs, endMs, rowsScanned uint64
+		valueCount                        int
+	}
+	shapes := []bucketShape{}
+	for cell := uint64(0); cell < 3; cell++ {
+		var cellEntry qbtypes.CachedData
+		require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(query, cell), &cellEntry))
+		for _, bucket := range cellEntry.Buckets {
+			var tsData qbtypes.TimeSeriesData
+			require.NoError(t, json.Unmarshal(bucket.Value, &tsData))
+			require.Len(t, tsData.Aggregations, 1)
+			require.Len(t, tsData.Aggregations[0].Series, 1)
+			shapes = append(shapes, bucketShape{cell, bucket.StartMs, bucket.EndMs, bucket.Stats.RowsScanned, len(tsData.Aggregations[0].Series[0].Values)})
+		}
+	}
+	assert.Equal(t, []bucketShape{
+		{0, 30000, 60000, 30, 30},
+		{1, 60000, 120000, 60, 60},
+		{2, 120000, 150000, 30, 30},
+	}, shapes)
+
+	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
+	assert.Equal(t, []*qbtypes.TimeRange{}, missing)
+	assert.Len(t, cached.Value.(*qbtypes.TimeSeriesData).Aggregations[0].Series[0].Values, 120)
+	assert.Equal(t, uint64(120), cached.Stats.RowsScanned)
+}
+
+func TestBucketCachePutAbsorbsWritesWithinACell(t *testing.T) {
+	type bucketShape struct{ startMs, endMs, rowsScanned uint64 }
+	testCases := []struct {
+		name                  string
+		firstWindow           qbtypes.TimeRange
+		secondWindow          qbtypes.TimeRange
+		expectedBuckets       []bucketShape
+		expectedMissingRanges []*qbtypes.TimeRange
+		expectedValueCount    int
+	}{
+		{
+			name:                  "DisjointWrites_StayApart",
+			firstWindow:           qbtypes.TimeRange{From: 1000, To: 3000},
+			secondWindow:          qbtypes.TimeRange{From: 5000, To: 8000},
+			expectedBuckets:       []bucketShape{{1000, 3000, 2}, {5000, 8000, 3}},
+			expectedMissingRanges: []*qbtypes.TimeRange{{From: 3000, To: 5000}},
+			expectedValueCount:    5,
+		},
+		{
+			name:                  "EdgeToEdgeWrites_BecomeOne",
+			firstWindow:           qbtypes.TimeRange{From: 1000, To: 3000},
+			secondWindow:          qbtypes.TimeRange{From: 3000, To: 5000},
+			expectedBuckets:       []bucketShape{{1000, 5000, 4}},
+			expectedMissingRanges: []*qbtypes.TimeRange{},
+			expectedValueCount:    4,
+		},
+		{
+			name:                  "OverlappingWrites_BecomeOne",
+			firstWindow:           qbtypes.TimeRange{From: 1000, To: 4000},
+			secondWindow:          qbtypes.TimeRange{From: 3000, To: 6000},
+			expectedBuckets:       []bucketShape{{1000, 6000, 6}},
+			expectedMissingRanges: []*qbtypes.TimeRange{},
+			expectedValueCount:    5,
+		},
+		{
+			name:                  "ContainedWrite_KeepsExistingBucket",
+			firstWindow:           qbtypes.TimeRange{From: 1000, To: 10000},
+			secondWindow:          qbtypes.TimeRange{From: 3000, To: 5000},
+			expectedBuckets:       []bucketShape{{1000, 10000, 9}},
+			expectedMissingRanges: []*qbtypes.TimeRange{},
+			expectedValueCount:    9,
+		},
+		{
+			name:                  "ContainingWrite_ReplacesExistingBucket",
+			firstWindow:           qbtypes.TimeRange{From: 3000, To: 5000},
+			secondWindow:          qbtypes.TimeRange{From: 1000, To: 10000},
+			expectedBuckets:       []bucketShape{{1000, 10000, 9}},
+			expectedMissingRanges: []*qbtypes.TimeRange{},
+			expectedValueCount:    9,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			bc := createTestBucketCache(t)
+			ctx := context.Background()
+			orgID := valuer.UUID{}
+			step := qbtypes.Step{Duration: time.Second}
+
+			for _, window := range []qbtypes.TimeRange{testCase.firstWindow, testCase.secondWindow} {
+				query := &mockQuery{fingerprint: "absorb-query", startMs: window.From, endMs: window.To}
+				bc.Put(ctx, orgID, query, step, &qbtypes.Result{
+					Type:  qbtypes.RequestTypeTimeSeries,
+					Value: createTestTimeSeries("A", window.From, window.To, 1000),
+					// one row per second, so a bucket's stats read as the seconds it was scanned for
+					Stats: qbtypes.ExecStats{RowsScanned: (window.To - window.From) / 1000},
+				})
+			}
+
+			query := &mockQuery{
+				fingerprint: "absorb-query",
+				startMs:     min(testCase.firstWindow.From, testCase.secondWindow.From),
+				endMs:       max(testCase.firstWindow.To, testCase.secondWindow.To),
+			}
+			var cellEntry qbtypes.CachedData
+			require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(query, 0), &cellEntry))
+			shapes := make([]bucketShape, 0, len(cellEntry.Buckets))
+			for _, bucket := range cellEntry.Buckets {
+				shapes = append(shapes, bucketShape{bucket.StartMs, bucket.EndMs, bucket.Stats.RowsScanned})
+			}
+			assert.Equal(t, testCase.expectedBuckets, shapes)
+
+			cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
+			assert.Equal(t, testCase.expectedMissingRanges, missing)
+			assert.Len(t, cached.Value.(*qbtypes.TimeSeriesData).Aggregations[0].Series[0].Values, testCase.expectedValueCount)
+		})
+	}
+}
+
+func TestBucketCachePutLeavesAnUnchangedCellAlone(t *testing.T) {
+	bc := createTestBucketCache(t)
+	ctx := context.Background()
+	orgID := valuer.UUID{}
+	step := qbtypes.Step{Duration: time.Second}
+
+	wide := &mockQuery{fingerprint: "unchanged-query", startMs: 1000, endMs: 10000}
+	bc.Put(ctx, orgID, wide, step, &qbtypes.Result{
+		Type:     qbtypes.RequestTypeTimeSeries,
+		Value:    createTestTimeSeries("A", 1000, 10000, 1000),
+		Warnings: []string{"from the wide write"},
+	})
+
+	// a write already covered by the cell's bucket must not rewrite the entry,
+	// which shows as its warnings never arriving
+	inside := &mockQuery{fingerprint: "unchanged-query", startMs: 3000, endMs: 5000}
+	bc.Put(ctx, orgID, inside, step, &qbtypes.Result{
+		Type:     qbtypes.RequestTypeTimeSeries,
+		Value:    createTestTimeSeries("A", 3000, 5000, 1000),
+		Warnings: []string{"from the inside write"},
+	})
+
+	var cellEntry qbtypes.CachedData
+	require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(wide, 0), &cellEntry))
+	assert.Equal(t, []string{"from the wide write"}, cellEntry.Warnings)
+}

pkg/types/aiobservabilitytypes/message_format.go

@@ -121,13 +121,10 @@ func (f *formatting) messages() {
 
 // OpenRouter's answer object or an Anthropic response beside the OpenAI chat request it answers is one
 // format, not a mix: an Anthropic request without system and without Anthropic-only blocks reads as an
-// OpenAI chat request. A side kept as generic already warned, and a side read from OpenInference's
-// buckets beside the raw payload of the other is the documented fallback.
+// OpenAI chat request.
 func (f *formatting) warnMixedFormats(inputLabel, outputLabel string) {
 	switch {
 	case inputLabel == "" || outputLabel == "" || outputLabel == inputLabel:
-	case inputLabel == FormatterGeneric || outputLabel == FormatterGeneric:
-	case inputLabel == FormatterOpenInference || outputLabel == FormatterOpenInference:
 	case inputLabel == FormatterOpenAIChat && (outputLabel == FormatterOpenRouter || outputLabel == FormatterAnthropic):
 	default:
 		f.warn("output formatted as %s, input as %s", outputLabel, inputLabel)
@@ -186,16 +183,11 @@ func (f *formatting) side(value any, role Role) (OutputMessages, string) {
 				return f.semconv(v), FormatterSemconv
 			case isAnthropicMessages(v):
 				return f.anthropicMessages(v), FormatterAnthropic
-			case isResponsesItems(v):
-				return foldAssistant(f.responsesItems(v)), FormatterOpenAIResponses
 			case first["role"] != nil:
 				return f.openAIChatMessages(v), FormatterOpenAIChat
 			}
 		}
 	case map[string]any:
-		if inner, ok := superJSON(v); ok {
-			return f.side(decode(inner), role)
-		}
 		switch {
 		case isLangChainRun(v):
 			return f.langChainRun(v), FormatterLangChain
@@ -222,9 +214,6 @@ func (f *formatting) side(value any, role Role) (OutputMessages, string) {
 		if messages, ok := v["messages"].([]any); ok {
 			return f.openAIChatMessages(messages), FormatterOpenAIChat
 		}
-		if (v["role"] != nil && hasKeys(v, "content")) || v["tool_calls"] != nil {
-			return OutputMessages{f.openAIChatSingle(v)}, FormatterOpenAIChat
-		}
 	case string:
 		if v == "" {
 			return OutputMessages{}, FormatterText
@@ -320,23 +309,6 @@ func foldAssistant(msgs OutputMessages) OutputMessages {
 	return out
 }
 
-// superJSON unwraps {json, meta?}, the envelope superjson, the transformer tRPC apps serialise with,
-// puts around a value; a Langfuse generation records it around the request when the app passes the
-// serialised form:
-// https://github.com/flightcontrolhq/superjson/blob/aaa65e36e8e31da740265a56b27c965ca1c7b754/README.md
-func superJSON(m map[string]any) (any, bool) {
-	inner, ok := m["json"]
-	if !ok {
-		return nil, false
-	}
-	for key := range m {
-		if key != "json" && key != "meta" {
-			return nil, false
-		}
-	}
-	return inner, true
-}
-
 // decode parses a JSON-encoded attribute value, twice when an SDK encoded the string again.
 // Anything that is not JSON is returned as is.
 func decode(value any) any {

pkg/types/aiobservabilitytypes/message_format_openai_chat.go

@@ -4,9 +4,8 @@ import (
 	"strings"
 )
 
-// Format: OpenAI Chat Completions, a request {messages}, a response {choices}, a bare message list, or a
-// single message.
-// Written by: bifrost, openrouter requests, the raw OpenAI calls OpenInference records, the Langfuse SDK.
+// Format: OpenAI Chat Completions, a request {messages}, a response {choices}, or a bare message list.
+// Written by: bifrost, openrouter requests, the raw OpenAI calls OpenInference records.
 // Handled: string and block content, tool_calls nested or flattened, tool messages, refusal,
 // reasoning_content, finish reasons.
 // Not yet: streaming delta chunks, legacy completions choices[].text, audio output.
@@ -89,19 +88,6 @@ func (f *formatting) openAIChatMessage(m map[string]any) OutputMessage {
 	return msg
 }
 
-// openAIChatSingle converts a message recorded outside a list: the first choice's message the Langfuse
-// OpenAI wrapper writes as the output, or the additional_kwargs of a LangChain AIMessage, {tool_calls}
-// without a role, which the Langfuse LangChain handler writes for a tool-calling turn:
-// https://github.com/langfuse/langfuse-python/blob/18baf80450dd5f9c1f85916eb2d1b3c72d2052e1/langfuse/openai.py#L446
-// https://github.com/langfuse/langfuse-python/blob/18baf80450dd5f9c1f85916eb2d1b3c72d2052e1/langfuse/langchain/CallbackHandler.py#L1558
-func (f *formatting) openAIChatSingle(m map[string]any) OutputMessage {
-	msg := f.openAIChatMessage(m)
-	if msg.Role.IsZero() {
-		msg.Role = RoleAssistant
-	}
-	return msg
-}
-
 // toolCallPart reads {id, function: {name, arguments}}; a gateway may flatten it to {id, name, arguments|args}.
 func toolCallPart(c map[string]any) Part {
 	call := ToolCallRequestPart{Type: PartTypeToolCall, ID: optionalString(c["id"]), Name: stringOf(c["name"])}

pkg/types/aiobservabilitytypes/message_format_openai_chat_test.go

@@ -205,30 +205,6 @@ func TestFormat_OpenAIChat(t *testing.T) {
 			]`,
 			wantOutput: `[]`,
 		},
-		{
-			// Langfuse SDK generation: the history as a list, the first choice's message as the output
-			name:       "SingleMessageOutput_AssistantMessage",
-			input:      `[{"role": "system", "content": "You are a support agent on a phone call."}, {"role": "user", "content": "Hello?"}]`,
-			output:     `{"role": "assistant", "content": "Hi, this is a courtesy call about your order. Do you have a minute?"}`,
-			wantInput:  `[{"role": "system", "parts": [{"type": "text", "content": "You are a support agent on a phone call."}]}, {"role": "user", "parts": [{"type": "text", "content": "Hello?"}]}]`,
-			wantOutput: `[{"role": "assistant", "parts": [{"type": "text", "content": "Hi, this is a courtesy call about your order. Do you have a minute?"}]}]`,
-		},
-		{
-			// a structured output that happens to carry a role key is not a message
-			name:       "ObjectWithRoleKeyButNoContent_KeptAsGeneric",
-			output:     `{"role": "admin", "permissions": ["read", "write"]}`,
-			warnings:   []string{"message format not recognised, kept as generic"},
-			wantInput:  `[]`,
-			wantOutput: `[{"role": "", "parts": [{"type": "generic", "content": "{\"permissions\":[\"read\",\"write\"],\"role\":\"admin\"}"}]}]`,
-		},
-		{
-			// Langfuse LangChain handler: the additional_kwargs of the AIMessage, without a role, as the output
-			// of a tool-calling turn
-			name:       "RolelessToolCallsOutput_AssistantToolCallPart",
-			output:     `{"tool_calls": [{"id": "call_1", "type": "function", "function": {"name": "get_weather", "arguments": "{\"city\": \"Oslo\"}"}}], "refusal": null}`,
-			wantInput:  `[]`,
-			wantOutput: `[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_weather", "id": "call_1", "arguments": {"city": "Oslo"}}]}]`,
-		},
 		{
 			name:      "ResponseWithScalarChoice_KeptAsGeneric",
 			output:    `{"choices":["oops",{"finish_reason":"stop","index":1,"message":{"role":"assistant","content":"hi"}}]}`,

pkg/types/aiobservabilitytypes/message_format_openai_responses.go

@@ -2,15 +2,13 @@ package aiobservabilitytypes
 
 import "strings"
 
-// Format: OpenAI Responses, a request {input, instructions}, a response {output, status} or a bare list
-// of items:
+// Format: OpenAI Responses, a request {input, instructions} or a response {output, status} of items:
 // https://github.com/openai/openai-openapi/blob/aeb6a041dc56c011ca9f12127ec898f911100aa0/openapi.yaml#L47597
 // https://github.com/openai/openai-openapi/blob/aeb6a041dc56c011ca9f12127ec898f911100aa0/openapi.yaml#L69691
 // https://github.com/openai/openai-openapi/blob/aeb6a041dc56c011ca9f12127ec898f911100aa0/openapi.yaml#L53834
 // https://github.com/openai/openai-openapi/blob/aeb6a041dc56c011ca9f12127ec898f911100aa0/openapi.yaml#L57596
-// Written by: gateways recording raw Responses bodies, the raw calls OpenInference records for the
-// Responses API and the OpenAI Agents SDK when its flattened messages are absent, and LiteLLM's
-// langfuse_otel callback, the function_call items of a tool-calling turn as a bare list.
+// Written by: gateways recording raw Responses bodies, and the raw calls OpenInference records for the
+// Responses API and the OpenAI Agents SDK when its flattened messages are absent.
 // Handled: message items with input_text, output_text, refusal, input_image and input_file content;
 // function_call and custom_tool_call with their outputs; reasoning summaries; compaction; every other
 // *_call item as a server tool call and *_output item as its response; the status and incomplete_details
@@ -34,19 +32,6 @@ func isResponsesRequest(m map[string]any) bool {
 	return isItem
 }
 
-// isResponsesItems looks for an item only the Responses API has, a tool call or its output, a reasoning
-// or compaction item, all without a role; a list of messages has none.
-func isResponsesItems(list []any) bool {
-	for _, item := range list {
-		m, _ := item.(map[string]any)
-		typ := stringOf(m["type"])
-		if m["role"] == nil && (typ == "reasoning" || typ == "compaction" || typ == "mcp_approval_response" || strings.HasSuffix(typ, "_call") || strings.HasSuffix(typ, "_output")) {
-			return true
-		}
-	}
-	return false
-}
-
 func isResponsesResponse(m map[string]any) bool {
 	if _, ok := m["output"].([]any); !ok {
 		return false

pkg/types/aiobservabilitytypes/message_format_openai_responses_test.go

@@ -73,23 +73,6 @@ func TestFormat_OpenAIResponses(t *testing.T) {
 			wantInput:  `[{"role": "system", "parts": [{"type": "text", "content": "Be brief."}]}, {"role": "user", "parts": [{"type": "text", "content": "Say hi"}]}]`,
 			wantOutput: `[]`,
 		},
-		{
-			// LiteLLM langfuse_otel: the function_call items of a tool-calling turn as a bare list
-			name:       "BareFunctionCallItems_OneAssistantMessage",
-			output:     `[{"id": "chatcmpl-1", "name": "set_stage", "call_id": "call_7", "type": "function_call", "arguments": {"fields": {"stage": "consent"}}}]`,
-			wantInput:  `[]`,
-			wantOutput: `[{"role": "assistant", "parts": [{"type": "tool_call", "name": "set_stage", "id": "call_7", "arguments": {"fields": {"stage": "consent"}}}]}]`,
-		},
-		{
-			name:  "BareItemsWithMessage_ToolRound",
-			input: `[{"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Weather in Oslo?"}]}, {"type": "function_call", "call_id": "call_9", "name": "get_weather", "arguments": "{\"city\":\"Oslo\"}"}, {"type": "function_call_output", "call_id": "call_9", "output": "4C, cloudy"}]`,
-			wantInput: `[
-			  {"role": "user", "parts": [{"type": "text", "content": "Weather in Oslo?"}]},
-			  {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_weather", "id": "call_9", "arguments": {"city": "Oslo"}}]},
-			  {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_9", "response": "4C, cloudy"}]}
-			]`,
-			wantOutput: `[]`,
-		},
 		{
 			// openinference capture, CreateEmbeddings span: an embeddings request also has input and model
 			name:       "EmbeddingsRequest_NotResponses_KeptAsGeneric",

pkg/types/aiobservabilitytypes/message_format_openinference.go

@@ -4,9 +4,8 @@ import "github.com/SigNoz/signoz/pkg/valuer"
 
 // Format: the flattened llm.input_messages.N.message.* and llm.output_messages.N.message.* keys, the
 // provider-neutral copy of the conversation the OpenInference instrumentations write on LLM spans. A side
-// without them, or whose buckets hold no message, falls back to the raw provider payload the mapper moved
-// onto gen_ai.*.messages; pipecat streams the reply into output.value alone, LiteLLM's OpenInference mode
-// leaves the output bucket empty on a tool-calling turn.
+// without them falls back to the raw provider payload the mapper moved onto gen_ai.*.messages; pipecat
+// streams the reply into output.value alone.
 // https://github.com/Arize-ai/openinference/blob/12f2cc035edfb00b60b656d977f07abfb7a69900/spec/semantic_conventions.md#L77
 // https://github.com/Arize-ai/openinference/blob/12f2cc035edfb00b60b656d977f07abfb7a69900/spec/tool_calling.md#L37
 // https://github.com/Arize-ai/openinference/blob/12f2cc035edfb00b60b656d977f07abfb7a69900/spec/multimodal_attributes.md#L35
@@ -29,14 +28,15 @@ func (f *formatting) openInference() bool {
 		return false
 	}
 	inputLabel, outputLabel := FormatterOpenInference, FormatterOpenInference
-	if msgs := openInferenceMessages(input); len(msgs) > 0 {
-		f.out.Input = inputMessages(msgs)
+	if len(input) > 0 {
+		f.out.Input = inputMessages(openInferenceMessages(input))
 	} else if raw := attribute(f.attributes, GenAIInputMessages); raw != nil {
+		var msgs OutputMessages
 		msgs, inputLabel = f.side(decode(raw), RoleUser)
 		f.out.Input = inputMessages(msgs)
 	}
-	if msgs := openInferenceMessages(output); len(msgs) > 0 {
-		f.out.Output = msgs
+	if len(output) > 0 {
+		f.out.Output = openInferenceMessages(output)
 		if fr := finishReason(stringOf(attribute(f.attributes, openInferenceFinishReason))); fr != nil {
 			for i := range f.out.Output {
 				f.out.Output[i].FinishReason = fr

pkg/types/aiobservabilitytypes/message_format_openinference_test.go

@@ -160,30 +160,16 @@ func TestFormat_OpenInference(t *testing.T) {
 			// which the mapper moves onto gen_ai.output.messages
 			// https://github.com/Arize-ai/openinference/blob/12f2cc035edfb00b60b656d977f07abfb7a69900/python/instrumentation/openinference-instrumentation-pipecat/src/openinference/instrumentation/pipecat/_attributes.py#L430
 			// https://github.com/Arize-ai/openinference/blob/12f2cc035edfb00b60b656d977f07abfb7a69900/python/instrumentation/openinference-instrumentation-pipecat/src/openinference/instrumentation/pipecat/_observer.py#L628
-			name: "OutputKeysAbsent_RawOutputFormatted",
+			name: "OutputKeysAbsent_RawOutputFormatted_Warns",
 			attributes: map[string]any{
 				"llm.input_messages.0.message.role":    "user",
 				"llm.input_messages.0.message.content": "hi",
 				GenAIOutputMessages:                    "Hello there.",
 			},
-			warnings:   []string{"bare assistant text, role assumed"},
+			warnings:   []string{"bare assistant text, role assumed", "output formatted as text, input as openinference"},
 			wantInput:  `[{"role": "user", "parts": [{"type": "text", "content": "hi"}]}]`,
 			wantOutput: `[{"role": "assistant", "parts": [{"type": "text", "content": "Hello there."}]}]`,
 		},
-		{
-			// LiteLLM's OpenInference mode leaves the output bucket empty on a tool-calling turn; the calls are
-			// the Langfuse output the mapper moved onto gen_ai.output.messages
-			name: "EmptyOutputBucket_RawOutputFormatted",
-			attributes: map[string]any{
-				"llm.input_messages.0.message.role":     "user",
-				"llm.input_messages.0.message.content":  "Yes, go ahead.",
-				"llm.output_messages.0.message.role":    "assistant",
-				"llm.output_messages.0.message.content": "",
-				GenAIOutputMessages:                     `[{"id": "chatcmpl-2", "name": "set_stage", "call_id": "call_8", "type": "function_call", "arguments": {"fields": {"stage": "email"}}}]`,
-			},
-			wantInput:  `[{"role": "user", "parts": [{"type": "text", "content": "Yes, go ahead."}]}]`,
-			wantOutput: `[{"role": "assistant", "parts": [{"type": "tool_call", "name": "set_stage", "id": "call_8", "arguments": {"fields": {"stage": "email"}}}]}]`,
-		},
 		{
 			// message.role left unset by some instrumentors: tool_call_id, tool_calls or neither decide it,
 			// as the collector-contrib normalizer does

pkg/types/aiobservabilitytypes/message_format_test.go

@@ -122,31 +122,6 @@ So, the ball costs 5 cents.`,
 			wantInput:  `[]`,
 			wantOutput: `[]`,
 		},
-		{
-			// Langfuse SDK generation: the app passes the request through superjson, the output is the parsed
-			// structured output
-			name:       "SuperJSONEnvelope_Unwrapped_StructuredOutputGeneric",
-			input:      `{"json": {"model": "gpt-4o-mini", "messages": [{"role": "system", "content": "Extract the main article of the page as JSON."}, {"role": "user", "content": "# Council approves new bike lanes"}], "temperature": 0}}`,
-			output:     `{"hasArticle": true, "article": {"title": "Council approves new bike lanes"}}`,
-			warnings:   []string{"message format not recognised, kept as generic"},
-			wantInput:  `[{"role": "system", "parts": [{"type": "text", "content": "Extract the main article of the page as JSON."}]}, {"role": "user", "parts": [{"type": "text", "content": "# Council approves new bike lanes"}]}]`,
-			wantOutput: `[{"role": "", "parts": [{"type": "generic", "content": "{\"article\":{\"title\":\"Council approves new bike lanes\"},\"hasArticle\":true}"}]}]`,
-		},
-		{
-			name:       "SuperJSONEnvelopeWithMeta_Unwrapped",
-			input:      `{"json": {"messages": [{"role": "user", "content": "What time is it in Oslo?"}]}, "meta": {"values": {"messages.0.at": ["Date"]}}}`,
-			output:     `{"json": {"choices": [{"finish_reason": "stop", "message": {"role": "assistant", "content": "It is 14:05 in Oslo."}}]}, "meta": {"values": {}}}`,
-			wantInput:  `[{"role": "user", "parts": [{"type": "text", "content": "What time is it in Oslo?"}]}]`,
-			wantOutput: `[{"role": "assistant", "parts": [{"type": "text", "content": "It is 14:05 in Oslo."}], "finish_reason": "stop"}]`,
-		},
-		{
-			// a json key beside others is a payload of its own, not the envelope
-			name:       "JSONKeyBesideOthers_NotUnwrapped_Generic",
-			input:      `{"json": {"messages": []}, "schema": "v1"}`,
-			warnings:   []string{"message format not recognised, kept as generic"},
-			wantInput:  `[{"role": "", "parts": [{"type": "generic", "content": "{\"json\":{\"messages\":[]},\"schema\":\"v1\"}"}]}]`,
-			wantOutput: `[]`,
-		},
 		{
 			name:       "NoMessageAttributes_EmptyLists",
 			attributes: map[string]any{GenAIRequestModel: "gpt-4o", GenAIToolName: "get_weather"},

pkg/types/querybuildertypes/querybuildertypesv5/cached.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"maps"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/cachetypes"
 )
 
@@ -33,6 +34,15 @@ func (c *CachedBucket) Clone() *CachedBucket {
 	}
 }
 
+func (c *CachedBucket) Contains(other *CachedBucket) bool {
+	return c.StartMs <= other.StartMs && other.EndMs <= c.EndMs
+}
+
+// true if c and other overlap or sit edge to edge, false otherwise.
+func (c *CachedBucket) Touches(other *CachedBucket) bool {
+	return c.StartMs <= other.EndMs && other.StartMs <= c.EndMs
+}
+
 // CachedData represents the full cached data for a query.
 type CachedData struct {
 	Buckets  []*CachedBucket `json:"buckets"`
@@ -77,3 +87,53 @@ func (c *CachedData) Cost() int64 {
 	}
 	return size
 }
+
+func (r *Result) SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs uint64) ([]*CachedBucket, error) {
+	tsData, ok := r.Value.(*TimeSeriesData)
+	if !ok || tsData == nil {
+		return nil, errors.NewInternalf(errors.CodeInternal, "result of type %s cannot be bucketed", r.Type.StringValue())
+	}
+
+	cellBuckets := make([]*CachedBucket, 0, 1)
+	for from := startMs; from < endMs; {
+		to := endMs
+		if cellWidthMs > 0 {
+			to = min(endMs, (from/cellWidthMs+1)*cellWidthMs)
+		}
+		// A promql value stamped exactly at the window end is an instant inside
+		// the window, so the last slice keeps it. A builder value never sits
+		// there, since the end is step-aligned and partial steps are dropped.
+		sliceEndMs := to
+		if to == endMs {
+			sliceEndMs = endMs + 1
+		}
+		value, err := json.Marshal(tsData.FilterToTimeRange(from, sliceEndMs))
+		if err != nil {
+			return nil, err
+		}
+		cellBuckets = append(cellBuckets, &CachedBucket{
+			StartMs: from,
+			EndMs:   to,
+			Type:    r.Type,
+			Value:   value,
+			Stats:   r.Stats.prorate(to-from, endMs-startMs),
+		})
+		from = to
+	}
+	return cellBuckets, nil
+}
+
+// prorate returns the share of the stats that partMs out of wholeMs of the
+// scanned window accounts for.
+func (e ExecStats) prorate(partMs, wholeMs uint64) ExecStats {
+	ratio := 1.0
+	if partMs < wholeMs {
+		ratio = float64(partMs) / float64(wholeMs)
+	}
+	return ExecStats{
+		RowsScanned:   uint64(float64(e.RowsScanned) * ratio),
+		BytesScanned:  uint64(float64(e.BytesScanned) * ratio),
+		DurationMS:    uint64(float64(e.DurationMS) * ratio),
+		StepIntervals: maps.Clone(e.StepIntervals),
+	}
+}

pkg/types/querybuildertypes/querybuildertypesv5/resp.go

@@ -137,6 +137,28 @@ type TimeSeriesData struct {
 	Aggregations []*AggregationBucket `json:"aggregations" description:"One bucket per aggregation of the query. The order is not guaranteed; match buckets to aggregations by index."`
 }
 
+// FilterToTimeRange copies the aggregation and series structure keeping only
+// the values with startMs <= timestamp < endMs.
+func (t *TimeSeriesData) FilterToTimeRange(startMs, endMs uint64) *TimeSeriesData {
+	filtered := &TimeSeriesData{
+		QueryName:    t.QueryName,
+		Aggregations: make([]*AggregationBucket, 0, len(t.Aggregations)),
+	}
+	for _, aggBucket := range t.Aggregations {
+		filteredBucket := &AggregationBucket{
+			Index:  aggBucket.Index,
+			Alias:  aggBucket.Alias,
+			Meta:   aggBucket.Meta,
+			Series: make([]*TimeSeries, 0, len(aggBucket.Series)),
+		}
+		for _, series := range aggBucket.Series {
+			filteredBucket.Series = append(filteredBucket.Series, series.filterToTimeRange(startMs, endMs))
+		}
+		filtered.Aggregations = append(filtered.Aggregations, filteredBucket)
+	}
+	return filtered
+}
+
 type AggregationBucket struct {
 	Index  int             `json:"index" description:"The zero-based position of the aggregation in the query."`
 	Alias  string          `json:"alias" description:"The alias of the aggregation, or the internal name __result_N, with N its index, when no alias was given."`
@@ -259,6 +281,21 @@ func (ts *TimeSeries) EvaluableValues() []*TimeSeriesValue {
 	return result
 }
 
+// filterToTimeRange copies the series keeping only the values with
+// startMs <= timestamp < endMs.
+func (ts *TimeSeries) filterToTimeRange(startMs, endMs uint64) *TimeSeries {
+	filtered := &TimeSeries{
+		Labels: ts.Labels,
+		Values: make([]*TimeSeriesValue, 0, len(ts.Values)),
+	}
+	for _, value := range ts.Values {
+		if timestamp := uint64(value.Timestamp); timestamp >= startMs && timestamp < endMs {
+			filtered.Values = append(filtered.Values, value)
+		}
+	}
+	return filtered
+}
+
 type Label struct {
 	Key   telemetrytypes.TelemetryFieldKey `json:"key" description:"The group-by field this label value belongs to."`
 	Value any                              `json:"value" description:"The label value as a string, number or boolean."`

pkg/types/querybuildertypes/querybuildertypesv5/resp_test.go

@@ -436,3 +436,97 @@ func TestRoundToNonZeroDecimals(t *testing.T) {
 	assert.Equal(t, math.Inf(1), roundToNonZeroDecimals(math.Inf(1), 3))
 	assert.Equal(t, math.Inf(-1), roundToNonZeroDecimals(math.Inf(-1), 3))
 }
+
+func TestTimeSeriesDataFilterToTimeRange(t *testing.T) {
+	testCases := []struct {
+		name             string
+		timeSeriesData   *TimeSeriesData
+		startMs          uint64
+		endMs            uint64
+		expectedFiltered *TimeSeriesData
+	}{
+		{
+			name: "HalfOpenRange_KeepsStartDropsEnd",
+			timeSeriesData: &TimeSeriesData{
+				QueryName: "A",
+				Aggregations: []*AggregationBucket{{
+					Index: 0,
+					Series: []*TimeSeries{{
+						Labels: []*Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "node-1"}},
+						Values: []*TimeSeriesValue{
+							{Timestamp: 1000, Value: 1},
+							{Timestamp: 2000, Value: 2},
+							{Timestamp: 3000, Value: 3},
+							{Timestamp: 4000, Value: 4},
+						},
+					}},
+				}},
+			},
+			startMs: 2000,
+			endMs:   4000,
+			expectedFiltered: &TimeSeriesData{
+				QueryName: "A",
+				Aggregations: []*AggregationBucket{{
+					Index: 0,
+					Series: []*TimeSeries{{
+						Labels: []*Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "node-1"}},
+						Values: []*TimeSeriesValue{
+							{Timestamp: 2000, Value: 2},
+							{Timestamp: 3000, Value: 3},
+						},
+					}},
+				}},
+			},
+		},
+		{
+			// heatmap counts are positional against Meta.Buckets, so the axis
+			// has to survive even when no value falls in the range
+			name: "NothingInRange_KeepsSeriesAndHeatmapAxis",
+			timeSeriesData: &TimeSeriesData{
+				QueryName: "A",
+				Aggregations: []*AggregationBucket{{
+					Index: 1,
+					Alias: "__result_1",
+					Meta:  AggregationMeta{Unit: "By", Buckets: []float64{1, 2, 4}},
+					Series: []*TimeSeries{{
+						Labels: []*Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "node-1"}},
+						Values: []*TimeSeriesValue{{Timestamp: 1000, Values: []float64{1, 2, 3, 4}}},
+					}},
+				}},
+			},
+			startMs: 5000,
+			endMs:   6000,
+			expectedFiltered: &TimeSeriesData{
+				QueryName: "A",
+				Aggregations: []*AggregationBucket{{
+					Index: 1,
+					Alias: "__result_1",
+					Meta:  AggregationMeta{Unit: "By", Buckets: []float64{1, 2, 4}},
+					Series: []*TimeSeries{{
+						Labels: []*Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "node-1"}},
+						Values: []*TimeSeriesValue{},
+					}},
+				}},
+			},
+		},
+		{
+			name: "NoSeries_KeepsAggregation",
+			timeSeriesData: &TimeSeriesData{
+				QueryName:    "A",
+				Aggregations: []*AggregationBucket{{Index: 0}},
+			},
+			startMs: 1000,
+			endMs:   2000,
+			expectedFiltered: &TimeSeriesData{
+				QueryName:    "A",
+				Aggregations: []*AggregationBucket{{Index: 0, Series: []*TimeSeries{}}},
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, testCase.expectedFiltered, testCase.timeSeriesData.FilterToTimeRange(testCase.startMs, testCase.endMs))
+		})
+	}
+}