test(traces-qb): expand attribute-JSON coverage (agg, group-by, resolution)

Extend the attribute-JSON unit tests to the remaining functional requirements
on the JSON-on path (window fully after release):

- IN / NOT IN / BETWEEN operators.
- ColumnExpressionFor group-by (coerced to String) and aggregation (coerced to
  Float64), both exists-guarded.
- No-ambiguity-warning: a plain attribute filter must not warn, since the JSON
  column is a second physical home for one logical field, not a second field.
- Branch-flip guard: a data-type-unspecified attribute key still resolves to no
  column, keeping bare keys on the legacy CandidateKeys/synthesis path.

Assisted-by: Claude Opus 4.8

cmd/community/server.go

@@ -46,7 +46,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -104,8 +103,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()

cmd/enterprise/server.go

@@ -63,7 +63,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -137,8 +136,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule, systemDashboardRegistry)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)

docs/api/openapi.yml

@@ -15359,73 +15359,6 @@ paths:
       summary: Migrate dashboard to v2
       tags:
       - dashboard
-  /api/v2/dashboards/system/{name}:
-    get:
-      deprecated: false
-      description: Returns a dashboard SigNoz ships and owns, addressed by its stable
-        definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards
-        are read-only and upgraded through releases. The dashboard's own `name` field
-        carries a reserved prefix that the path segment must not include.
-      operationId: GetSystemDashboard
-      parameters:
-      - in: path
-        name: name
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/DashboardtypesGettableDashboardV2'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - dashboard:read
-      - tokenizer:
-        - dashboard:read
-      summary: Get system dashboard
-      tags:
-      - dashboard
   /api/v2/factor_password/forgot:
     post:
       deprecated: false

ee/modules/dashboard/impldashboard/module.go

@@ -32,9 +32,9 @@ type module struct {
 	tagModule          tag.Module
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -276,10 +276,6 @@ func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UU
 	return module.pkgDashboardModule.GetV2(ctx, orgID, id)
 }
 
-func (module *module) GetByNameV2(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.GetByNameV2(ctx, orgID, name)
-}
-
 func (module *module) MigrateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
 	return module.pkgDashboardModule.MigrateV2(ctx, orgID, id)
 }
@@ -288,10 +284,6 @@ func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer
 	return module.pkgDashboardModule.UpdateV2(ctx, orgID, id, updatedBy, updatable)
 }
 
-func (module *module) UpdateUnsafeV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.UpdateUnsafeV2(ctx, orgID, id, updatedBy, updatable)
-}
-
 func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
 	return module.pkgDashboardModule.PatchV2(ctx, orgID, id, updatedBy, patch)
 }
@@ -369,14 +361,6 @@ func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valu
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
 }
 
-func (module *module) ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error {
-	return module.pkgDashboardModule.ReconcileSystemDashboards(ctx, orgID)
-}
-
-func (module *module) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.GetSystemDashboard(ctx, orgID, name)
-}
-
 func (module *module) delete(ctx context.Context, orgID, id valuer.UUID) error {
 	return module.store.RunInTx(ctx, func(ctx context.Context) error {
 		if err := module.store.DeletePublic(ctx, id.String()); err != nil && !errors.Ast(err, errors.TypeNotFound) {

frontend/src/api/generated/services/dashboard/index.ts

@@ -46,8 +46,6 @@ import type {
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	GetSystemDashboard200,
-	GetSystemDashboardPathParameters,
 	ListDashboardViews200,
 	ListDashboardsForUserV2200,
 	ListDashboardsForUserV2Params,
@@ -1887,108 +1885,6 @@ export const useMigrateDashboardV2 = <
 > => {
 	return useMutation(getMigrateDashboardV2MutationOptions(options));
 };
-/**
- * Returns a dashboard SigNoz ships and owns, addressed by its stable definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards are read-only and upgraded through releases. The dashboard's own `name` field carries a reserved prefix that the path segment must not include.
- * @summary Get system dashboard
- */
-export const getSystemDashboard = (
-	{ name }: GetSystemDashboardPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetSystemDashboard200>({
-		url: `/api/v2/dashboards/system/${name}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetSystemDashboardQueryKey = ({
-	name,
-}: GetSystemDashboardPathParameters) => {
-	return [`/api/v2/dashboards/system/${name}`] as const;
-};
-
-export const getGetSystemDashboardQueryOptions = <
-	TData = Awaited<ReturnType<typeof getSystemDashboard>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ name }: GetSystemDashboardPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getSystemDashboard>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetSystemDashboardQueryKey({ name });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getSystemDashboard>>
-	> = ({ signal }) => getSystemDashboard({ name }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!name,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getSystemDashboard>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetSystemDashboardQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getSystemDashboard>>
->;
-export type GetSystemDashboardQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get system dashboard
- */
-
-export function useGetSystemDashboard<
-	TData = Awaited<ReturnType<typeof getSystemDashboard>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ name }: GetSystemDashboardPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getSystemDashboard>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetSystemDashboardQueryOptions({ name }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get system dashboard
- */
-export const invalidateGetSystemDashboard = async (
-	queryClient: QueryClient,
-	{ name }: GetSystemDashboardPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetSystemDashboardQueryKey({ name }) },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint returns the sanitized v2-shape dashboard data for public access. Each panel query is reduced to a safe field subset, so filters and raw query strings are not exposed.
  * @summary Get public dashboard data (v2)

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

@@ -11313,17 +11313,6 @@ export type MigrateDashboardV2200 = {
 	status: string;
 };
 
-export type GetSystemDashboardPathParameters = {
-	name: string;
-};
-export type GetSystemDashboard200 = {
-	data: DashboardtypesGettableDashboardV2DTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetFeatures200 = {
 	/**
 	 * @type array

frontend/src/components/ExplorerCard/ExplorerCard.tsx

@@ -7,8 +7,9 @@ import axios from 'axios';
 import TextToolTip from 'components/TextToolTip';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { LOCALSTORAGE } from 'constants/localStorage';
+import { QueryParams } from 'constants/query';
 import { useOptionsMenu } from 'container/OptionsMenu';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useDeleteView } from 'hooks/saveViews/useDeleteView';
 import { useGetAllViews } from 'hooks/saveViews/useGetAllViews';
@@ -68,7 +69,9 @@ function ExplorerCard({
 		setIsOpen(newOpen);
 	};
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const { options } = useOptionsMenu({
 		storageKey:

frontend/src/components/ExplorerCard/constants.ts

@@ -1,3 +1,5 @@
+import { QueryParams } from 'constants/query';
+
 export const ExploreHeaderToolTip = {
 	url: 'https://signoz.io/docs/querying/overview/?utm_source=product&utm_medium=new-query-builder',
 	text: 'More details on how to use query builder',
@@ -7,3 +9,5 @@ export const SaveButtonText = {
 	SAVE_AS_NEW_VIEW: 'Save as new view',
 	SAVE_VIEW: 'Save view',
 };
+
+export type QuerySearchParamNames = QueryParams.viewName | QueryParams.viewKey;

frontend/src/container/ExplorerOptions/ExplorerOptions.tsx

@@ -54,7 +54,7 @@ import {
 } from 'container/OptionsMenu/constants';
 import { OptionsQuery } from 'container/OptionsMenu/types';
 import { ExportDashboard } from 'hooks/dashboard/useExportDashboards';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useGetAllViews } from 'hooks/saveViews/useGetAllViews';
 import { useSaveView } from 'hooks/saveViews/useSaveView';
@@ -287,7 +287,8 @@ function ExplorerOptions({
 
 	const compositeQuery = mapCompositeQueryFromQuery(currentQuery, panelType);
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const extraData = viewsData?.data?.data?.find(
 		(view) => view.id === viewKey,

frontend/src/container/LogDetailedView/BodyTitleRenderer.tsx

@@ -15,8 +15,9 @@ import {
 	QUERY_BUILDER_FUNCTIONS,
 } from 'constants/antlrQueryConstants';
 import { FeatureKeys } from 'constants/features';
+import { QueryParams } from 'constants/query';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { useNotifications } from 'hooks/useNotifications';
@@ -49,7 +50,7 @@ function BodyTitleRenderer({
 	const { featureFlags } = useAppContext();
 	const [, setCopy] = useCopyToClipboard();
 	const { notifications } = useNotifications();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 
 	const cleanedNodeKey = removeObjectFromString(nodeKey);
 	const isBodyJsonQueryEnabled =

frontend/src/container/LogDetailedView/TableView/TableViewActions.tsx

@@ -7,12 +7,13 @@ import GroupByIcon from 'assets/CustomIcons/GroupByIcon';
 import cx from 'classnames';
 import CopyClipboardHOC from 'components/Logs/CopyClipboardHOC';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
+import { QueryParams } from 'constants/query';
 import { OPERATORS } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
 import { MetricsType } from 'container/MetricsApplication/constant';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import {
@@ -140,7 +141,7 @@ export default function TableViewActions(
 
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 	const { dataType, logType: fieldType } = getFieldAttributes(record.field);
 
 	// there is no option for where clause in old logs explorer and live logs page or infra monitoring

frontend/src/container/LogDetailedView/TableView/__test__/TableViewActions.test.tsx

@@ -1,6 +1,6 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
 
@@ -88,7 +88,7 @@ jest.mock('react-router-dom', () => ({
 }));
 
 jest.mock('hooks/queryBuilder/useQueryBuilder');
-jest.mock('hooks/saveViews/useGetSavedViewParams');
+jest.mock('hooks/queryBuilder/useGetSearchQueryParam');
 
 describe('TableViewActions', () => {
 	const TEST_VALUE = 'test value';
@@ -140,10 +140,8 @@ describe('TableViewActions', () => {
 			}),
 		} as any);
 
-		// Default mock for useGetSavedViewParams
-		jest
-			.mocked(useGetSavedViewParams)
-			.mockReturnValue({ viewName: '', viewKey: '' });
+		// Default mock for useGetSearchQueryParam
+		jest.mocked(useGetSearchQueryParam).mockReturnValue(null);
 	});
 
 	it('should render without crashing', () => {
@@ -251,9 +249,7 @@ describe('TableViewActions', () => {
 			updateQueriesData: mockUpdateQueriesData,
 		} as any);
 
-		jest
-			.mocked(useGetSavedViewParams)
-			.mockReturnValue({ viewName: '', viewKey: '' });
+		jest.mocked(useGetSearchQueryParam).mockReturnValue(null);
 
 		render(
 			<TableViewActions

frontend/src/container/LogDetailedView/hooks/useLogAttributeActions.tsx

@@ -3,9 +3,10 @@ import { useLocation } from 'react-router-dom';
 import { CircleMinus, CirclePlus, Layers, RefreshCw } from '@signozhq/icons';
 import { convertFiltersToExpression } from 'components/QueryBuilderV2/utils';
 import { FeatureKeys } from 'constants/features';
+import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
@@ -57,7 +58,7 @@ export function useLogAttributeActions({
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
 	const { featureFlags } = useAppContext();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 
 	const isBodyJsonQueryEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.USE_JSON_BODY)

frontend/src/hooks/queryBuilder/useGetSearchQueryParam.ts

@@ -0,0 +1,15 @@
+import { useMemo } from 'react';
+import { QuerySearchParamNames } from 'components/ExplorerCard/constants';
+import useUrlQuery from 'hooks/useUrlQuery';
+
+export const useGetSearchQueryParam = (
+	searchParams: QuerySearchParamNames,
+): string | null => {
+	const urlQuery = useUrlQuery();
+
+	return useMemo(() => {
+		const searchQuery = urlQuery.get(searchParams);
+
+		return searchQuery ? JSON.parse(searchQuery) : null;
+	}, [urlQuery, searchParams]);
+};

frontend/src/hooks/saveViews/__tests__/useGetSavedViewParams.test.ts

@@ -1,60 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import useUrlQuery from 'hooks/useUrlQuery';
-
-import { useGetSavedViewParams } from '../useGetSavedViewParams';
-
-jest.mock('hooks/useUrlQuery');
-
-const mockedUseUrlQuery = useUrlQuery as jest.Mock;
-
-const setSearch = (search: string): void => {
-	mockedUseUrlQuery.mockReturnValue(new URLSearchParams(search));
-};
-
-describe('useGetSavedViewParams', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns empty strings when no params are present', () => {
-		setSearch('');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({ viewName: '', viewKey: '' });
-	});
-
-	it('parses JSON-stringified values', () => {
-		setSearch(
-			`viewName=${encodeURIComponent(
-				JSON.stringify('Hindsight'),
-			)}&viewKey=${encodeURIComponent(JSON.stringify('abc-123'))}`,
-		);
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({
-			viewName: 'Hindsight',
-			viewKey: 'abc-123',
-		});
-	});
-
-	it('falls back to the raw string when a value is not valid JSON', () => {
-		setSearch('viewName=Hindsight&viewKey=some-uuid-value');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({
-			viewName: 'Hindsight',
-			viewKey: 'some-uuid-value',
-		});
-	});
-
-	it('does not throw and keeps the raw string for non-string JSON', () => {
-		setSearch('viewName=123');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({ viewName: '123', viewKey: '' });
-	});
-});

frontend/src/hooks/saveViews/useGetSavedViewParams.ts

@@ -1,33 +0,0 @@
-import { useMemo } from 'react';
-import { QueryParams } from 'constants/query';
-import useUrlQuery from 'hooks/useUrlQuery';
-
-interface SavedViewParams {
-	viewName: string;
-	viewKey: string;
-}
-
-const parseViewParam = (value: string | null): string => {
-	if (!value) {
-		return '';
-	}
-
-	try {
-		const parsed = JSON.parse(value);
-		return typeof parsed === 'string' ? parsed : value;
-	} catch {
-		return value;
-	}
-};
-
-export const useGetSavedViewParams = (): SavedViewParams => {
-	const urlQuery = useUrlQuery();
-
-	return useMemo(
-		() => ({
-			viewName: parseViewParam(urlQuery.get(QueryParams.viewName)),
-			viewKey: parseViewParam(urlQuery.get(QueryParams.viewKey)),
-		}),
-		[urlQuery],
-	);
-};

frontend/src/hooks/useHandleExplorerTabChange.ts

@@ -6,7 +6,7 @@ import { SIGNOZ_VALUE } from 'container/QueryBuilder/filters/OrderByFilter/const
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { useGetSavedViewParams } from './saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from './queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from './queryBuilder/useQueryBuilder';
 
 export interface ICurrentQueryData {
@@ -31,7 +31,9 @@ export const useHandleExplorerTabChange = (): {
 		updateQueriesData,
 	} = useQueryBuilder();
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const getUpdateQuery = useCallback(
 		(newPanelType: PANEL_TYPES): Query => {

pkg/apiserver/signozapiserver/dashboard.go

@@ -332,33 +332,6 @@ func (provider *provider) addDashboardRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/dashboards/system/{name}", handler.New(
-		provider.authzMiddleware.CheckResources(provider.dashboardHandler.GetSystemDashboard, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName),
-		handler.OpenAPIDef{
-			ID:                  "GetSystemDashboard",
-			Tags:                []string{"dashboard"},
-			Summary:             "Get system dashboard",
-			Description:         "Returns a dashboard SigNoz ships and owns, addressed by its stable definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards are read-only and upgraded through releases. The dashboard's own `name` field carries a reserved prefix that the path segment must not include.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(dashboardtypes.GettableDashboardV2),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceDashboard.Scope(coretypes.VerbRead)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceDashboard,
-			Verb:     coretypes.VerbRead,
-			Category: coretypes.ActionCategoryDataAccess,
-			ID:       provider.systemDashboardID(),
-			Selector: coretypes.IDSelector,
-		}),
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
 	// Pinning mutates the calling user's pin list, not the dashboard, so it rides
 	// on the collection-level list permission rather than a per-dashboard check.
 	// The id is still extracted, for audit.
@@ -745,23 +718,3 @@ func (provider *provider) addDashboardRoutes(router *mux.Router) error {
 
 	return nil
 }
-
-// systemDashboardID resolves the {name} path param to the dashboard's id. Authz
-// tuples and audit records are written against ids, so the name has to be
-// resolved before either runs.
-func (provider *provider) systemDashboardID() coretypes.ResourceIDExtractor {
-	return coretypes.NewResourceIDExtractor(coretypes.PhaseRequest, func(ec coretypes.ExtractorContext) (string, error) {
-		ctx := ec.Request.Context()
-		claims, err := authtypes.ClaimsFromContext(ctx)
-		if err != nil {
-			return "", err
-		}
-
-		systemDashboard, err := provider.dashboardModule.GetSystemDashboard(ctx, valuer.MustNewUUID(claims.OrgID), mux.Vars(ec.Request)["name"])
-		if err != nil {
-			return "", err
-		}
-
-		return systemDashboard.ID.StringValue(), nil
-	})
-}

pkg/modules/dashboard/dashboard.go

@@ -63,8 +63,6 @@ type Module interface {
 
 	GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error)
 
-	GetByNameV2(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error)
-
 	// MigrateV2 retries the v1→v2 migration on a dashboard still stored in the v1 schema.
 	MigrateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error)
 
@@ -74,9 +72,6 @@ type Module interface {
 
 	UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error)
 
-	// UpdateUnsafeV2 updates a dashboard bypassing the guards. Intended for internal system callers.
-	UpdateUnsafeV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
 	LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error
 
 	PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error)
@@ -104,14 +99,6 @@ type Module interface {
 	DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 
 	GetByMetricNamesV2(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string][]dashboardtypes.DashboardPanelRef, error)
-
-	// ════════════════════════════════════════════════════════════════════════
-	// System dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-
-	ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error
-
-	GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error)
 }
 
 type Handler interface {
@@ -175,6 +162,4 @@ type Handler interface {
 	UpdateView(http.ResponseWriter, *http.Request)
 
 	DeleteView(http.ResponseWriter, *http.Request)
-
-	GetSystemDashboard(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/fs/definitions/ai-o11y-overview.json

@@ -1,17 +0,0 @@
-{
-  "version": 1,
-  "definition": {
-    "schemaVersion": "v6",
-    "name": "signoz---ai-o11y-overview",
-    "tags": [],
-    "spec": {
-      "display": {
-        "name": "AI Observability Overview",
-        "description": "Overview of LLM traffic. Panels ship in an upcoming release."
-      },
-      "variables": [],
-      "panels": {},
-      "layouts": []
-    }
-  }
-}

pkg/modules/dashboard/impldashboard/module.go

@@ -21,25 +21,23 @@ import (
 )
 
 type module struct {
-	store                   dashboardtypes.Store
-	settings                factory.ScopedProviderSettings
-	analytics               analytics.Analytics
-	orgGetter               organization.Getter
-	queryParser             queryparser.QueryParser
-	tagModule               tag.Module
-	systemDashboardRegistry dashboardtypes.SystemDashboardRegistry
+	store       dashboardtypes.Store
+	settings    factory.ScopedProviderSettings
+	analytics   analytics.Analytics
+	orgGetter   organization.Getter
+	queryParser queryparser.QueryParser
+	tagModule   tag.Module
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard")
 	return &module{
-		store:                   store,
-		settings:                scopedProviderSettings,
-		analytics:               analytics,
-		orgGetter:               orgGetter,
-		queryParser:             queryParser,
-		tagModule:               tagModule,
-		systemDashboardRegistry: systemDashboardRegistry,
+		store:       store,
+		settings:    scopedProviderSettings,
+		analytics:   analytics,
+		orgGetter:   orgGetter,
+		queryParser: queryParser,
+		tagModule:   tagModule,
 	}
 }
 

pkg/modules/dashboard/impldashboard/store.go

@@ -3,7 +3,6 @@ package impldashboard
 import (
 	"context"
 	"strings"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -65,23 +64,6 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
-func (store *store) GetByName(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.StorableDashboard, error) {
-	storableDashboard := new(dashboardtypes.StorableDashboard)
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(storableDashboard).
-		Where("name = ?", name).
-		Where("org_id = ?", orgID).
-		Scan(ctx)
-	if err != nil {
-		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "dashboard with name %s doesn't exist", name)
-	}
-
-	return storableDashboard, nil
-}
-
 // ListForUser emits the joined dashboard ⨝ user_dashboard_preference query the
 // spec calls for. Aliases:
 //
@@ -631,60 +613,3 @@ func (store *store) DeleteDashboardView(ctx context.Context, orgID valuer.UUID,
 	}
 	return nil
 }
-
-func (store *store) CreateSystemDashboard(ctx context.Context, storable *dashboardtypes.StorableSystemDashboard) error {
-	_, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewInsert().
-		Model(storable).
-		Exec(ctx)
-	if err != nil {
-		return store.sqlstore.WrapAlreadyExistsErrf(err, dashboardtypes.ErrCodeSystemDashboardAlreadyProvisioned, "system dashboard %s is already provisioned", storable.Name)
-	}
-
-	return nil
-}
-
-func (store *store) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.StorableSystemDashboard, error) {
-	storable := new(dashboardtypes.StorableSystemDashboard)
-	err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewSelect().
-		Model(storable).
-		Where("org_id = ?", orgID).
-		Where("name = ?", name).
-		Scan(ctx)
-	if err != nil {
-		return nil, store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeSystemDashboardNotFound, "system dashboard %s is not provisioned", name)
-	}
-
-	return storable, nil
-}
-
-func (store *store) UpdateSystemDashboardVersion(ctx context.Context, orgID valuer.UUID, name string, version int) error {
-	result, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model(new(dashboardtypes.StorableSystemDashboard)).
-		Set("version = ?", version).
-		Set("updated_at = ?", time.Now()).
-		Where("org_id = ?", orgID).
-		Where("name = ?", name).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rows, err := result.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeSystemDashboardNotFound, "system dashboard %s is not provisioned", name)
-	}
-
-	return nil
-}

pkg/modules/dashboard/impldashboard/system_dashboard_definitions.go

@@ -1,46 +0,0 @@
-package impldashboard
-
-import (
-	"embed"
-	"io/fs"
-	"path"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-)
-
-const definitionsRoot = "fs/definitions"
-
-//go:embed fs/definitions/*.json
-var definitionFiles embed.FS
-
-// NewSystemDashboardRegistry parses every embedded definition. Definitions are
-// build-time assets validated by a test, so a failure here means the binary
-// shipped broken JSON.
-func NewSystemDashboardRegistry() (dashboardtypes.SystemDashboardRegistry, error) {
-	entries, err := fs.ReadDir(definitionFiles, definitionsRoot)
-	if err != nil {
-		return dashboardtypes.SystemDashboardRegistry{}, errors.WrapInternalf(err, errors.CodeInternal, "couldn't read system dashboard definitions")
-	}
-
-	definitions := make([]dashboardtypes.SystemDashboardDefinition, 0, len(entries))
-	for _, entry := range entries {
-		if entry.IsDir() {
-			continue
-		}
-
-		file := path.Join(definitionsRoot, entry.Name())
-		raw, err := definitionFiles.ReadFile(file)
-		if err != nil {
-			return dashboardtypes.SystemDashboardRegistry{}, errors.WrapInternalf(err, errors.CodeInternal, "couldn't read %s", file)
-		}
-
-		definition, err := dashboardtypes.NewSystemDashboardDefinition(raw)
-		if err != nil {
-			return dashboardtypes.SystemDashboardRegistry{}, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "couldn't parse %s", file)
-		}
-		definitions = append(definitions, definition)
-	}
-
-	return dashboardtypes.NewSystemDashboardRegistry(definitions)
-}

pkg/modules/dashboard/impldashboard/system_dashboard_service.go

@@ -1,81 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"log/slog"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-)
-
-const reconcileRetryInterval = 30 * time.Second
-
-type service struct {
-	settings  factory.ScopedProviderSettings
-	module    dashboard.Module
-	orgGetter organization.Getter
-	stopC     chan struct{}
-	healthyC  chan struct{}
-}
-
-// NewService reconciles every org's system dashboards once at startup. Orgs
-// created later are reconciled by the organization setter instead.
-func NewService(providerSettings factory.ProviderSettings, module dashboard.Module, orgGetter organization.Getter) factory.Service {
-	return &service{
-		settings:  factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"),
-		module:    module,
-		orgGetter: orgGetter,
-		stopC:     make(chan struct{}),
-		healthyC:  make(chan struct{}),
-	}
-}
-
-func (service *service) Start(ctx context.Context) error {
-	ticker := time.NewTicker(reconcileRetryInterval)
-	defer ticker.Stop()
-
-	for {
-		err := service.reconcile(ctx)
-		if err == nil {
-			close(service.healthyC)
-			<-service.stopC
-			return nil
-		}
-
-		service.settings.Logger().WarnContext(ctx, "system dashboard reconciliation failed, retrying", errors.Attr(err))
-
-		select {
-		case <-service.stopC:
-			return nil
-		case <-ticker.C:
-		}
-	}
-}
-
-func (service *service) Healthy() <-chan struct{} {
-	return service.healthyC
-}
-
-func (service *service) Stop(_ context.Context) error {
-	close(service.stopC)
-	return nil
-}
-
-func (service *service) reconcile(ctx context.Context) error {
-	orgs, err := service.orgGetter.ListByOwnedKeyRange(ctx)
-	if err != nil {
-		return err
-	}
-
-	for _, org := range orgs {
-		if err := service.module.ReconcileSystemDashboards(ctx, org.ID); err != nil {
-			return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "couldn't reconcile system dashboards for org %s", org.ID.StringValue())
-		}
-	}
-
-	service.settings.Logger().InfoContext(ctx, "system dashboard reconciliation completed", slog.Int("orgs", len(orgs)))
-	return nil
-}

pkg/modules/dashboard/impldashboard/v2_handler.go

@@ -502,28 +502,3 @@ func (handler *handler) GetPublicWidgetQueryRangeV2(rw http.ResponseWriter, r *h
 
 	render.Success(rw, http.StatusOK, queryRangeResults)
 }
-
-func (handler *handler) GetSystemDashboard(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	name := mux.Vars(r)["name"]
-	if name == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "name is missing in the path"))
-		return
-	}
-
-	systemDashboard, err := handler.module.GetSystemDashboard(ctx, valuer.MustNewUUID(claims.OrgID), name)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, systemDashboard.ToGettableDashboardV2())
-}

pkg/modules/dashboard/impldashboard/v2_module.go

@@ -2,8 +2,6 @@ package impldashboard
 
 import (
 	"context"
-	"log/slog"
-	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/transition"
@@ -21,12 +19,9 @@ func (m *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy stri
 		return nil, err
 	}
 
-	dashboard, err := postable.NewDashboardV2(orgID, createdBy, source)
-	if err != nil {
-		return nil, err
-	}
+	dashboard := postable.NewDashboardV2(orgID, createdBy, source)
 
-	err = m.store.RunInTx(ctx, func(ctx context.Context) error {
+	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
 		resolvedTags, err := m.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, dashboard.ID, postable.Tags)
 		if err != nil {
 			return err
@@ -125,20 +120,6 @@ func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UU
 	return storable.ToDashboardV2(tags)
 }
 
-func (module *module) GetByNameV2(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
-	storable, err := module.store.GetByName(ctx, orgID, name)
-	if err != nil {
-		return nil, err
-	}
-
-	tags, err := module.tagModule.ListForResource(ctx, orgID, coretypes.KindDashboard, storable.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return storable.ToDashboardV2(tags)
-}
-
 // MigrateV2 retries the v1→v2 migration on a dashboard still stored as v1 (one the
 // bulk 103 migration skipped or failed). Idempotent: an already-v2 one is unchanged.
 func (module *module) MigrateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
@@ -198,32 +179,13 @@ func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer
 		return nil, err
 	}
 
-	return module.updateV2(ctx, orgID, existing, updatedBy, updatable, existing.Update)
-}
-
-func (module *module) UpdateUnsafeV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	if err := updatable.Validate(); err != nil {
-		return nil, err
-	}
-
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	return module.updateV2(ctx, orgID, existing, updatedBy, updatable, existing.UpdateUnsafe)
-}
-
-// apply is existing.Update or existing.UpdateUnsafe, so the gated path keeps its
-// in-transaction checks and only UpdateUnsafeV2 skips them.
-func (module *module) updateV2(ctx context.Context, orgID valuer.UUID, existing *dashboardtypes.DashboardV2, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2, apply func(dashboardtypes.UpdatableDashboardV2, string, []*tagtypes.Tag) error) (*dashboardtypes.DashboardV2, error) {
-	err := module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, existing.ID, updatable.Tags)
+	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
+		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updatable.Tags)
 		if err != nil {
 			return err
 		}
 
-		err = apply(updatable, updatedBy, resolvedTags)
+		err = existing.Update(updatable, updatedBy, resolvedTags)
 		if err != nil {
 			return err
 		}
@@ -334,98 +296,3 @@ func (module *module) UnpinV2(ctx context.Context, orgID valuer.UUID, userID val
 func (module *module) DeletePreferencesForUser(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
 	return module.store.DeletePreferencesForUser(ctx, orgID, userID)
 }
-
-func (m *module) ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error {
-	for _, definition := range m.systemDashboardRegistry.List() {
-		if err := m.reconcileSystemDashboard(ctx, orgID, definition); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *module) reconcileSystemDashboard(ctx context.Context, orgID valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
-	existing, err := m.GetByNameV2(ctx, orgID, definition.Name())
-	if err != nil {
-		if !errors.Ast(err, errors.TypeNotFound) {
-			return err
-		}
-		return m.provisionSystemDashboard(ctx, orgID, definition)
-	}
-
-	state, err := m.store.GetSystemDashboard(ctx, orgID, definition.Name())
-	if err != nil {
-		return err
-	}
-	// Only ever move forward: a downgrade must not rewrite the newer content.
-	if state.Version >= definition.Version {
-		return nil
-	}
-
-	return m.upgradeSystemDashboard(ctx, orgID, existing.ID, definition)
-}
-
-// provisionSystemDashboard creates the dashboard and its state row in one transaction,
-// so a system dashboard can never exist without the version it was provisioned at.
-// A concurrent provisioner (another replica, or the org-creation hook racing the
-// startup sweep) loses on the state row's unique (org_id, name) index and rolls back.
-func (m *module) provisionSystemDashboard(ctx context.Context, orgID valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
-	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
-		created, err := m.CreateV2(
-			ctx,
-			orgID,
-			dashboardtypes.ProvisionerIdentity,
-			valuer.UUID{},
-			dashboardtypes.SourceSystem,
-			definition.Dashboard,
-		)
-		if err != nil {
-			return err
-		}
-
-		return m.store.CreateSystemDashboard(ctx, dashboardtypes.NewStorableSystemDashboard(orgID, created.ID, definition.Name(), definition.Version))
-	})
-	if err != nil {
-		if errors.Ast(err, errors.TypeAlreadyExists) {
-			m.settings.Logger().DebugContext(ctx, "system dashboard already provisioned concurrently", slog.String("name", definition.Name()), slog.String("org_id", orgID.StringValue()))
-			return nil
-		}
-		return err
-	}
-
-	m.settings.Logger().InfoContext(ctx, "provisioned system dashboard", slog.String("name", definition.Name()), slog.Int("version", definition.Version), slog.String("org_id", orgID.StringValue()))
-	return nil
-}
-
-func (m *module) upgradeSystemDashboard(ctx context.Context, orgID valuer.UUID, id valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
-	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
-		if _, err := m.UpdateUnsafeV2(ctx, orgID, id, dashboardtypes.ProvisionerIdentity, definition.ToUpdatable()); err != nil {
-			return err
-		}
-
-		return m.store.UpdateSystemDashboardVersion(ctx, orgID, definition.Name(), definition.Version)
-	})
-	if err != nil {
-		return err
-	}
-
-	m.settings.Logger().InfoContext(ctx, "upgraded system dashboard", slog.String("name", definition.Name()), slog.Int("version", definition.Version), slog.String("org_id", orgID.StringValue()))
-	return nil
-}
-
-func (m *module) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
-	if strings.HasPrefix(name, dashboardtypes.SystemDashboardNamePrefix) {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "name must not carry the %q prefix", dashboardtypes.SystemDashboardNamePrefix)
-	}
-
-	existing, err := m.GetByNameV2(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+name)
-	if err != nil {
-		return nil, err
-	}
-	if err := existing.ErrIfNotSystem(); err != nil {
-		return nil, err
-	}
-
-	return existing, nil
-}

pkg/modules/dashboard/impldashboard/v2_module_test.go

@@ -1,191 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"path/filepath"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/analytics/analyticstest"
-	"github.com/SigNoz/signoz/pkg/factory/factorytest"
-	"github.com/SigNoz/signoz/pkg/modules/tag/impltag"
-	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlitesqlstore"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-const testDashboardName = "test-overview"
-
-func newTestSQLStore(t *testing.T) sqlstore.SQLStore {
-	t.Helper()
-
-	store, err := sqlitesqlstore.New(context.Background(), factorytest.NewSettings(), sqlstore.Config{
-		Provider:   "sqlite",
-		Connection: sqlstore.ConnectionConfig{MaxOpenConns: 10},
-		Sqlite: sqlstore.SqliteConfig{
-			Path:            filepath.Join(t.TempDir(), "test.db"),
-			Mode:            "wal",
-			BusyTimeout:     5 * time.Second,
-			TransactionMode: "deferred",
-		},
-	})
-	require.NoError(t, err)
-
-	for _, model := range []any{
-		(*dashboardtypes.StorableDashboard)(nil),
-		(*tagtypes.Tag)(nil),
-		(*tagtypes.TagRelation)(nil),
-		(*dashboardtypes.StorableSystemDashboard)(nil),
-	} {
-		_, err := store.BunDB().NewCreateTable().Model(model).IfNotExists().Exec(context.Background())
-		require.NoError(t, err)
-	}
-
-	_, err = store.BunDB().Exec(`CREATE UNIQUE INDEX IF NOT EXISTS uq_system_dashboard_org_name ON system_dashboard (org_id, name)`)
-	require.NoError(t, err)
-
-	return store
-}
-
-func newTestModule(t *testing.T, sqlStore sqlstore.SQLStore, definitions ...dashboardtypes.SystemDashboardDefinition) *module {
-	t.Helper()
-
-	registry, err := dashboardtypes.NewSystemDashboardRegistry(definitions)
-	require.NoError(t, err)
-
-	providerSettings := factorytest.NewSettings()
-	return NewModule(
-		NewStore(sqlStore),
-		providerSettings,
-		analyticstest.New(),
-		nil,
-		queryparser.New(providerSettings),
-		impltag.NewModule(impltag.NewStore(sqlStore)),
-		registry,
-	).(*module)
-}
-
-func newTestDefinition(t *testing.T, version int, displayName string) dashboardtypes.SystemDashboardDefinition {
-	t.Helper()
-
-	raw := `{
-		"version": ` + strconv.Itoa(version) + `,
-		"definition": {
-			"schemaVersion": "` + dashboardtypes.SchemaVersion + `",
-			"name": "` + dashboardtypes.SystemDashboardNamePrefix + testDashboardName + `",
-			"tags": [],
-			"spec": {"display": {"name": "` + displayName + `"}, "variables": [], "panels": {}, "layouts": []}
-		}
-	}`
-
-	definition, err := dashboardtypes.NewSystemDashboardDefinition([]byte(raw))
-	require.NoError(t, err)
-
-	return definition
-}
-
-func TestReconcileProvisionsThenUpgrades(t *testing.T) {
-	ctx := context.Background()
-	sqlStore := newTestSQLStore(t)
-	orgID := valuer.GenerateUUID()
-
-	dashboardModule := newTestModule(t, sqlStore, newTestDefinition(t, 1, "v1"))
-	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
-
-	provisioned, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
-	require.NoError(t, err)
-	assert.Equal(t, dashboardtypes.SourceSystem, provisioned.Source)
-	assert.Equal(t, dashboardtypes.ProvisionerIdentity, provisioned.CreatedBy)
-	assert.Equal(t, "v1", provisioned.Spec.Display.Name)
-	assert.Equal(t, 1, stateVersion(t, dashboardModule, ctx, orgID))
-
-	// Reconciling the same version again is a no-op.
-	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
-	unchanged, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
-	require.NoError(t, err)
-	assert.Equal(t, provisioned.UpdatedAt, unchanged.UpdatedAt)
-
-	// An unmodified copy is upgraded in place, keeping its id.
-	upgradingModule := newTestModule(t, sqlStore, newTestDefinition(t, 2, "v2"))
-	require.NoError(t, upgradingModule.ReconcileSystemDashboards(ctx, orgID))
-
-	upgraded, err := upgradingModule.GetSystemDashboard(ctx, orgID, testDashboardName)
-	require.NoError(t, err)
-	assert.Equal(t, provisioned.ID, upgraded.ID)
-	assert.Equal(t, "v2", upgraded.Spec.Display.Name)
-	assert.Equal(t, 2, stateVersion(t, upgradingModule, ctx, orgID))
-}
-
-func stateVersion(t *testing.T, module *module, ctx context.Context, orgID valuer.UUID) int {
-	t.Helper()
-
-	state, err := module.store.GetSystemDashboard(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+testDashboardName)
-	require.NoError(t, err)
-
-	return state.Version
-}
-
-func TestSystemDashboardsAreImmutableToUsers(t *testing.T) {
-	ctx := context.Background()
-	sqlStore := newTestSQLStore(t)
-	orgID := valuer.GenerateUUID()
-
-	dashboardModule := newTestModule(t, sqlStore, newTestDefinition(t, 1, "v1"))
-	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
-
-	provisioned, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
-	require.NoError(t, err)
-
-	_, err = dashboardModule.UpdateV2(ctx, orgID, provisioned.ID, "user@signoz.io", newTestDefinition(t, 1, "edited").ToUpdatable())
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "cannot be modified")
-}
-
-func TestReconcileDoesNotDowngrade(t *testing.T) {
-	ctx := context.Background()
-	sqlStore := newTestSQLStore(t)
-	orgID := valuer.GenerateUUID()
-
-	newerModule := newTestModule(t, sqlStore, newTestDefinition(t, 3, "v3"))
-	require.NoError(t, newerModule.ReconcileSystemDashboards(ctx, orgID))
-
-	olderModule := newTestModule(t, sqlStore, newTestDefinition(t, 2, "v2"))
-	require.NoError(t, olderModule.ReconcileSystemDashboards(ctx, orgID))
-
-	got, err := newerModule.GetSystemDashboard(ctx, orgID, testDashboardName)
-	require.NoError(t, err)
-	assert.Equal(t, "v3", got.Spec.Display.Name)
-	assert.Equal(t, 3, stateVersion(t, newerModule, ctx, orgID))
-}
-
-func TestGetRejectsANonSystemDashboard(t *testing.T) {
-	ctx := context.Background()
-	sqlStore := newTestSQLStore(t)
-	orgID := valuer.GenerateUUID()
-
-	dashboardModule := newTestModule(t, sqlStore)
-
-	var postable dashboardtypes.PostableDashboardV2
-	require.NoError(t, postable.UnmarshalJSON([]byte(`{
-		"schemaVersion": "`+dashboardtypes.SchemaVersion+`",
-		"name": "a-user-dashboard",
-		"tags": [],
-		"spec": {"display": {"name": "user"}, "variables": [], "panels": {}, "layouts": []}
-	}`)))
-	_, err := dashboardModule.CreateV2(ctx, orgID, "user@signoz.io", valuer.GenerateUUID(), dashboardtypes.SourceUser, postable)
-	require.NoError(t, err)
-
-	// The server-side prefix makes user names structurally unreachable here.
-	_, err = dashboardModule.GetSystemDashboard(ctx, orgID, "a-user-dashboard")
-	require.Error(t, err)
-
-	_, err = dashboardModule.GetSystemDashboard(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+testDashboardName)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "must not carry")
-}

pkg/modules/organization/implorganization/setter.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
-	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -15,11 +14,10 @@ type setter struct {
 	store        types.OrganizationStore
 	alertmanager alertmanager.Alertmanager
 	quickfilter  quickfilter.Module
-	dashboard    dashboard.Module
 }
 
-func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module, dashboard dashboard.Module) organization.Setter {
-	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter, dashboard: dashboard}
+func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module) organization.Setter {
+	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter}
 }
 
 func (module *setter) Create(ctx context.Context, organization *types.Organization, createManagedRoles func(context.Context, valuer.UUID) error) error {
@@ -39,10 +37,6 @@ func (module *setter) Create(ctx context.Context, organization *types.Organizati
 		return err
 	}
 
-	if err := module.dashboard.ReconcileSystemDashboards(ctx, organization.ID); err != nil {
-		return err
-	}
-
 	return nil
 }
 

pkg/querybuilder/exists_expr.go

@@ -43,7 +43,7 @@ func ExistsExpression(columns []*schema.Column, key *telemetrytypes.TelemetryFie
 		if len(evolutionsEntries) > 0 && evolutionsEntries[0] != nil {
 			columnName = evolutionsEntries[0].ColumnName
 		}
-		rawPath := fmt.Sprintf("%s.`%s`", columnName, key.Name)
+		rawPath := fmt.Sprintf("%s.%s", columnName, ClickHouseIdentifier(key.Name))
 		if exists {
 			return rawPath + " IS NOT NULL", nil
 		}

pkg/signoz/handler_test.go

@@ -49,9 +49,7 @@ func TestNewHandlers(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
-	require.NoError(t, err)
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/module.go

@@ -67,35 +67,35 @@ import (
 )
 
 type Modules struct {
-	OrgGetter            organization.Getter
-	OrgSetter            organization.Setter
-	Preference           preference.Module
-	UserSetter           user.Setter
-	UserGetter           user.Getter
-	RetentionGetter      retention.Getter
-	SavedView            savedview.Module
-	Apdex                apdex.Module
-	Dashboard            dashboard.Module
-	QuickFilter          quickfilter.Module
-	TraceFunnel          tracefunnel.Module
-	RawDataExport        rawdataexport.Module
-	AuthDomain           authdomain.Module
-	Session              session.Module
-	Services             services.Module
-	SpanPercentile       spanpercentile.Module
-	MetricsExplorer      metricsexplorer.Module
-	MetricReductionRule  metricreductionrule.Module
-	InfraMonitoring      inframonitoring.Module
+	OrgGetter           organization.Getter
+	OrgSetter           organization.Setter
+	Preference          preference.Module
+	UserSetter          user.Setter
+	UserGetter          user.Getter
+	RetentionGetter     retention.Getter
+	SavedView           savedview.Module
+	Apdex               apdex.Module
+	Dashboard           dashboard.Module
+	QuickFilter         quickfilter.Module
+	TraceFunnel         tracefunnel.Module
+	RawDataExport       rawdataexport.Module
+	AuthDomain          authdomain.Module
+	Session             session.Module
+	Services            services.Module
+	SpanPercentile      spanpercentile.Module
+	MetricsExplorer     metricsexplorer.Module
+	MetricReductionRule metricreductionrule.Module
+	InfraMonitoring     inframonitoring.Module
 	Promote              promote.Module
 	ServiceAccount       serviceaccount.Module
 	ServiceAccountGetter serviceaccount.Getter
 	CloudIntegration     cloudintegration.Module
-	LogsPipeline         logspipeline.Module
-	RuleStateHistory     rulestatehistory.Module
-	TraceDetail          tracedetail.Module
-	SpanMapper           spanmapper.Module
-	LLMPricingRule       llmpricingrule.Module
-	Tag                  tag.Module
+	LogsPipeline        logspipeline.Module
+	RuleStateHistory    rulestatehistory.Module
+	TraceDetail         tracedetail.Module
+	SpanMapper          spanmapper.Module
+	LLMPricingRule      llmpricingrule.Module
+	Tag                 tag.Module
 }
 
 func NewModules(
@@ -126,7 +126,7 @@ func NewModules(
 	metricReductionRule metricreductionrule.Module,
 ) Modules {
 	quickfilter := implquickfilter.NewModule(implquickfilter.NewStore(sqlstore))
-	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter, dashboard)
+	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter)
 	// Cleanup callbacks from other modules, invoked when a user is deleted.
 	onDeleteUser := []user.OnDeleteUser{
 		dashboard.DeletePreferencesForUser,
@@ -136,34 +136,34 @@ func NewModules(
 	authDomainModule := implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs, authz)
 
 	return Modules{
-		OrgGetter:            orgGetter,
-		OrgSetter:            orgSetter,
-		Preference:           implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
-		SavedView:            implsavedview.NewModule(implsavedview.NewStore(sqlstore)),
-		Apdex:                implapdex.NewModule(sqlstore),
-		Dashboard:            dashboard,
-		UserSetter:           userSetter,
-		UserGetter:           userGetter,
-		RetentionGetter:      retentionGetter,
-		QuickFilter:          quickfilter,
-		TraceFunnel:          impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
-		RawDataExport:        implrawdataexport.NewModule(querier),
-		AuthDomain:           authDomainModule,
-		Session:              implsession.NewModule(providerSettings, authNs, userSetter, userGetter, authDomainModule, tokenizer, orgGetter, authz, config.Global),
-		SpanPercentile:       implspanpercentile.NewModule(querier, providerSettings),
-		Services:             implservices.NewModule(querier, telemetryStore),
-		MetricsExplorer:      implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, fl, providerSettings, config.MetricsExplorer),
-		MetricReductionRule:  metricReductionRule,
-		InfraMonitoring:      implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, fl, providerSettings, config.InfraMonitoring),
-		Promote:              implpromote.NewModule(telemetryMetadataStore, telemetryStore),
+		OrgGetter:           orgGetter,
+		OrgSetter:           orgSetter,
+		Preference:          implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
+		SavedView:           implsavedview.NewModule(implsavedview.NewStore(sqlstore)),
+		Apdex:               implapdex.NewModule(sqlstore),
+		Dashboard:           dashboard,
+		UserSetter:          userSetter,
+		UserGetter:          userGetter,
+		RetentionGetter:     retentionGetter,
+		QuickFilter:         quickfilter,
+		TraceFunnel:         impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
+		RawDataExport:       implrawdataexport.NewModule(querier),
+		AuthDomain:          authDomainModule,
+		Session:             implsession.NewModule(providerSettings, authNs, userSetter, userGetter, authDomainModule, tokenizer, orgGetter, authz, config.Global),
+		SpanPercentile:      implspanpercentile.NewModule(querier, providerSettings),
+		Services:            implservices.NewModule(querier, telemetryStore),
+		MetricsExplorer:     implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, fl, providerSettings, config.MetricsExplorer),
+		MetricReductionRule: metricReductionRule,
+		InfraMonitoring:     implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, fl, providerSettings, config.InfraMonitoring),
+		Promote:             implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 		ServiceAccount:       serviceAccount,
 		ServiceAccountGetter: serviceAccountGetter,
-		LogsPipeline:         impllogspipeline.NewModule(sqlstore),
-		RuleStateHistory:     implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger), ruleStore),
-		CloudIntegration:     cloudIntegrationModule,
-		TraceDetail:          impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
-		SpanMapper:           implspanmapper.NewModule(implspanmapper.NewStore(sqlstore), fl),
-		LLMPricingRule:       impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore), fl, querier),
-		Tag:                  tagModule,
+		LogsPipeline:        impllogspipeline.NewModule(sqlstore),
+		RuleStateHistory:    implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger), ruleStore),
+		CloudIntegration:    cloudIntegrationModule,
+		TraceDetail:         impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
+		SpanMapper:          implspanmapper.NewModule(implspanmapper.NewStore(sqlstore), fl),
+		LLMPricingRule:      impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore), fl, querier),
+		Tag:                 tagModule,
 	}
 }

pkg/signoz/module_test.go

@@ -51,9 +51,7 @@ func TestNewModules(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
-	require.NoError(t, err)
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/provider.go

@@ -245,7 +245,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewMigrateLambdaDashboardsFactory(),
 		sqlmigration.NewAddAuthDomainTuplesFactory(sqlstore),
 		sqlmigration.NewAddDeploymentHostTuplesFactory(sqlstore),
-		sqlmigration.NewAddSystemDashboardFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/signoz/signoz.go

@@ -60,7 +60,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	pkgtokenizer "github.com/SigNoz/signoz/pkg/tokenizer"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
@@ -176,7 +175,7 @@ func New(
 	telemetrystoreProviderFactories factory.NamedMap[factory.ProviderFactory[telemetrystore.TelemetryStore, telemetrystore.Config]],
 	authNsCallback func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error),
 	authzCallback func(context.Context, sqlstore.SQLStore, authz.Config, licensing.Licensing, []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error),
-	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module, dashboardtypes.SystemDashboardRegistry) dashboard.Module,
+	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module) dashboard.Module,
 	gatewayProviderFactory func(licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config],
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
 	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
@@ -441,13 +440,8 @@ func New(
 	// Initialize query parser (needed for dashboard module)
 	queryParser := queryparser.New(providerSettings)
 
-	// Initialize dashboard module. The system dashboard registry is parsed here so
-	// a malformed embedded definition fails startup instead of a request.
-	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
-	if err != nil {
-		return nil, err
-	}
-	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule, systemDashboardRegistry)
+	// Initialize dashboard module
+	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
 
 	// Initialize user getter
 	userGetter := impluser.NewGetter(userStore, userRoleStore, flagger)
@@ -616,7 +610,6 @@ func New(
 		factory.NewNamedService(factory.MustNewName("auditor"), auditor),
 		factory.NewNamedService(factory.MustNewName("meterreporter"), meterReporter, factory.MustNewName("licensing")),
 		factory.NewNamedService(factory.MustNewName("ruler"), rulerInstance),
-		factory.NewNamedService(factory.MustNewName("systemdashboard"), impldashboard.NewService(providerSettings, dashboard, orgGetter)),
 	)
 	if err != nil {
 		return nil, err

pkg/sqlmigration/119_add_system_dashboard.go

@@ -1,93 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addSystemDashboard struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewAddSystemDashboardFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(
-		factory.MustNewName("add_system_dashboard"),
-		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-			return &addSystemDashboard{sqlstore: sqlstore, sqlschema: sqlschema}, nil
-		},
-	)
-}
-
-func (migration *addSystemDashboard) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addSystemDashboard) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "system_dashboard",
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "dashboard_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "version", DataType: sqlschema.DataTypeBigInt, Nullable: false},
-			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
-			ColumnNames: []sqlschema.ColumnName{"id"},
-		},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-			{
-				ReferencingColumnName: sqlschema.ColumnName("dashboard_id"),
-				ReferencedTableName:   sqlschema.TableName("dashboard"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-
-	// (org_id, name) is what makes provisioning safe across replicas: the state
-	// row is written in the same transaction as the dashboard, so a losing racer
-	// rolls back its dashboard too.
-	sqls = append(sqls, migration.sqlschema.Operator().CreateIndex(
-		&sqlschema.UniqueIndex{
-			TableName:   "system_dashboard",
-			ColumnNames: []sqlschema.ColumnName{"org_id", "name"},
-		},
-	)...)
-	sqls = append(sqls, migration.sqlschema.Operator().CreateIndex(
-		&sqlschema.UniqueIndex{
-			TableName:   "system_dashboard",
-			ColumnNames: []sqlschema.ColumnName{"dashboard_id"},
-		},
-	)...)
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addSystemDashboard) Down(context.Context, *bun.DB) error {
-	return nil
-}

pkg/telemetryschema/tracestelemetryschema/const.go

@@ -43,6 +43,7 @@ const (
 	SpanAttributesStringColumn = "attributes_string"
 	SpanAttributesNumberColumn = "attributes_number"
 	SpanAttributesBoolColumn   = "attributes_bool"
+	SpanAttributesColumn       = "attributes"
 	SpanResourcesStringColumn  = "resources_string"
 )
 

pkg/telemetryschema/tracestelemetryschema/field_mapper.go

@@ -52,8 +52,9 @@ var (
 			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
 			ValueType: schema.ColumnTypeString,
 		}},
-		"resource": {Name: "resource", Type: schema.JSONColumnType{}},
-		"scope":    {Name: "scope", Type: schema.JSONColumnType{}},
+		"resource":   {Name: "resource", Type: schema.JSONColumnType{}},
+		"scope":      {Name: "scope", Type: schema.JSONColumnType{}},
+		"attributes": {Name: "attributes", Type: schema.JSONColumnType{}},
 
 		"events": {Name: "events", Type: schema.ArrayColumnType{
 			ElementType: schema.ColumnTypeString,
@@ -184,16 +185,32 @@ func (m *fieldMapper) getColumn(
 	case telemetrytypes.FieldContextScope:
 		return []*schema.Column{indexV3Columns["scope"]}, nil
 	case telemetrytypes.FieldContextAttribute:
+		// Only typed keys resolve here: a data-type-unspecified attribute key
+		// falls through to ErrColumnNotFound so bare keys keep taking the legacy
+		// CandidateKeys/synthesis path rather than flipping to metadata-first.
+		var mapCol *schema.Column
 		switch key.FieldDataType {
 		case telemetrytypes.FieldDataTypeString:
-			return []*schema.Column{indexV3Columns["attributes_string"]}, nil
+			mapCol = indexV3Columns["attributes_string"]
 		case telemetrytypes.FieldDataTypeInt64,
 			telemetrytypes.FieldDataTypeFloat64,
 			telemetrytypes.FieldDataTypeNumber:
-			return []*schema.Column{indexV3Columns["attributes_number"]}, nil
+			mapCol = indexV3Columns["attributes_number"]
 		case telemetrytypes.FieldDataTypeBool:
-			return []*schema.Column{indexV3Columns["attributes_bool"]}, nil
+			mapCol = indexV3Columns["attributes_bool"]
+		default:
+			return nil, qbtypes.ErrColumnNotFound
 		}
+		// Dual-read from the JSON column only once the attributes evolution entry
+		// is registered for this key; without it, resolution is byte-for-byte the
+		// legacy Map path. The JSON column is returned first so it wins the multiIf
+		// when both homes hold the key; SelectEvolutionsForColumns narrows the pair
+		// by the query's time range. This makes the evolution entry the rollout
+		// control, exactly as it is for resource/scope.
+		if attributeJSONEvolutionRegistered(key) {
+			return []*schema.Column{indexV3Columns["attributes"], mapCol}, nil
+		}
+		return []*schema.Column{mapCol}, nil
 	case telemetrytypes.FieldContextSpan:
 		// Check if this is a span scope field
 		if strings.ToLower(key.Name) == SpanSearchScopeRoot || strings.ToLower(key.Name) == SpanSearchScopeEntryPoint {
@@ -279,6 +296,7 @@ func (m *fieldMapper) resolveColumnExprs(
 		return nil, nil, nil, err
 	}
 
+	key = narrowEvolutionsToColumns(key, columns)
 	newColumns, evolutionsEntries, err := qbtypes.SelectEvolutionsForColumns(columns, key.Evolutions, startNs, endNs)
 	if err != nil {
 		return nil, nil, nil, err
@@ -309,6 +327,17 @@ func (m *fieldMapper) resolveColumnExprs(
 					exprs = append(exprs, fmt.Sprintf("%s.attributes.%s::String", columnName, querybuilder.ClickHouseIdentifier(attributeName)))
 					existExprs = append(existExprs, fmt.Sprintf("%s.attributes.%s IS NOT NULL", columnName, querybuilder.ClickHouseIdentifier(attributeName)))
 				}
+			case telemetrytypes.FieldContextAttribute:
+				// Span attributes are flat shared-data paths keyed by the attribute name
+				// verbatim (no nested object), so the name addresses the path directly.
+				// String casts to ::String so an absent path folds to '' — matching the
+				// Map column's default and preserving negative-operator parity; typed
+				// numeric/bool cast to Nullable so a missing or wrong-typed path reads
+				// NULL rather than 0/false. Existence tests the raw path (the cast folds
+				// NULL) and is index-eligible via attributes_paths_tokenbf.
+				path := fmt.Sprintf("%s.%s", columnName, querybuilder.ClickHouseIdentifier(key.Name))
+				exprs = append(exprs, fmt.Sprintf("%s::%s", path, attributeJSONCast(key.FieldDataType)))
+				existExprs = append(existExprs, fmt.Sprintf("%s IS NOT NULL", path))
 			default:
 				return nil, nil, nil, errors.NewInternalf(errors.CodeInternal, "only resource and scope context fields are supported for json columns, got %s", key.FieldContext.String)
 			}
@@ -353,6 +382,66 @@ func (m *fieldMapper) resolveColumnExprs(
 	return exprs, existExprs, columns, nil
 }
 
+// attributeJSONEvolutionRegistered reports whether the key carries an evolution entry for the
+// `attributes` JSON column. Until that entry is registered, attribute resolution stays on the
+// legacy Map column and the JSON column is never touched.
+func attributeJSONEvolutionRegistered(key *telemetrytypes.TelemetryFieldKey) bool {
+	for _, e := range key.Evolutions {
+		if e != nil && e.ColumnName == SpanAttributesColumn {
+			return true
+		}
+	}
+	return false
+}
+
+// narrowEvolutionsToColumns returns key.Evolutions filtered to entries whose column is in cols.
+// A metadata attribute key carries the `__all__` evolutions for every attribute-context column
+// (all three legacy maps plus the JSON column), but getColumn resolves a typed key to only its
+// own map + the JSON column; without this filter SelectEvolutionsForColumns would reject the
+// in-range sibling-map entries as columns not present in the slice. A no-op for every other
+// context, where getColumn already returns exactly the columns the evolutions name.
+func narrowEvolutionsToColumns(key *telemetrytypes.TelemetryFieldKey, cols []*schema.Column) *telemetrytypes.TelemetryFieldKey {
+	if len(key.Evolutions) == 0 {
+		return key
+	}
+	allowed := make(map[string]struct{}, len(cols))
+	for _, c := range cols {
+		allowed[c.Name] = struct{}{}
+	}
+	filtered := make([]*telemetrytypes.EvolutionEntry, 0, len(key.Evolutions))
+	for _, e := range key.Evolutions {
+		if e == nil {
+			continue
+		}
+		if _, ok := allowed[e.ColumnName]; ok {
+			filtered = append(filtered, e)
+		}
+	}
+	if len(filtered) == len(key.Evolutions) {
+		return key
+	}
+	narrowed := *key
+	narrowed.Evolutions = filtered
+	return &narrowed
+}
+
+// attributeJSONCast returns the ClickHouse cast target for a span attribute read from the
+// JSON column. String (and data-type-unspecified) casts to non-nullable String so an absent
+// path folds to ” the way the Map column's default does, keeping negative-operator parity;
+// numeric and bool cast to Nullable so an absent or wrong-typed path reads NULL instead of a
+// spurious 0/false. GROUP BY accepts these Nullable scalar casts (unlike a raw Dynamic).
+func attributeJSONCast(dataType telemetrytypes.FieldDataType) string {
+	switch dataType {
+	case telemetrytypes.FieldDataTypeInt64,
+		telemetrytypes.FieldDataTypeFloat64,
+		telemetrytypes.FieldDataTypeNumber,
+		telemetrytypes.FieldDataTypeBool:
+		return fmt.Sprintf("Nullable(%s)", telemetrytypes.MappingFieldDataTypeToJSONDataType[dataType].StringValue())
+	default:
+		return "String"
+	}
+}
+
 // upgradeToFamilies swaps single-member candidates for their family when the
 // metadata map proves membership. Candidate order and every non-family
 // candidate stay exactly as the legacy flow produced them; sibling candidates
@@ -516,6 +605,7 @@ func (m *fieldMapper) columnIsTemporal(ctx context.Context, startNs, endNs uint6
 	if err != nil {
 		return false, err
 	}
+	key = narrowEvolutionsToColumns(key, columns)
 	newColumns, _, err := qbtypes.SelectEvolutionsForColumns(columns, key.Evolutions, startNs, endNs)
 	if err != nil {
 		return false, err
@@ -638,6 +728,7 @@ func (m *fieldMapper) ExistsFor(
 	if err != nil {
 		return "", err
 	}
+	key = narrowEvolutionsToColumns(key, columns)
 	fieldExpression, err := m.FieldFor(ctx, orgID, tsStart, tsEnd, key)
 	if err != nil {
 		return "", err

pkg/telemetryschema/tracestelemetryschema/field_mapper_attributes_json_test.go

@@ -0,0 +1,254 @@
+package tracestelemetryschema
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	attrJSONRelease = time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
+
+	attrWindowBefore   = [2]uint64{tsNano(2024, 1), tsNano(2024, 6)}
+	attrWindowAfter    = [2]uint64{tsNano(2025, 6), tsNano(2025, 7)}
+	attrWindowStraddle = [2]uint64{tsNano(2024, 6), tsNano(2025, 6)}
+)
+
+func tsNano(y int, m time.Month) uint64 {
+	return uint64(time.Date(y, m, 1, 0, 0, 0, 0, time.UTC).UnixNano())
+}
+
+func attrKey(name string, dt telemetrytypes.FieldDataType, evo []*telemetrytypes.EvolutionEntry) telemetrytypes.TelemetryFieldKey {
+	return telemetrytypes.TelemetryFieldKey{
+		Name:          name,
+		FieldContext:  telemetrytypes.FieldContextAttribute,
+		FieldDataType: dt,
+		Evolutions:    evo,
+	}
+}
+
+// TestFieldForAttributeJSONEvolution asserts the value expression across the rollout window:
+// before release the legacy Map lookup (byte-for-byte today), after release the type-aware JSON
+// cast, straddling a dual-read multiIf with the JSON column first.
+func TestFieldForAttributeJSONEvolution(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	testCases := []struct {
+		name     string
+		dataType telemetrytypes.FieldDataType
+		window   [2]uint64
+		expected string
+	}{
+		{"string before -> map", telemetrytypes.FieldDataTypeString, attrWindowBefore, "attributes_string['user.id']"},
+		{"string after -> json", telemetrytypes.FieldDataTypeString, attrWindowAfter, "attributes.`user.id`::String"},
+		{"string straddle -> dual", telemetrytypes.FieldDataTypeString, attrWindowStraddle, "multiIf(attributes.`user.id` IS NOT NULL, attributes.`user.id`::String, mapContains(attributes_string, 'user.id'), attributes_string['user.id'], NULL)"},
+		{"number before -> map", telemetrytypes.FieldDataTypeNumber, attrWindowBefore, "attributes_number['user.id']"},
+		{"number after -> json", telemetrytypes.FieldDataTypeNumber, attrWindowAfter, "attributes.`user.id`::Nullable(Float64)"},
+		{"number straddle -> dual", telemetrytypes.FieldDataTypeNumber, attrWindowStraddle, "multiIf(attributes.`user.id` IS NOT NULL, attributes.`user.id`::Nullable(Float64), mapContains(attributes_number, 'user.id'), attributes_number['user.id'], NULL)"},
+		{"int64 after -> json", telemetrytypes.FieldDataTypeInt64, attrWindowAfter, "attributes.`user.id`::Nullable(Int64)"},
+		{"bool before -> map", telemetrytypes.FieldDataTypeBool, attrWindowBefore, "attributes_bool['user.id']"},
+		{"bool after -> json", telemetrytypes.FieldDataTypeBool, attrWindowAfter, "attributes.`user.id`::Nullable(Bool)"},
+		{"bool straddle -> dual", telemetrytypes.FieldDataTypeBool, attrWindowStraddle, "multiIf(attributes.`user.id` IS NOT NULL, attributes.`user.id`::Nullable(Bool), mapContains(attributes_bool, 'user.id'), attributes_bool['user.id'], NULL)"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			key := attrKey("user.id", tc.dataType, evo)
+			got, err := fm.FieldFor(ctx, valuer.UUID{}, tc.window[0], tc.window[1], &key)
+			require.NoError(t, err)
+			assert.Equal(t, tc.expected, got)
+		})
+	}
+}
+
+// TestFieldForAttributeNoEvolutionParity proves the JSON column is untouched until the evolution
+// entry is registered: a key with no evolutions resolves to the Map column for every window.
+func TestFieldForAttributeNoEvolutionParity(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+
+	for _, dt := range []struct {
+		dataType telemetrytypes.FieldDataType
+		expected string
+	}{
+		{telemetrytypes.FieldDataTypeString, "attributes_string['user.id']"},
+		{telemetrytypes.FieldDataTypeNumber, "attributes_number['user.id']"},
+		{telemetrytypes.FieldDataTypeBool, "attributes_bool['user.id']"},
+	} {
+		key := attrKey("user.id", dt.dataType, nil)
+		got, err := fm.FieldFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &key)
+		require.NoError(t, err)
+		assert.Equal(t, dt.expected, got, "no evolution entry must keep the Map path")
+	}
+}
+
+// TestConditionForAttributeJSON asserts the emitted WHERE fragment per operator against the JSON
+// column (window fully after release). Positive operators carry the raw-path existence guard;
+// numeric comparisons keep numeric semantics; existence never tests the ::String cast.
+func TestConditionForAttributeJSON(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	cb := NewConditionBuilder(fm, flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	testCases := []struct {
+		name     string
+		key      telemetrytypes.TelemetryFieldKey
+		operator qbtypes.FilterOperator
+		value    any
+		expected string
+	}{
+		{
+			name:     "equal string",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorEqual, value: "admin",
+			expected: "(attributes.`user.id`::String = ? AND attributes.`user.id` IS NOT NULL)",
+		},
+		{
+			name:     "not equal string has no exists guard",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorNotEqual, value: "admin",
+			expected: "attributes.`user.id`::String <> ?",
+		},
+		{
+			name:     "greater than number",
+			key:      attrKey("http.status_code", telemetrytypes.FieldDataTypeInt64, evo),
+			operator: qbtypes.FilterOperatorGreaterThan, value: float64(200),
+			expected: "toFloat64(attributes.`http.status_code`::Nullable(Int64)) > ?",
+		},
+		{
+			name:     "ilike string",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorILike, value: "%adm%",
+			expected: "LOWER(attributes.`user.id`::String) LIKE LOWER(?)",
+		},
+		{
+			name:     "exists uses raw path",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorExists, value: nil,
+			expected: "attributes.`user.id` IS NOT NULL",
+		},
+		{
+			name:     "not exists uses raw path",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorNotExists, value: nil,
+			expected: "attributes.`user.id` IS NULL",
+		},
+		{
+			name:     "in string",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorIn, value: []any{"a", "b"},
+			expected: "((attributes.`user.id`::String = ? OR attributes.`user.id`::String = ?) AND attributes.`user.id` IS NOT NULL)",
+		},
+		{
+			name:     "not in string has no exists guard",
+			key:      attrKey("user.id", telemetrytypes.FieldDataTypeString, evo),
+			operator: qbtypes.FilterOperatorNotIn, value: []any{"a", "b"},
+			expected: "(attributes.`user.id`::String <> ? AND attributes.`user.id`::String <> ?)",
+		},
+		{
+			name:     "between number",
+			key:      attrKey("latency", telemetrytypes.FieldDataTypeNumber, evo),
+			operator: qbtypes.FilterOperatorBetween, value: []any{float64(1), float64(9)},
+			expected: "toFloat64(attributes.`latency`::Nullable(Float64)) BETWEEN ? AND ?",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			sb := sqlbuilder.NewSelectBuilder()
+			conds, _, err := cb.ConditionFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &tc.key,
+				map[string][]*telemetrytypes.TelemetryFieldKey{tc.key.Name: {&tc.key}}, qbtypes.ConditionBuilderOptions{}, tc.operator, tc.value, sb)
+			require.NoError(t, err)
+			sb.Where(conds...)
+			sql, _ := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+			assert.Contains(t, sql, tc.expected)
+		})
+	}
+}
+
+// TestConditionForAttributeJSONNotExistsDualRead covers NOT EXISTS across both homes during the
+// dual-read window: it must AND the JSON IS NULL with NOT mapContains so a row present in either
+// home is excluded (De Morgan), including rows that predate the JSON column.
+func TestConditionForAttributeJSONNotExistsDualRead(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	cb := NewConditionBuilder(fm, flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	key := attrKey("user.id", telemetrytypes.FieldDataTypeString, evo)
+	sb := sqlbuilder.NewSelectBuilder()
+	conds, _, err := cb.ConditionFor(ctx, valuer.UUID{}, attrWindowStraddle[0], attrWindowStraddle[1], &key,
+		map[string][]*telemetrytypes.TelemetryFieldKey{key.Name: {&key}}, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotExists, nil, sb)
+	require.NoError(t, err)
+	sb.Where(conds...)
+	sql, _ := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	// the value multiIf resolves the row's home; NOT EXISTS negates the whole thing to IS NULL
+	assert.Contains(t, sql, "IS NULL")
+	assert.Contains(t, sql, "attributes.`user.id` IS NOT NULL")
+	assert.Contains(t, sql, "mapContains(attributes_string, 'user.id')")
+}
+
+// TestColumnExpressionForAttributeJSON covers group-by (coerced to String) and aggregation
+// (coerced to Float64) over a JSON attribute after release: both are exists-guarded so an absent
+// path is NULL rather than a spurious ”/0, and the numeric branch keeps its toFloat64 coercion.
+func TestColumnExpressionForAttributeJSON(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	t.Run("group by string", func(t *testing.T) {
+		key := attrKey("user.id", telemetrytypes.FieldDataTypeString, evo)
+		got, err := fm.ColumnExpressionFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &key, telemetrytypes.FieldDataTypeString, nil)
+		require.NoError(t, err)
+		assert.Equal(t, "multiIf(attributes.`user.id` IS NOT NULL, attributes.`user.id`::String, NULL)", got)
+	})
+
+	t.Run("aggregation numeric", func(t *testing.T) {
+		key := attrKey("latency", telemetrytypes.FieldDataTypeNumber, evo)
+		got, err := fm.ColumnExpressionFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &key, telemetrytypes.FieldDataTypeFloat64, nil)
+		require.NoError(t, err)
+		assert.Equal(t, "multiIf(attributes.`latency` IS NOT NULL, toFloat64(attributes.`latency`::Nullable(Float64)), NULL)", got)
+	})
+}
+
+// TestAttributeJSONNoAmbiguityWarning guards against a visible regression: the JSON column is a
+// second physical home for the same logical field, not a second logical field, so a plain
+// attribute filter must not emit the "ambiguous key" warning.
+func TestAttributeJSONNoAmbiguityWarning(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	cb := NewConditionBuilder(fm, flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	key := attrKey("user.id", telemetrytypes.FieldDataTypeString, evo)
+	sb := sqlbuilder.NewSelectBuilder()
+	_, warnings, err := cb.ConditionFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &key,
+		map[string][]*telemetrytypes.TelemetryFieldKey{key.Name: {&key}}, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorEqual, "x", sb)
+	require.NoError(t, err)
+	assert.Empty(t, warnings, "a plain attribute filter must not emit an ambiguity warning")
+}
+
+// TestColumnForUnspecifiedAttributeNoBranchFlip pins the branch-flip decision: a
+// data-type-unspecified attribute key resolves to no column (even with the evolution present), so
+// bare attribute keys keep taking the legacy CandidateKeys/synthesis path rather than becoming
+// metadata-first resolvable.
+func TestColumnForUnspecifiedAttributeNoBranchFlip(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper(flaggertest.New(t))
+	evo := MockAttributeEvolutionData(attrJSONRelease)
+
+	key := attrKey("user.id", telemetrytypes.FieldDataTypeUnspecified, evo)
+	_, err := fm.ColumnFor(ctx, valuer.UUID{}, attrWindowAfter[0], attrWindowAfter[1], &key)
+	assert.ErrorIs(t, err, qbtypes.ErrColumnNotFound)
+}

pkg/telemetryschema/tracestelemetryschema/test_data.go

@@ -154,6 +154,29 @@ func BuildCompleteFieldKeyMap(releaseTime time.Time) map[string][]*telemetrytype
 	return keysMap
 }
 
+// MockAttributeEvolutionData returns the attribute-context evolution timeline: the three legacy
+// map columns at epoch 0 and the JSON `attributes` column released at releaseTime. Every entry
+// is field_name "__all__", so a typed attribute key carries all four; getColumn keeps only its
+// own map plus the JSON column and narrowEvolutionsToColumns drops the rest before selection.
+func MockAttributeEvolutionData(releaseTime time.Time) []*telemetrytypes.EvolutionEntry {
+	entry := func(col, typ string, rt time.Time) *telemetrytypes.EvolutionEntry {
+		return &telemetrytypes.EvolutionEntry{
+			Signal:       telemetrytypes.SignalTraces,
+			ColumnName:   col,
+			ColumnType:   typ,
+			FieldContext: telemetrytypes.FieldContextAttribute,
+			FieldName:    "__all__",
+			ReleaseTime:  rt,
+		}
+	}
+	return []*telemetrytypes.EvolutionEntry{
+		entry("attributes_string", "Map(LowCardinality(String), String)", time.Unix(0, 0)),
+		entry("attributes_number", "Map(LowCardinality(String), Float64)", time.Unix(0, 0)),
+		entry("attributes_bool", "Map(LowCardinality(String), Bool)", time.Unix(0, 0)),
+		entry("attributes", "JSON()", releaseTime),
+	}
+}
+
 // MockEvolutionData returns the canonical resource-column evolution timeline used in tests:
 // the legacy resources_string map at epoch 0 and the JSON resource column released at releaseTime.
 func MockEvolutionData(releaseTime time.Time) []*telemetrytypes.EvolutionEntry {

pkg/types/dashboardtypes/perses_dashboard.go

@@ -25,10 +25,6 @@ const (
 	dashboardNameSuffixLen = 8
 )
 
-// SystemDashboardNamePrefix is reserved for dashboards SigNoz ships and owns. Generated
-// names never contain consecutive hyphens, so only a typed name can carry it — create rejects that.
-const SystemDashboardNamePrefix = "signoz---"
-
 const (
 	dashboardIconPathPrefix = "/assets/Icons/"
 	dashboardLogoPathPrefix = "/assets/Logos/"
@@ -79,8 +75,8 @@ type DashboardV2 struct {
 }
 
 func (d *DashboardV2) ErrIfNotMutable() error {
-	if d.Source != SourceUser {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be modified", d.Source)
+	if d.Source == SourceIntegration {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be modified")
 	}
 	return nil
 }
@@ -99,11 +95,6 @@ func (d *DashboardV2) Update(updatable UpdatableDashboardV2, updatedBy string, r
 	if err := d.ErrIfNotUpdatable(); err != nil {
 		return err
 	}
-	return d.UpdateUnsafe(updatable, updatedBy, resolvedTags)
-}
-
-// UpdateUnsafe applies the update without the source/lock gate. Intended for internal system callers.
-func (d *DashboardV2) UpdateUnsafe(updatable UpdatableDashboardV2, updatedBy string, resolvedTags []*tagtypes.Tag) error {
 	if updatable.Name != d.Name {
 		return errors.NewInvalidInputf(ErrCodeDashboardImmutable, "name is immutable; cannot change from %q to %q", d.Name, updatable.Name)
 	}
@@ -138,13 +129,6 @@ func (d *DashboardV2) LockUnlock(lock bool, isAdmin bool, updatedBy string) erro
 	return nil
 }
 
-func (d *DashboardV2) ErrIfNotSystem() error {
-	if d.Source != SourceSystem {
-		return errors.Newf(errors.TypeNotFound, ErrCodeDashboardNotFound, "dashboard %q is not a system dashboard", d.Name)
-	}
-	return nil
-}
-
 func (d *DashboardV2) ErrIfNotClonable() error {
 	if !d.Source.isClonable() {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be cloned", d.Source)
@@ -221,21 +205,13 @@ type PostableDashboardV2 struct {
 	Spec         DashboardSpec          `json:"spec" required:"true"`
 }
 
-func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) (*DashboardV2, error) {
+func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) *DashboardV2 {
 	now := time.Now()
 
 	name := postable.Name
 	if postable.GenerateName {
 		name = generateDashboardName(postable.Spec.Display.Name)
 	}
-	// Checked on the final name, here rather than in validateName, because only
-	// the constructor knows the source.
-	if source != SourceSystem && strings.HasPrefix(name, SystemDashboardNamePrefix) {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: the %q prefix is reserved for system dashboards", name, SystemDashboardNamePrefix)
-	}
-	if source == SourceSystem && !strings.HasPrefix(name, SystemDashboardNamePrefix) {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: system dashboard names must start with the %q prefix", name, SystemDashboardNamePrefix)
-	}
 
 	return &DashboardV2{
 		Identifiable:            types.Identifiable{ID: valuer.GenerateUUID()},
@@ -248,7 +224,7 @@ func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy
 		Name:                    name,
 		Tags:                    tagtypes.NewTagsFromPostableTags(orgID, coretypes.KindDashboard, postable.Tags),
 		Spec:                    postable.Spec,
-	}, nil
+	}
 }
 
 func (p *PostableDashboardV2) UnmarshalJSON(data []byte) error {

pkg/types/dashboardtypes/perses_dashboard_convertors_test.go

@@ -89,25 +89,21 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 	cases := []struct {
 		scenario       string
 		source         Source
-		name           string
 		expectedLocked bool
 	}{
 		{
 			scenario:       "user source is not locked",
 			source:         SourceUser,
-			name:           "my-dashboard",
 			expectedLocked: false,
 		},
 		{
 			scenario:       "system source is not locked",
 			source:         SourceSystem,
-			name:           SystemDashboardNamePrefix + "my-dashboard",
 			expectedLocked: false,
 		},
 		{
 			scenario:       "integration source is locked",
 			source:         SourceIntegration,
-			name:           "my-dashboard",
 			expectedLocked: true,
 		},
 	}
@@ -119,7 +115,7 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 					SchemaVersion: SchemaVersion,
 					Image:         "img",
 				},
-				Name: tc.name,
+				Name: "my-dashboard",
 				Tags: []tagtypes.PostableTag{
 					{Key: "team", Value: "platform"},
 					{Key: "env", Value: "prod"},
@@ -128,8 +124,7 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			}
 
 			before := time.Now()
-			dashboard, err := postable.NewDashboardV2(orgID, "alice", tc.source)
-			require.NoError(t, err)
+			dashboard := postable.NewDashboardV2(orgID, "alice", tc.source)
 			after := time.Now()
 
 			require.NotNil(t, dashboard)
@@ -165,10 +160,8 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			Spec:                    DashboardSpec{},
 		}
 
-		first, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		require.NoError(t, err)
-		second, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		require.NoError(t, err)
+		first := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		second := postable.NewDashboardV2(orgID, "alice", SourceUser)
 		assert.NotEqual(t, first.ID, second.ID, "expected distinct UUIDs across invocations")
 	})
 
@@ -181,8 +174,7 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			},
 		}
 
-		dashboard, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		require.NoError(t, err)
+		dashboard := postable.NewDashboardV2(orgID, "alice", SourceUser)
 		assert.True(t, strings.HasPrefix(dashboard.Name, "my-dashboard-"), "expected slug prefix, got %q", dashboard.Name)
 		assert.Len(t, dashboard.Name, len("my-dashboard-")+dashboardNameSuffixLen)
 	})

pkg/types/dashboardtypes/perses_dashboard_patch_test.go

@@ -109,8 +109,7 @@ func TestPatchableDashboardV2_Apply(t *testing.T) {
 	var p PostableDashboardV2
 	require.NoError(t, json.Unmarshal([]byte(basePostableJSON), &p), "base postable JSON must validate")
 	testOrgID := valuer.GenerateUUID()
-	base, err := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
-	require.NoError(t, err)
+	base := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
 	base.Tags = []*tagtypes.Tag{
 		{Key: "team", Value: "alpha"},
 		{Key: "env", Value: "prod"},

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/perses/spec/go/dashboard"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -1929,37 +1928,3 @@ func TestEnsureSingleExpressionAggregation(t *testing.T) {
 		})
 	}
 }
-
-// Guards the constant: a prefixed name must stay a valid DNS-1123 label.
-func TestSystemDashboardNamePrefix(t *testing.T) {
-	require.NoError(t, validateDashboardName(SystemDashboardNamePrefix+"ai-o11y-overview"))
-}
-
-func TestNewDashboardV2RejectsReservedName(t *testing.T) {
-	testCases := []struct {
-		description string
-		name        string
-		source      Source
-		errContains string
-	}{
-		{description: "reserved name for a system dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceSystem},
-		{description: "reserved name for a user dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceUser, errContains: "reserved for system dashboards"},
-		{description: "reserved name for an integration dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceIntegration, errContains: "reserved for system dashboards"},
-		{description: "unprefixed name for a system dashboard", name: "overview", source: SourceSystem, errContains: "must start with"},
-		{description: "ordinary name for a user dashboard", name: "overview", source: SourceUser},
-		{description: "fewer hyphens than the prefix for a user dashboard", name: "signoz--overview", source: SourceUser},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.description, func(t *testing.T) {
-			postable := PostableDashboardV2{Name: testCase.name}
-			_, err := postable.NewDashboardV2(valuer.GenerateUUID(), "user@signoz.io", testCase.source)
-			if testCase.errContains != "" {
-				require.Error(t, err)
-				assert.Contains(t, err.Error(), testCase.errContains)
-				return
-			}
-			require.NoError(t, err)
-		})
-	}
-}

pkg/types/dashboardtypes/store.go

@@ -13,9 +13,6 @@ type Store interface {
 
 	Get(context.Context, valuer.UUID, valuer.UUID) (*StorableDashboard, error)
 
-	// GetByName resolves a dashboard by its per-org unique name.
-	GetByName(ctx context.Context, orgID valuer.UUID, name string) (*StorableDashboard, error)
-
 	GetPublic(context.Context, string) (*StorablePublicDashboard, error)
 
 	GetDashboardByOrgsAndPublicID(context.Context, []string, string) (*StorableDashboard, error)
@@ -75,13 +72,4 @@ type Store interface {
 	UpdateDashboardView(ctx context.Context, view *DashboardView) error
 
 	DeleteDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// ════════════════════════════════════════════════════════════════════════
-	// System dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-	CreateSystemDashboard(ctx context.Context, storable *StorableSystemDashboard) error
-
-	GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*StorableSystemDashboard, error)
-
-	UpdateSystemDashboardVersion(ctx context.Context, orgID valuer.UUID, name string, version int) error
 }

pkg/types/dashboardtypes/system_dashboard.go

@@ -1,45 +0,0 @@
-package dashboardtypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-var (
-	ErrCodeSystemDashboardNotFound           = errors.MustNewCode("system_dashboard_not_found")
-	ErrCodeSystemDashboardDefinitionInvalid  = errors.MustNewCode("system_dashboard_definition_invalid")
-	ErrCodeSystemDashboardAlreadyProvisioned = errors.MustNewCode("system_dashboard_already_provisioned")
-)
-
-// ProvisionerIdentity is stamped into created_by/updated_by by the reconciler.
-const ProvisionerIdentity = "signoz"
-
-// StorableSystemDashboard records the shipped version each org's copy of a system
-// dashboard was last provisioned at. That version is the only thing the dashboard
-// row cannot answer, since the binary only embeds the latest definition.
-type StorableSystemDashboard struct {
-	bun.BaseModel `bun:"table:system_dashboard"`
-
-	types.Identifiable
-	types.TimeAuditable
-	OrgID       valuer.UUID `bun:"org_id,type:text,notnull"`
-	DashboardID valuer.UUID `bun:"dashboard_id,type:text,notnull"`
-	Name        string      `bun:"name,type:text,notnull"`
-	Version     int         `bun:"version,notnull"`
-}
-
-func NewStorableSystemDashboard(orgID valuer.UUID, dashboardID valuer.UUID, name string, version int) *StorableSystemDashboard {
-	now := time.Now()
-	return &StorableSystemDashboard{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		OrgID:         orgID,
-		DashboardID:   dashboardID,
-		Name:          name,
-		Version:       version,
-	}
-}

pkg/types/dashboardtypes/system_dashboard_definition.go

@@ -1,95 +0,0 @@
-package dashboardtypes
-
-import (
-	"bytes"
-	"encoding/json"
-	"slices"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-// SystemDashboardDefinition is one shipped system dashboard. Version is bumped on
-// every content change and drives upgrade detection; the name is the stable key
-// and never changes.
-type SystemDashboardDefinition struct {
-	Version   int                 `json:"version"`
-	Dashboard PostableDashboardV2 `json:"definition"`
-}
-
-func (definition SystemDashboardDefinition) Name() string {
-	return definition.Dashboard.Name
-}
-
-func NewSystemDashboardDefinition(raw []byte) (SystemDashboardDefinition, error) {
-	decoder := json.NewDecoder(bytes.NewReader(raw))
-	decoder.DisallowUnknownFields()
-
-	var definition SystemDashboardDefinition
-	if err := decoder.Decode(&definition); err != nil {
-		return SystemDashboardDefinition{}, errors.WrapInvalidInputf(err, ErrCodeSystemDashboardDefinitionInvalid, "%s", err.Error())
-	}
-	if err := definition.validate(); err != nil {
-		return SystemDashboardDefinition{}, err
-	}
-
-	return definition, nil
-}
-
-func (definition SystemDashboardDefinition) validate() error {
-	if definition.Version < 1 {
-		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "version must be at least 1, got %d", definition.Version)
-	}
-	if !strings.HasPrefix(definition.Name(), SystemDashboardNamePrefix) {
-		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "name %q must start with %q", definition.Name(), SystemDashboardNamePrefix)
-	}
-	if definition.Dashboard.GenerateName {
-		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "%s: generateName is not allowed, the name is the stable key", definition.Name())
-	}
-
-	return nil
-}
-
-// ToUpdatable is how an upgrade re-applies a definition onto an existing row:
-// everything but the dashboard's identity comes from the shipped definition.
-func (definition SystemDashboardDefinition) ToUpdatable() UpdatableDashboardV2 {
-	return UpdatableDashboardV2{
-		DashboardV2MetadataBase: definition.Dashboard.DashboardV2MetadataBase,
-		Name:                    definition.Dashboard.Name,
-		Tags:                    definition.Dashboard.Tags,
-		Spec:                    definition.Dashboard.Spec,
-	}
-}
-
-// SystemDashboardRegistry holds every definition embedded in the binary, keyed by name.
-type SystemDashboardRegistry struct {
-	definitions map[string]SystemDashboardDefinition
-}
-
-func NewSystemDashboardRegistry(definitions []SystemDashboardDefinition) (SystemDashboardRegistry, error) {
-	byName := make(map[string]SystemDashboardDefinition, len(definitions))
-	for _, definition := range definitions {
-		if _, duplicate := byName[definition.Name()]; duplicate {
-			return SystemDashboardRegistry{}, errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "duplicate system dashboard name %q", definition.Name())
-		}
-		byName[definition.Name()] = definition
-	}
-
-	return SystemDashboardRegistry{definitions: byName}, nil
-}
-
-func (registry SystemDashboardRegistry) Get(name string) (SystemDashboardDefinition, bool) {
-	definition, ok := registry.definitions[name]
-	return definition, ok
-}
-
-// List returns the definitions sorted by name so provisioning order is stable.
-func (registry SystemDashboardRegistry) List() []SystemDashboardDefinition {
-	definitions := make([]SystemDashboardDefinition, 0, len(registry.definitions))
-	for _, definition := range registry.definitions {
-		definitions = append(definitions, definition)
-	}
-	slices.SortFunc(definitions, func(a, b SystemDashboardDefinition) int { return strings.Compare(a.Name(), b.Name()) })
-
-	return definitions
-}

tests/integration/tests/dashboard/07_system_dashboard.py

@@ -1,186 +0,0 @@
-from collections.abc import Callable
-from http import HTTPStatus
-
-import requests
-
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.dashboards import DASHBOARDS_BASE_URL, MAX_LIST_LIMIT
-from fixtures.types import Operation, SigNoz
-
-SYSTEM_BASE_URL = "/api/v2/dashboards/system"
-
-# Provisioned for every org by the reconciler; the path segment is the bare
-# definition name, the stored name carries the reserved prefix.
-SYSTEM_DASHBOARD_NAME = "ai-o11y-overview"
-SYSTEM_DASHBOARD_PREFIX = "signoz---"
-
-
-def test_get_system_dashboard(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_NAME}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-
-    assert response.status_code == HTTPStatus.OK, response.text
-    dashboard = response.json()["data"]
-    assert dashboard["name"] == SYSTEM_DASHBOARD_PREFIX + SYSTEM_DASHBOARD_NAME
-    assert dashboard["source"] == "system"
-    assert dashboard["createdBy"] == "signoz"
-    assert dashboard["schemaVersion"] == "v6"
-
-
-def test_get_system_dashboard_rejects_prefixed_name(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_PREFIX}{SYSTEM_DASHBOARD_NAME}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert "must not carry" in response.json()["error"]["message"]
-
-
-def test_get_missing_system_dashboard_returns_not_found(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/no-such-dashboard"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-
-    assert response.status_code == HTTPStatus.NOT_FOUND, response.text
-
-
-def test_system_dashboard_hidden_from_list_but_gettable_by_id(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_NAME}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    dashboard_id = response.json()["data"]["id"]
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}?limit={MAX_LIST_LIMIT}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    listed = response.json()["data"]["dashboards"] or []
-    assert all(dashboard["source"] != "system" for dashboard in listed)
-    assert all(dashboard["id"] != dashboard_id for dashboard in listed)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["source"] == "system"
-
-
-def test_system_dashboard_is_immutable(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_NAME}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    dashboard = response.json()["data"]
-    dashboard_id = dashboard["id"]
-
-    response = requests.put(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
-        json={
-            "schemaVersion": dashboard["schemaVersion"],
-            "name": dashboard["name"],
-            "tags": [],
-            "spec": dashboard["spec"],
-        },
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert response.json()["error"]["code"] == "dashboard_immutable"
-
-    response = requests.delete(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert response.json()["error"]["code"] == "dashboard_immutable"
-
-    response = requests.put(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}/lock"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert response.json()["error"]["code"] == "dashboard_immutable"
-
-    response = requests.post(
-        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}/clone"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert response.json()["error"]["code"] == "dashboard_immutable"
-
-
-def test_create_rejects_reserved_prefix_name(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.post(
-        signoz.self.host_configs["8080"].get(DASHBOARDS_BASE_URL),
-        json={
-            "schemaVersion": "v6",
-            "name": f"{SYSTEM_DASHBOARD_PREFIX}custom",
-            "tags": [],
-            "spec": {
-                "display": {"name": "Custom"},
-                "variables": [],
-                "panels": {},
-                "layouts": [],
-            },
-        },
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert "reserved for system dashboards" in response.json()["error"]["message"]