fix: remove omitempty from alertonabsent

<!--A few plain bullets saying what changed and why, for a reviewer
skimming it - not a wall of text, not a restatement of the diff, not
generated boilerplate.-->
#### Description

- AI explorer list view gets the column picker (`useOptionsMenu`, keys
from `/api/v1/fields/keys`), like the trace view. Picked columns are
sent with the list query, so adding or removing one refetches;
reordering does not.
- The list panel keeps its own columns in the AI preference slice, so
saved views and `options.selectColumns` in the URL cover it too.
- The list panel defaults to the current static columns. The column
store keeps only widths.

<!--Reference issues using `Closes #issue-number` to enable automatic
closure on merge. -->
#### Issues closed by this PR

https://github.com/SigNoz/nerve-pod/issues/551

<!--If applicable, include screenshots or screen recordings that clearly
show the behavior before the change and the result after the change. -->
#### Screenshots / Screen Recordings



https://github.com/user-attachments/assets/f2d455f5-ba97-4325-8832-79ac6b637cf7



<!--Anything reviewers should keep in mind while reviewing -->
#### Additional Information

- Stacked on #13297.
- Review commit by commit: preferences → list view. Each commit builds.
- Column order picked on the list view before this PR was kept in the
table's column store; it is ignored now, so those users see the default
order once. Column widths are kept.

---------

Co-authored-by: Gaurav Tewari <tewarig@users.noreply.github.com>

docs/api/openapi.yml

@@ -11573,20 +11573,10 @@ components:
           description: Whether the rule is paused. A disabled rule is neither evaluated
             nor notifies. Defaults to false.
           type: boolean
-        evalWindow:
-          description: The lookback window as a Go duration such as 5m. Only read
-            when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec
-            instead.
-          type: string
         evaluation:
           allOf:
           - $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
           description: The evaluation window, as a kind and spec.
-        frequency:
-          description: How often the rule is evaluated, as a Go duration such as 1m.
-            Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set
-            it in evaluation.spec instead.
-          type: string
         labels:
           additionalProperties:
             type: string
@@ -11598,13 +11588,6 @@ components:
           allOf:
           - $ref: '#/components/schemas/RuletypesNotificationSettings'
           description: Grouping, re-notification and routing behaviour.
-        preferredChannels:
-          description: The displayName of each notification channel to notify, for
-            schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries
-            its own channels.
-          items:
-            type: string
-          type: array
         ruleType:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleType'
@@ -11714,20 +11697,10 @@ components:
           description: Whether the rule is paused. A disabled rule is neither evaluated
             nor notifies. Defaults to false.
           type: boolean
-        evalWindow:
-          description: The lookback window as a Go duration such as 5m. Only read
-            when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec
-            instead.
-          type: string
         evaluation:
           allOf:
           - $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
           description: The evaluation window, as a kind and spec.
-        frequency:
-          description: How often the rule is evaluated, as a Go duration such as 1m.
-            Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set
-            it in evaluation.spec instead.
-          type: string
         id:
           description: The unique identifier of the rule.
           type: string
@@ -11742,13 +11715,6 @@ components:
           allOf:
           - $ref: '#/components/schemas/RuletypesNotificationSettings'
           description: Grouping, re-notification and routing behaviour.
-        preferredChannels:
-          description: The displayName of each notification channel to notify, for
-            schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries
-            its own channels.
-          items:
-            type: string
-          type: array
         ruleType:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleType'
@@ -11802,28 +11768,10 @@ components:
           description: Whether to fire a nodata alert when the query returns no data.
             Defaults to false.
           type: boolean
-        algorithm:
-          description: 'anomaly_rule only: the anomaly detection algorithm. The supported
-            value is standard.'
-          type: string
         compositeQuery:
           allOf:
           - $ref: '#/components/schemas/RuletypesAlertCompositeQuery'
           description: The queries whose result is compared against the thresholds.
-        matchType:
-          allOf:
-          - $ref: '#/components/schemas/RuletypesMatchType'
-          description: 'schemaVersion v1 only: which points in the window must satisfy
-            op. Accepted as at_least_once, all_the_times, on_average, in_total or
-            last, their aliases avg and sum, or the legacy codes as strings, ''1''
-            to ''5''. Required for v1; v2alpha1 sets matchType on each threshold.'
-        op:
-          allOf:
-          - $ref: '#/components/schemas/RuletypesCompareOperator'
-          description: 'schemaVersion v1 only: how the value is compared with target.
-            Accepted as above, below, equal, not_equal, above_or_equal, below_or_equal
-            or outside_bounds, their symbols, or the legacy codes as strings, ''1''
-            to ''7''. Required for v1; v2alpha1 sets op on each threshold.'
         requireMinPoints:
           description: Whether a series is skipped until it has at least requiredNumPoints
             points in the window. Defaults to false.
@@ -11841,17 +11789,6 @@ components:
           description: The name of the query whose result is evaluated, such as A
             or F1. Must match a query in compositeQuery.
           type: string
-        target:
-          description: 'schemaVersion v1 only: the value compared against, in targetUnit.
-            Required for v1; v2alpha1 sets target on each threshold.'
-          format: double
-          nullable: true
-          type: number
-        targetUnit:
-          description: 'schemaVersion v1 only: the unit of target, such as percent
-            or ms. Converted to compositeQuery.unit before comparison when the two
-            differ.'
-          type: string
         thresholds:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleThresholdData'
@@ -25339,56 +25276,6 @@ paths:
       - rules
       x-signoz-stability: alpha
   /api/v2/rules:
-    get:
-      deprecated: true
-      description: 'This endpoint lists all alert rules with their current evaluation
-        state. Deprecated: use ListRulesV3, which supports filtering, sorting and
-        pagination.'
-      operationId: ListRules
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/RuletypesRule'
-                    type: array
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List alert rules
-      tags:
-      - rules
-      x-signoz-stability: alpha
     post:
       deprecated: false
       description: This endpoint creates a new alert rule

ee/query-service/rules/anomaly.go

@@ -34,8 +34,7 @@ type AnomalyRule struct {
 
 	provider anomaly.Provider
 
-	version string
-	logger  *slog.Logger
+	logger *slog.Logger
 
 	seasonality anomaly.Seasonality
 }
@@ -63,7 +62,6 @@ func NewAnomalyRule(
 	r := AnomalyRule{
 		BaseRule: baseRule,
 		querier:  querier,
-		version:  p.Version,
 		logger:   logger.With(slog.String("rule.id", id)),
 	}
 
@@ -105,15 +103,15 @@ func (r *AnomalyRule) Type() ruletypes.RuleType {
 }
 
 func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) *qbtypes.QueryRangeRequest {
-	r.logger.InfoContext(
-		ctx, "prepare query range request", slog.Int64("ts", ts.UnixMilli()),
-		slog.Int64("eval.window_ms", r.EvalWindow().Milliseconds()),
-		slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()),
-	)
-
 	startTs, endTs := r.Timestamps(ts)
 	start, end := startTs.UnixMilli(), endTs.UnixMilli()
 
+	r.logger.InfoContext(
+		ctx, "prepare query range request", slog.Int64("ts", ts.UnixMilli()),
+		slog.Int64("eval.window_ms", end-start),
+		slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()),
+	)
+
 	req := &qbtypes.QueryRangeRequest{
 		Start:       uint64(start),
 		End:         uint64(end),
@@ -420,12 +418,10 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 func (r *AnomalyRule) String() string {
 
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.Name()),
-		RuleCondition:     r.Condition(),
-		EvalWindow:        r.EvalWindow(),
-		Labels:            r.Labels().Map(),
-		Annotations:       r.Annotations().Map(),
-		PreferredChannels: r.PreferredChannels(),
+		AlertName:     valuer.NewDisplayName(r.Name()),
+		RuleCondition: r.Condition(),
+		Labels:        r.Labels().Map(),
+		Annotations:   r.Annotations().Map(),
 	}
 
 	byt, err := json.Marshal(ar)

ee/query-service/rules/anomaly_test.go

@@ -54,9 +54,6 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &target,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
 				Queries: []qbtypes.QueryEnvelope{{
@@ -157,10 +154,7 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			AlertOnAbsent:   true,
-			Target:          &target,
+			AlertOnAbsent: true,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
 				Queries: []qbtypes.QueryEnvelope{{

frontend/src/container/LLMObservability/Explorer/Explorer.tsx

@@ -11,6 +11,10 @@ import { QuickFiltersSource } from 'components/QuickFilters/types';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { initialQueryAIWithType } from 'constants/queryBuilder';
 import { usePageActions } from 'container/AIAssistant/pageActions/usePageActions';
+import {
+	defaultOptionsQuery,
+	URL_OPTIONS,
+} from 'container/OptionsMenu/constants';
 import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
 import Toolbar from 'container/Toolbar/Toolbar';
 import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
@@ -115,11 +119,16 @@ function Explorer(): JSX.Element {
 
 	const handleChangeSelectedView = useCallback(
 		(view: ExplorerViews, querySearchParameters?: ICurrentQueryData): void => {
-			handleSetConfig(explorerViewToPanelType[view], DataSource.TRACES);
+			const panelType = explorerViewToPanelType[view];
+			handleSetConfig(panelType, DataSource.TRACES);
 
+			// Drop the left panel's url columns; each panel loads its own.
 			handleExplorerTabChange(
-				explorerViewToPanelType[view],
+				panelType,
 				querySearchParameters,
+				undefined,
+				undefined,
+				{ [URL_OPTIONS]: defaultOptionsQuery },
 			);
 		},
 		[handleExplorerTabChange, handleSetConfig],

frontend/src/container/LLMObservability/Explorer/ListView/ListView.tsx

@@ -12,12 +12,15 @@ import { QueryKey } from 'react-query';
 import { useSelector } from 'react-redux';
 import logEvent from 'api/common/logEvent';
 import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
+import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { QueryParams } from 'constants/query';
 import { initialQueryAIWithType, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import useOptionsMenu from 'container/OptionsMenu/useOptionsMenu';
+import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import { CustomTimeType } from 'container/TopNav/DateTimeSelectionV2/types';
 import { getTraceLink, transformSpanRows } from './utils';
 import { getFieldColumn, TracesTableRow } from '../TracesTable/getFieldColumn';
@@ -37,11 +40,7 @@ import { getListOrderBy, setListOrderBy } from 'utils/explorerUtils';
 
 import TraceExplorerControls from '../Controls';
 import { getListViewQuery } from '../explorerUtils';
-import {
-	defaultSelectedColumns,
-	PER_PAGE_OPTIONS,
-	TIMESTAMP_FIELD,
-} from './configs';
+import { PER_PAGE_OPTIONS, TIMESTAMP_FIELD } from './configs';
 import './ListView.styles.scss';
 
 import styles from './ListView.module.scss';
@@ -77,6 +76,11 @@ function ListView({
 		loading: timeRangeUpdateLoading,
 	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);
 
+	const { options, config } = useOptionsMenu({
+		sourcePage: SavedviewtypesSourceDTO.ai_observability,
+	});
+	const selectColumns = options.selectColumns;
+
 	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
 		QueryParams.pagination,
 	);
@@ -88,6 +92,18 @@ function ListView({
 		[stagedQuery, orderBy],
 	);
 
+	// Sorted field keys: reorder keeps the cache, any field change refetches.
+	const selectColumnsSignature = useMemo(
+		() =>
+			selectColumns
+				.map(({ name, fieldContext, fieldDataType }) =>
+					buildCompositeKey(name, fieldContext, fieldDataType),
+				)
+				.sort()
+				.join(','),
+		[selectColumns],
+	);
+
 	const queryKey = useMemo(
 		() => [
 			REACT_QUERY_KEY.GET_QUERY_RANGE,
@@ -97,6 +113,7 @@ function ListView({
 			stagedQuery,
 			panelType,
 			paginationConfig,
+			selectColumnsSignature,
 		],
 		[
 			stagedQuery,
@@ -105,6 +122,7 @@ function ListView({
 			paginationConfig,
 			maxTime,
 			minTime,
+			selectColumnsSignature,
 		],
 	);
 
@@ -123,7 +141,7 @@ function ListView({
 			},
 			tableParams: {
 				pagination: paginationConfig,
-				selectColumns: defaultSelectedColumns,
+				selectColumns,
 			},
 		},
 		ENTITY_VERSION_V5,
@@ -156,13 +174,20 @@ function ListView({
 		[queryTableDataResult],
 	);
 
-	// TODO(ai-explorer): static columns until the preferences framework lands.
 	const columns = useMemo<TableColumnDef<TracesTableRow>[]>(
 		() =>
-			[TIMESTAMP_FIELD, ...defaultSelectedColumns].map((field) =>
-				getFieldColumn(field),
-			),
-		[],
+			[
+				TIMESTAMP_FIELD,
+				...selectColumns.filter((field) => field.name !== TIMESTAMP_FIELD.name),
+			].map((field) => getFieldColumn(field)),
+		[selectColumns],
+	);
+
+	const handleColumnOrderChange = useCallback(
+		(cols: TableColumnDef<TracesTableRow>[]): void => {
+			config?.addColumn?.onReorder(cols.map((column) => column.id));
+		},
+		[config],
 	);
 
 	const rows = useMemo(
@@ -204,6 +229,7 @@ function ListView({
 					isLoading={isFetching}
 					totalCount={rows.length}
 					perPageOptions={PER_PAGE_OPTIONS}
+					config={config}
 				/>
 			</div>
 
@@ -211,7 +237,8 @@ function ListView({
 				data={rows}
 				columns={columns}
 				columnStorageKey={LOCALSTORAGE.AI_OBSERVABILITY_LIST_COLUMNS}
-				respectColumnOrder
+				onColumnOrderChange={handleColumnOrderChange}
+				onColumnRemove={config?.addColumn?.onRemove}
 				panelType="LIST"
 				getRowHref={getTraceLink}
 				isLoading={isLoading}

frontend/src/container/LLMObservability/Explorer/ListView/__tests__/ListView.columns.test.tsx

@@ -0,0 +1,193 @@
+import type { ComponentProps, MutableRefObject } from 'react';
+import type { QueryKey } from 'react-query';
+import { ENVIRONMENT } from 'constants/env';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import type { TelemetryFieldKey } from 'api/v5/v5';
+import { LOCALSTORAGE } from 'constants/localStorage';
+import { QueryParams } from 'constants/query';
+import { initialQueryAIWithType, PANEL_TYPES } from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
+import store from 'store';
+import { UPDATE_TIME_INTERVAL } from 'types/actions/globalTime';
+import type {
+	BuilderQuery,
+	QueryRangeRequestV5,
+} from 'types/api/v5/queryRange';
+
+import type TraceExplorerControls from '../../Controls';
+import type { TracesTableProps } from '../../TracesTable/TracesTable';
+import { defaultSelectedColumns } from '../configs';
+import ListView from '../ListView';
+
+const mockAddedField: TelemetryFieldKey = {
+	name: 'gen_ai.request.model',
+	signal: 'traces',
+	fieldContext: 'attribute',
+	fieldDataType: 'string',
+};
+
+jest.mock('../../Controls', () => ({
+	__esModule: true,
+	default: ({
+		config,
+	}: ComponentProps<typeof TraceExplorerControls>): JSX.Element => {
+		const fieldsSelector = config?.fieldsSelector;
+		return (
+			<button
+				data-testid="add-column"
+				type="button"
+				onClick={(): void =>
+					fieldsSelector?.onFieldsChange([...fieldsSelector.value, mockAddedField])
+				}
+			>
+				add
+			</button>
+		);
+	},
+}));
+
+jest.mock('../../TracesTable/TracesTable', () => ({
+	__esModule: true,
+	default: ({
+		columns,
+		onColumnOrderChange,
+		onColumnRemove,
+	}: TracesTableProps): JSX.Element => (
+		<div>
+			<div data-testid="table-columns">
+				{columns.map((column) => String(column.header)).join(',')}
+			</div>
+			<button
+				data-testid="reverse-columns"
+				type="button"
+				onClick={(): void => onColumnOrderChange?.([...columns].reverse())}
+			>
+				reverse
+			</button>
+			<button
+				data-testid="remove-status-code"
+				type="button"
+				onClick={(): void => onColumnRemove?.('span:response_status_code')}
+			>
+				remove
+			</button>
+		</div>
+	),
+}));
+
+const QUERY_RANGE_URL = `${ENVIRONMENT.baseURL}/api/v5/query_range`;
+const LIST_VIEW_ROUTE = `${ROUTES.AI_OBSERVABILITY_EXPLORER}?${
+	QueryParams.panelTypes
+}=${encodeURIComponent(JSON.stringify(PANEL_TYPES.LIST))}`;
+
+const DEFAULT_NAMES = defaultSelectedColumns.map((field) => field.name);
+
+let requestedFields: string[][] = [];
+
+const shownColumns = (): string[] =>
+	(screen.getByTestId('table-columns').textContent ?? '').split(',');
+
+const renderListView = (
+	queryKeyRef?: MutableRefObject<QueryKey | undefined>,
+): ReturnType<typeof render> =>
+	render(
+		<ListView
+			isFilterApplied={false}
+			setWarning={jest.fn()}
+			setIsLoadingQueries={jest.fn()}
+			queryKeyRef={queryKeyRef}
+		/>,
+		{},
+		{
+			initialRoute: LIST_VIEW_ROUTE,
+			queryBuilderOverrides: {
+				panelType: PANEL_TYPES.LIST,
+				stagedQuery: initialQueryAIWithType,
+				currentQuery: initialQueryAIWithType,
+			} as never,
+		},
+	);
+
+describe('ListView columns', () => {
+	beforeAll(() => {
+		// The list waits until the global time range has loaded.
+		const { minTime, maxTime, selectedTime } = store.getState().globalTime;
+		store.dispatch({
+			type: UPDATE_TIME_INTERVAL,
+			payload: { minTime, maxTime, selectedTime },
+		});
+	});
+
+	beforeEach(() => {
+		localStorage.clear();
+		requestedFields = [];
+		server.use(
+			rest.post(QUERY_RANGE_URL, async (req, res, ctx) => {
+				const body = (await req.json()) as QueryRangeRequestV5;
+				const spec = body.compositeQuery.queries[0].spec as BuilderQuery;
+				requestedFields.push((spec.selectFields ?? []).map((field) => field.name));
+				return res(
+					ctx.status(200),
+					ctx.json({ data: { type: 'raw', data: { results: [] } } }),
+				);
+			}),
+		);
+	});
+
+	it('refetches with the columns added or removed', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderListView();
+		await waitFor(() => expect(requestedFields).toStrictEqual([DEFAULT_NAMES]));
+
+		await user.click(screen.getByTestId('add-column'));
+
+		await waitFor(() => expect(requestedFields).toHaveLength(2));
+		expect(requestedFields[1]).toStrictEqual([
+			...DEFAULT_NAMES,
+			mockAddedField.name,
+		]);
+
+		await user.click(screen.getByTestId('remove-status-code'));
+
+		await waitFor(() => expect(requestedFields).toHaveLength(3));
+		expect(requestedFields[2]).toStrictEqual([
+			...DEFAULT_NAMES.filter((name) => name !== 'response_status_code'),
+			mockAddedField.name,
+		]);
+	});
+
+	it('reorders the columns without refetching', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const queryKeyRef: MutableRefObject<QueryKey | undefined> = {
+			current: undefined,
+		};
+		renderListView(queryKeyRef);
+		await waitFor(() => expect(requestedFields).toHaveLength(1));
+		const initialQueryKey = queryKeyRef.current;
+
+		await user.click(screen.getByTestId('reverse-columns'));
+
+		expect(shownColumns()).toStrictEqual([
+			'timestamp',
+			...[...DEFAULT_NAMES].reverse(),
+		]);
+		expect(queryKeyRef.current).toStrictEqual(initialQueryKey);
+		expect(requestedFields).toHaveLength(1);
+	});
+
+	it('restores the stored list columns', async () => {
+		localStorage.setItem(
+			LOCALSTORAGE.AI_OBSERVABILITY_PANEL_COLUMNS,
+			JSON.stringify({ [PANEL_TYPES.LIST]: [mockAddedField] }),
+		);
+
+		renderListView();
+
+		expect(shownColumns()).toStrictEqual(['timestamp', mockAddedField.name]);
+		await waitFor(() =>
+			expect(requestedFields).toStrictEqual([[mockAddedField.name]]),
+		);
+	});
+});

frontend/src/container/LLMObservability/Explorer/TracesTable/TracesTable.tsx

@@ -1,7 +1,6 @@
-import { Dispatch, SetStateAction, useCallback } from 'react';
+import { useCallback } from 'react';
 import { useAppNavigate } from 'lib/router/useAppNavigate';
 import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import type { ColumnSizingState } from '@tanstack/react-table';
 import TanStackTable from 'components/TanStackTableView';
 import type {
 	CellTypographySize,
@@ -32,8 +31,6 @@ export type TracesTableProps = {
 	isFilterApplied: boolean;
 	onColumnOrderChange?: (cols: TableColumnDef<TracesTableRow>[]) => void;
 	onColumnRemove?: (columnId: string) => void;
-	columnSizing?: ColumnSizingState;
-	onColumnSizingChange?: Dispatch<SetStateAction<ColumnSizingState>>;
 	cellTypographySize?: CellTypographySize;
 };
 
@@ -51,8 +48,6 @@ function TracesTable({
 	isFilterApplied,
 	onColumnOrderChange,
 	onColumnRemove,
-	columnSizing,
-	onColumnSizingChange,
 	cellTypographySize = 'medium',
 }: TracesTableProps): JSX.Element {
 	const navigate = useAppNavigate();
@@ -103,8 +98,6 @@ function TracesTable({
 						cellTypographySize={cellTypographySize}
 						onColumnOrderChange={onColumnOrderChange}
 						onColumnRemove={onColumnRemove}
-						columnSizing={columnSizing}
-						onColumnSizingChange={onColumnSizingChange}
 						onRowClick={handleRowClick}
 						onRowClickNewTab={handleRowClickNewTab}
 						getRowTestId={(row): string => `traces-table-row-${row.id}`}
@@ -120,8 +113,6 @@ TracesTable.defaultProps = {
 	respectColumnOrder: false,
 	onColumnOrderChange: undefined,
 	onColumnRemove: undefined,
-	columnSizing: undefined,
-	onColumnSizingChange: undefined,
 	cellTypographySize: 'medium',
 };
 

frontend/src/container/LLMObservability/Explorer/TracesView/TracesView.tsx

@@ -12,12 +12,7 @@ import { QueryKey } from 'react-query';
 import { useSelector } from 'react-redux';
 import logEvent from 'api/common/logEvent';
 import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
-import type { ColumnSizingState } from '@tanstack/react-table';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
-import {
-	setColumnSizing,
-	useColumnSizing,
-} from 'components/TanStackTableView/useColumnStore';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -92,22 +87,6 @@ function TracesView({
 		[config],
 	);
 
-	// The column store keeps widths only; the picked columns live in the slice.
-	const columnSizing = useColumnSizing(
-		LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS,
-	);
-	const handleColumnSizingChange = useCallback<
-		Dispatch<SetStateAction<ColumnSizingState>>
-	>(
-		(updater) => {
-			setColumnSizing(
-				LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS,
-				typeof updater === 'function' ? updater(columnSizing) : updater,
-			);
-		},
-		[columnSizing],
-	);
-
 	const {
 		selectedTime: globalSelectedTime,
 		maxTime,
@@ -243,10 +222,9 @@ function TracesView({
 			<TracesTable
 				data={rows}
 				columns={tableColumns}
+				columnStorageKey={LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS}
 				onColumnOrderChange={handleColumnOrderChange}
 				onColumnRemove={config?.addColumn?.onRemove}
-				columnSizing={columnSizing}
-				onColumnSizingChange={handleColumnSizingChange}
 				panelType="TRACE"
 				getRowHref={getTraceLink}
 				isLoading={isLoading}

frontend/src/container/LLMObservability/Explorer/TracesView/__tests__/TracesView.columns.test.tsx

@@ -14,14 +14,15 @@ jest.mock('../../TracesTable/TracesTable', () => ({
 	__esModule: true,
 	default: ({
 		columns,
+		columnStorageKey,
 		onColumnOrderChange,
 		onColumnRemove,
-		onColumnSizingChange,
 	}: TracesTableProps): JSX.Element => (
 		<div>
 			<div data-testid="table-columns">
 				{columns.map((column) => String(column.header)).join(',')}
 			</div>
+			<div data-testid="column-storage-key">{columnStorageKey}</div>
 			<button
 				data-testid="reverse-columns"
 				type="button"
@@ -36,13 +37,6 @@ jest.mock('../../TracesTable/TracesTable', () => ({
 			>
 				remove
 			</button>
-			<button
-				data-testid="resize-trace-id"
-				type="button"
-				onClick={(): void => onColumnSizingChange?.({ trace_id: 240 })}
-			>
-				resize
-			</button>
 		</div>
 	),
 }));
@@ -168,15 +162,11 @@ describe('TracesView columns', () => {
 		expect(shownColumns()).toStrictEqual(['trace_id']);
 	});
 
-	it('keeps column widths in the column store', async () => {
-		const user = userEvent.setup();
+	it('keeps column widths under the trace view key', () => {
 		renderTracesView();
 
-		await user.click(screen.getByTestId('resize-trace-id'));
-
-		expect(
-			useColumnStore.getState().tables[SIZING_KEY].columnSizing,
-		).toStrictEqual({ trace_id: 240 });
-		expect(localStorage.getItem(PANEL_COLUMNS_KEY)).toBeNull();
+		expect(screen.getByTestId('column-storage-key')).toHaveTextContent(
+			SIZING_KEY,
+		);
 	});
 });

frontend/src/container/LLMObservability/Explorer/__tests__/Explorer.test.tsx

@@ -1,8 +1,16 @@
+import { LOCALSTORAGE } from 'constants/localStorage';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { renderWithExplorerProviders } from 'container/SavedViews/__tests__/savedViewsTestUtils';
-import { act, screen } from 'tests/test-utils';
+import {
+	defaultOptionsQuery,
+	URL_OPTIONS,
+} from 'container/OptionsMenu/constants';
+import {
+	renderWithExplorerProviders,
+	urlParam,
+} from 'container/SavedViews/__tests__/savedViewsTestUtils';
+import { act, screen, userEvent } from 'tests/test-utils';
 
 import Explorer from '../Explorer';
 
@@ -14,6 +22,10 @@ jest.mock('../TableView/TableView', () => ({
 	__esModule: true,
 	default: (): JSX.Element => <div data-testid="ai-table-view" />,
 }));
+jest.mock('../TracesView/TracesView', () => ({
+	__esModule: true,
+	default: (): JSX.Element => <div data-testid="ai-trace-view" />,
+}));
 
 const explorerUrlWithPanel = (panelType: PANEL_TYPES): string =>
 	`${ROUTES.AI_OBSERVABILITY_EXPLORER}?${QueryParams.panelTypes}=${encodeURIComponent(
@@ -21,6 +33,10 @@ const explorerUrlWithPanel = (panelType: PANEL_TYPES): string =>
 	)}`;
 
 describe('AI observability Explorer', () => {
+	afterEach(() => {
+		localStorage.clear();
+	});
+
 	it('shows the view of the panel type in the url', () => {
 		renderWithExplorerProviders(
 			<Explorer />,
@@ -43,4 +59,27 @@ describe('AI observability Explorer', () => {
 		expect(screen.getByTestId('ai-table-view')).toBeInTheDocument();
 		expect(screen.queryByTestId('ai-list-view')).not.toBeInTheDocument();
 	});
+
+	it('clears the url columns of the panel being left', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const traceColumns = [{ name: 'span_count' }];
+		localStorage.setItem(
+			LOCALSTORAGE.AI_OBSERVABILITY_PANEL_COLUMNS,
+			JSON.stringify({ [PANEL_TYPES.TRACE]: traceColumns }),
+		);
+		const { history } = renderWithExplorerProviders(
+			<Explorer />,
+			`${explorerUrlWithPanel(PANEL_TYPES.TRACE)}&${URL_OPTIONS}=${encodeURIComponent(
+				JSON.stringify({ ...defaultOptionsQuery, selectColumns: traceColumns }),
+			)}`,
+		);
+
+		await user.click(screen.getByTestId('search-view'));
+
+		expect(screen.getByTestId('ai-list-view')).toBeInTheDocument();
+		expect(JSON.parse(urlParam(history, URL_OPTIONS) ?? '')).toStrictEqual({
+			...defaultOptionsQuery,
+			selectColumns: [],
+		});
+	});
 });

frontend/src/container/TracesExplorer/ListView/__tests__/SpanDrawerNavigation.test.tsx

@@ -1,3 +1,9 @@
+import { logEventMock } from '__tests__/logEventMock';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import {
+	OpenTraceSource,
+	TracesExplorerEvents,
+} from 'container/TracesExplorer/events';
 import { getCurrentLocation } from 'lib/router/navigation';
 import { server } from 'mocks-server/server';
 import { screen, userEvent, waitFor, within } from 'tests/test-utils';
@@ -44,6 +50,12 @@ jest.mock('container/OptionsMenu/useOptionsMenu', () => ({
 	}),
 }));
 
+const ROW_TEST_ID = `traces-table-row-${listRows[0].data.span_id}`;
+
+// The row click handler sits on each cell, so a click on the <tr> does nothing.
+const getRowCell = (row: HTMLElement): HTMLElement =>
+	within(row).getAllByRole('cell')[0];
+
 describe('Traces ListView - span drawer navigation', () => {
 	beforeEach(() => {
 		mockSuccess();
@@ -134,6 +146,63 @@ describe('Traces ListView - span drawer navigation', () => {
 		);
 		expect(getCurrentLocation().pathname).toBe('/traces-explorer');
 		expect(screen.queryByTestId('span-details-drawer')).not.toBeInTheDocument();
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.LIST,
+				source: OpenTraceSource.RowIcon,
+			},
+		);
+	});
+
+	it('opens the trace page in a new tab from the drawer', async () => {
+		const open = jest.spyOn(window, 'open').mockImplementation(() => null);
+		const user = userEvent.setup();
+		renderListView();
+
+		await user.click(getRowCell(await screen.findByTestId(ROW_TEST_ID)));
+		expect(logEventMock).not.toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{ panelType: PANEL_TYPES.LIST, source: OpenTraceSource.Row },
+		);
+		await user.click(await screen.findByTestId('span-drawer-view-full-trace'));
+
+		expect(open).toHaveBeenCalledWith(
+			expect.stringMatching(/\/trace\/0000000000000000344ded1387b08a7e\?/),
+			'_blank',
+		);
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.LIST,
+				source: OpenTraceSource.SpanDrawer,
+			},
+		);
+	});
+
+	it('opens the trace page in a new tab on a Cmd-click without opening the drawer', async () => {
+		const open = jest.spyOn(window, 'open').mockImplementation(() => null);
+		const user = userEvent.setup();
+		renderListView();
+
+		const cell = getRowCell(await screen.findByTestId(ROW_TEST_ID));
+		await user.keyboard('{Meta>}');
+		await user.click(cell);
+		await user.keyboard('{/Meta}');
+
+		expect(open).toHaveBeenCalledWith(
+			expect.stringMatching(/\/trace\/0000000000000000344ded1387b08a7e\?/),
+			'_blank',
+			'noopener',
+		);
+		expect(screen.queryByTestId('span-details-drawer')).not.toBeInTheDocument();
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.LIST,
+				source: OpenTraceSource.Row,
+			},
+		);
 	});
 
 	it('shows the row icon only on the hovered copy of a duplicate span', async () => {

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

@@ -146,7 +146,9 @@ function ListView({
 				(field) => field.name !== TIMESTAMP_FIELD.name,
 			),
 		];
-		const fieldColumns = fields.map((field) => getFieldColumn(field));
+		const fieldColumns = fields.map((field) =>
+			getFieldColumn(field, PANEL_TYPES.LIST),
+		);
 		return [openTraceColumn, ...fieldColumns];
 	}, [options?.selectColumns, openTraceColumn]);
 

frontend/src/container/TracesExplorer/SpanDrawer/OpenTraceButton.tsx

@@ -2,7 +2,12 @@ import { MouseEvent } from 'react';
 import { CornerUpRight } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { Tooltip } from '@signozhq/ui/tooltip';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 import { useIsRowHovered } from 'components/TanStackTableView/TanStackTableStateContext';
+import {
+	logOpenTraceClicked,
+	OpenTraceSource,
+} from 'container/TracesExplorer/events';
 import { getTraceLink } from 'container/TracesExplorer/ListView/utils';
 import { TracesTableRow } from 'container/TracesExplorer/TracesTable/getFieldColumn';
 import { openInNewTab } from 'utils/navigation';
@@ -23,6 +28,7 @@ function OpenTraceButton({
 	const handleClick = (event: MouseEvent): void => {
 		// The row click would open the drawer instead.
 		event.stopPropagation();
+		logOpenTraceClicked(PANEL_TYPES.LIST, OpenTraceSource.RowIcon);
 		openInNewTab(getTraceLink(row));
 	};
 

frontend/src/container/TracesExplorer/SpanDrawer/SpanDrawer.tsx

@@ -4,7 +4,12 @@ import { ButtonGroup } from '@signozhq/ui/button-group';
 import { ChevronDown, ChevronUp, CornerUpRight } from '@signozhq/icons';
 import { useGetTraceSummary } from 'api/generated/services/tracedetail';
 import { HeaderAction } from 'components/DetailsPanel';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 import type { UseRowNavigationResult } from 'components/TanStackTableView/useRowNavigation';
+import {
+	logOpenTraceClicked,
+	OpenTraceSource,
+} from 'container/TracesExplorer/events';
 import { getTraceLink } from 'container/TracesExplorer/ListView/utils';
 import { TracesTableRow } from 'container/TracesExplorer/TracesTable/getFieldColumn';
 import { SpanDetailVariant } from 'pages/TraceDetailsV3/SpanDetailsPanel/constants';
@@ -48,7 +53,10 @@ function SpanDrawer({
 						color="secondary"
 						size="md"
 						prefix={<CornerUpRight />}
-						onClick={(): void => openInNewTab(getTraceLink(row))}
+						onClick={(): void => {
+							logOpenTraceClicked(PANEL_TYPES.LIST, OpenTraceSource.SpanDrawer);
+							openInNewTab(getTraceLink(row));
+						}}
 						testId="span-drawer-view-full-trace"
 					>
 						View full trace

frontend/src/container/TracesExplorer/TracesTable/FieldCell.tsx

@@ -4,7 +4,12 @@ import { Minus } from '@signozhq/icons';
 import { Badge } from '@signozhq/ui/badge';
 import TanStackTable from 'components/TanStackTableView';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
+import {
+	logOpenTraceClicked,
+	OpenTraceSource,
+} from 'container/TracesExplorer/events';
 import { getMs } from 'utils/timeUtils';
 import { useTimezone } from 'providers/Timezone';
 
@@ -21,9 +26,10 @@ import styles from './FieldCell.module.scss';
 type FieldCellProps = {
 	name: string;
 	value: unknown;
+	panelType: PANEL_TYPES;
 };
 
-function FieldCell({ name, value }: FieldCellProps): JSX.Element {
+function FieldCell({ name, value, panelType }: FieldCellProps): JSX.Element {
 	const { formatTimezoneAdjustedTimestamp } = useTimezone();
 
 	if (TIMESTAMP_FIELD_NAMES.has(name)) {
@@ -54,7 +60,15 @@ function FieldCell({ name, value }: FieldCellProps): JSX.Element {
 			<AppLink
 				to={buildRoutePath(ROUTES.TRACE_DETAIL, { id: text })}
 				data-testid="trace-id"
-				onClick={(e): void => e.stopPropagation()}
+				onClick={(e): void => {
+					e.stopPropagation();
+					logOpenTraceClicked(panelType, OpenTraceSource.TraceId);
+				}}
+				onAuxClick={(e): void => {
+					if (e.button === 1) {
+						logOpenTraceClicked(panelType, OpenTraceSource.TraceId);
+					}
+				}}
 			>
 				{text}
 			</AppLink>

frontend/src/container/TracesExplorer/TracesTable/TracesTable.tsx

@@ -2,6 +2,7 @@ import { useCallback, useRef } from 'react';
 import { useAppNavigate } from 'lib/router/useAppNavigate';
 import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
 import TanStackTable from 'components/TanStackTableView';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 import type {
 	CellTypographySize,
 	TableColumnDef,
@@ -10,6 +11,10 @@ import { useRecoverFromEmptyPage } from 'components/TanStackTableView/useRecover
 import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
 import NoLogs from 'container/NoLogs/NoLogs';
 import { TracesLoading } from 'container/TracesExplorer/TraceLoading/TraceLoading';
+import {
+	logOpenTraceClicked,
+	OpenTraceSource,
+} from 'container/TracesExplorer/events';
 import APIError from 'types/api/error';
 import { DataSource, PanelTypeKeys } from 'types/common/queryBuilder';
 import { noop } from 'lodash-es';
@@ -101,16 +106,18 @@ function TracesTable({
 				onRowClick(row);
 				return;
 			}
+			logOpenTraceClicked(PANEL_TYPES[panelType], OpenTraceSource.Row);
 			navigate(getRowHref(row));
 		},
-		[onRowClick, navigate, getRowHref],
+		[onRowClick, navigate, getRowHref, panelType],
 	);
 
 	const handleRowClickNewTab = useCallback(
 		(row: TracesTableRow): void => {
+			logOpenTraceClicked(PANEL_TYPES[panelType], OpenTraceSource.Row);
 			window.open(getAbsoluteUrl(getRowHref(row)), '_blank', 'noopener');
 		},
-		[getRowHref],
+		[getRowHref, panelType],
 	);
 
 	return (

frontend/src/container/TracesExplorer/TracesTable/getFieldColumn.tsx

@@ -2,6 +2,7 @@ import { TelemetryFieldKey } from 'api/v5/v5';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
 import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import { getSpanAttribute } from 'pages/TraceDetailsV3/utils';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 
 import { TIMESTAMP_FIELD_NAMES } from './constants';
 import FieldCell from './FieldCell';
@@ -10,6 +11,7 @@ export type TracesTableRow = { id: string } & Record<string, unknown>;
 
 export function getFieldColumn(
 	field: TelemetryFieldKey,
+	panelType: PANEL_TYPES,
 ): TableColumnDef<TracesTableRow> {
 	const { name, fieldContext, fieldDataType } = field;
 	const isTimestamp = TIMESTAMP_FIELD_NAMES.has(name);
@@ -25,6 +27,8 @@ export function getFieldColumn(
 		enableRemove: !isTimestamp,
 		canBeHidden: !isTimestamp,
 		width: { min: 192 },
-		cell: ({ value }): JSX.Element => <FieldCell name={name} value={value} />,
+		cell: ({ value }): JSX.Element => (
+			<FieldCell name={name} value={value} panelType={panelType} />
+		),
 	};
 }

frontend/src/container/TracesExplorer/TracesView/__tests__/OpenTraceClicked.test.tsx

@@ -0,0 +1,93 @@
+import { logEventMock } from '__tests__/logEventMock';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import {
+	OpenTraceSource,
+	TracesExplorerEvents,
+} from 'container/TracesExplorer/events';
+import { getCurrentLocation } from 'lib/router/navigation';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { screen, userEvent, waitFor, within } from 'tests/test-utils';
+
+import {
+	groupedResponse,
+	groupedRows,
+	QUERY_RANGE_URL,
+	renderTracesView,
+} from './testUtils';
+
+const TRACE_ID = '0000000000000000344ded1387b08a7e';
+const ROW_TEST_ID = `traces-table-row-${TRACE_ID}`;
+
+describe('TracesView - open trace clicked', () => {
+	beforeEach(() => {
+		server.use(
+			rest.post(QUERY_RANGE_URL, (_req, res, ctx) =>
+				res(ctx.status(200), ctx.json(groupedResponse(groupedRows))),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('logs a row click that opens the trace page', async () => {
+		const user = userEvent.setup();
+		renderTracesView();
+
+		const row = await screen.findByTestId(ROW_TEST_ID);
+		// The row click handler sits on each cell, so a click on the <tr> does nothing.
+		await user.click(within(row).getAllByRole('cell')[0]);
+
+		await waitFor(() =>
+			expect(getCurrentLocation().pathname).toBe(`/trace/${TRACE_ID}`),
+		);
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.TRACE,
+				source: OpenTraceSource.Row,
+			},
+		);
+	});
+
+	it('logs a trace_id link click', async () => {
+		const user = userEvent.setup();
+		renderTracesView();
+
+		const row = await screen.findByTestId(ROW_TEST_ID);
+		await user.click(within(row).getByTestId('trace-id'));
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.TRACE,
+				source: OpenTraceSource.TraceId,
+			},
+		);
+		expect(logEventMock).not.toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{ panelType: PANEL_TYPES.TRACE, source: OpenTraceSource.Row },
+		);
+	});
+
+	it('logs a middle click on the trace_id link', async () => {
+		const user = userEvent.setup();
+		renderTracesView();
+
+		const row = await screen.findByTestId(ROW_TEST_ID);
+		await user.pointer({
+			keys: '[MouseMiddle]',
+			target: within(row).getByTestId('trace-id'),
+		});
+
+		expect(logEventMock).toHaveBeenCalledWith(
+			TracesExplorerEvents.OpenTraceClicked,
+			{
+				panelType: PANEL_TYPES.TRACE,
+				source: OpenTraceSource.TraceId,
+			},
+		);
+	});
+});

frontend/src/container/TracesExplorer/TracesView/configs.tsx

@@ -1,4 +1,5 @@
 import { TelemetryFieldKey } from 'api/v5/v5';
+import { PANEL_TYPES } from 'constants/queryBuilder';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
 import {
 	getFieldColumn,
@@ -15,7 +16,7 @@ const TRACE_FIELDS = [
 
 export const columns: TableColumnDef<TracesTableRow>[] = TRACE_FIELDS.map(
 	(field) => ({
-		...getFieldColumn(field),
+		...getFieldColumn(field, PANEL_TYPES.TRACE),
 		enableRemove: false,
 		canBeHidden: false,
 	}),

frontend/src/container/TracesExplorer/events.ts

@@ -0,0 +1,20 @@
+import logEvent from 'api/common/logEvent';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+
+export enum TracesExplorerEvents {
+	OpenTraceClicked = 'Traces Explorer: Open trace clicked',
+}
+
+export enum OpenTraceSource {
+	Row = 'row',
+	RowIcon = 'row_icon',
+	TraceId = 'trace_id',
+	SpanDrawer = 'span_drawer',
+}
+
+export function logOpenTraceClicked(
+	panelType: PANEL_TYPES,
+	source: OpenTraceSource,
+): void {
+	void logEvent(TracesExplorerEvents.OpenTraceClicked, { panelType, source });
+}

frontend/src/hooks/useHandleExplorerTabChange.ts

@@ -25,6 +25,7 @@ export const useHandleExplorerTabChange = (): {
 		querySearchParameters?: ICurrentQueryData,
 		redirectToUrl?: (typeof ROUTES)[keyof typeof ROUTES],
 		newTab?: boolean,
+		searchParams?: Record<string, unknown>,
 	) => void;
 } => {
 	const {
@@ -69,6 +70,7 @@ export const useHandleExplorerTabChange = (): {
 			currentQueryData?: ICurrentQueryData,
 			redirectToUrl?: (typeof ROUTES)[keyof typeof ROUTES],
 			newTab?: boolean,
+			searchParams?: Record<string, unknown>,
 		) => {
 			const newPanelType = type as PANEL_TYPES;
 
@@ -82,6 +84,7 @@ export const useHandleExplorerTabChange = (): {
 			redirectWithQueryBuilderData(
 				query,
 				{
+					...searchParams,
 					[QueryParams.panelTypes]: newPanelType,
 					...(nextViewKey ? { [QueryParams.viewKey]: nextViewKey } : {}),
 				},

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

@@ -36,6 +36,12 @@ describe('hasPreferences', () => {
 		).toBe(true);
 		expect(
 			hasPreferences(SavedviewtypesSourceDTO.ai_observability, PANEL_TYPES.LIST),
+		).toBe(true);
+		expect(
+			hasPreferences(
+				SavedviewtypesSourceDTO.ai_observability,
+				PANEL_TYPES.TIME_SERIES,
+			),
 		).toBe(false);
 	});
 

frontend/src/providers/preferences/configs/aiObservabilityLoaderConfig.ts

@@ -7,6 +7,7 @@ import {
 	DEFAULT_PANEL_TYPE,
 	TRACE_VIEW_DEFAULT_COLUMNS,
 } from 'container/LLMObservability/Explorer/constants';
+import { defaultSelectedColumns as LIST_VIEW_DEFAULT_COLUMNS } from 'container/LLMObservability/Explorer/ListView/configs';
 
 import { PanelColumns } from '../types';
 import { isAiObservabilityExplorerRoute } from '../utils';
@@ -45,6 +46,11 @@ const toPanels = (value: unknown): PanelColumns => {
 	);
 };
 
+const PANEL_DEFAULT_COLUMNS: PanelColumns = {
+	[PANEL_TYPES.LIST]: LIST_VIEW_DEFAULT_COLUMNS,
+	[PANEL_TYPES.TRACE]: TRACE_VIEW_DEFAULT_COLUMNS,
+};
+
 // Stored as { [panelType]: columns }.
 export const readStoredPanels = (): PanelColumns => {
 	try {
@@ -91,9 +97,8 @@ const getAiObservabilityLoaderConfig = (
 ): AiObservabilityLoaderConfig => ({
 	local: () => ({ columns: readStoredPanels()[panelType] ?? [] }),
 	url: () => ({ columns: readUrlPanels()[panelType] ?? [] }),
-	// Only the trace panel keeps columns today.
 	default: () => ({
-		columns: panelType === PANEL_TYPES.TRACE ? TRACE_VIEW_DEFAULT_COLUMNS : [],
+		columns: PANEL_DEFAULT_COLUMNS[panelType] ?? [],
 	}),
 	priority: ['local', 'url', 'default'] as const,
 });

frontend/src/providers/preferences/constants.ts

@@ -10,5 +10,6 @@ export const PREFERENCE_SOURCE_PAGES = [
 
 // The AI observability panels that keep their own columns.
 export const AI_OBSERVABILITY_COLUMN_PANELS: PANEL_TYPES[] = [
+	PANEL_TYPES.LIST,
 	PANEL_TYPES.TRACE,
 ];

pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/config.go

@@ -9,8 +9,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/tidwall/gjson"
-	"github.com/uptrace/bun"
 )
 
 type config struct {
@@ -239,37 +237,6 @@ func (store *config) ListAllChannels(ctx context.Context) ([]*alertmanagertypes.
 	return channels, nil
 }
 
-func (store *config) GetMatchers(ctx context.Context, orgID string) (map[string][]string, error) {
-	type matcher struct {
-		bun.BaseModel `bun:"table:rule"`
-		ID            valuer.UUID `bun:"id,pk"`
-		Data          string      `bun:"data"`
-	}
-
-	matchers := []matcher{}
-
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Column("id", "data").
-		Model(&matchers).
-		Scan(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	matchersMap := make(map[string][]string)
-	for _, matcher := range matchers {
-		receivers := gjson.Get(matcher.Data, "preferredChannels").Array()
-		for _, receiver := range receivers {
-			matchersMap[matcher.ID.StringValue()] = append(matchersMap[matcher.ID.StringValue()], receiver.String())
-		}
-	}
-
-	return matchersMap, nil
-}
-
 func (store *config) wrap(ctx context.Context, fn func(ctx context.Context) error, opts ...alertmanagertypes.StoreOption) error {
 	storeOpts := alertmanagertypes.NewStoreOptions(opts...)
 

pkg/alertmanager/service.go

@@ -245,25 +245,13 @@ func (service *Service) compareAndSelectConfig(ctx context.Context, incomingConf
 		return nil, err
 	}
 
-	matchers, err := service.configStore.GetMatchers(ctx, incomingConfig.StoreableConfig().OrgID)
-	if err != nil {
-		return nil, err
-	}
-
 	config, err := alertmanagertypes.NewConfigFromChannels(service.config.Global, service.config.Route, channels, incomingConfig.StoreableConfig().OrgID)
 	if err != nil {
 		return nil, err
 	}
 
-	for ruleID, receivers := range matchers {
-		err = config.CreateRuleIDMatcher(ruleID, receivers)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	if incomingConfig.StoreableConfig().Hash != config.StoreableConfig().Hash {
-		service.settings.Logger().InfoContext(ctx, "mismatch found, updating config to match channels and matchers")
+		service.settings.Logger().InfoContext(ctx, "mismatch found, updating config to match channels")
 		return config, nil
 	}
 

pkg/apiserver/signozapiserver/ruler.go

@@ -14,20 +14,6 @@ import (
 )
 
 func (provider *provider) addRulerRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/rules", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.ListRules), handler.OpenAPIDef{
-		ID:                  "ListRules",
-		Tags:                []string{"rules"},
-		Summary:             "List alert rules",
-		Description:         "This endpoint lists all alert rules with their current evaluation state. Deprecated: use ListRulesV3, which supports filtering, sorting and pagination.",
-		Response:            make([]*ruletypes.Rule, 0),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		Deprecated:          true,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v3/rules", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.ListRulesV3), handler.OpenAPIDef{
 		ID:                  "ListRulesV3",
 		Tags:                []string{"rules"},

pkg/modules/rulestatehistory/implrulestatehistory/links.go

@@ -59,11 +59,7 @@ func (m *module) relatedLinkBuilderForRule(ctx context.Context, orgID valuer.UUI
 		}
 	}
 	if builder.evaluation == nil {
-		evalWindow := rule.EvalWindow
-		if evalWindow.IsZero() {
-			evalWindow = valuer.MustParseTextDuration("5m")
-		}
-		builder.evaluation = ruletypes.RollingWindow{EvalWindow: evalWindow}
+		return nil
 	}
 
 	return builder

pkg/querier/bucket_cache.go

@@ -26,9 +26,8 @@ const bucketCacheCellSteps = 60
 type BucketCache interface {
 	// cached portion + list of gaps to fetch
 	GetMissRanges(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step) (cached *qbtypes.Result, missing []*qbtypes.TimeRange)
-	// store fresh buckets for future hits; only the ranges in the map were
-	// queried for fresh, the rest of it came from the cache
-	Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result, execStatsForQueriedTimeRanges map[qbtypes.TimeRange]qbtypes.ExecStats)
+	// store fresh buckets for future hits
+	Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result)
 }
 
 // bucketCache implements the BucketCache interface.
@@ -117,7 +116,7 @@ func (bc *bucketCache) GetMissRanges(
 	}
 
 	// Merge buckets into a single result
-	mergedResult := bc.mergeBuckets(ctx, relevantBuckets, cachedWarnings, startMs, endMs)
+	mergedResult := bc.mergeBuckets(ctx, relevantBuckets, cachedWarnings)
 
 	// Filter the merged result to only include values within the requested time range
 	mergedResult = bc.filterResultToTimeRange(mergedResult, q, startMs, endMs, stepMs)
@@ -126,7 +125,7 @@ func (bc *bucketCache) GetMissRanges(
 }
 
 // Put stores fresh query results in the cache.
-func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result, execStatsForQueriedTimeRanges map[qbtypes.TimeRange]qbtypes.ExecStats) {
+func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result) {
 	// Get query window
 	startMs, endMs := q.Window()
 
@@ -189,7 +188,7 @@ func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Que
 
 	// Convert trimmed result to buckets, one per grid cell it spans
 	cellWidthMs := bucketCacheCellSteps * stepMs
-	freshBuckets := bc.resultToBuckets(ctx, trimmedResult, cachableStartMs, cachableEndMs, cellWidthMs, execStatsForQueriedTimeRanges)
+	freshBuckets := bc.resultToBuckets(ctx, trimmedResult, cachableStartMs, cachableEndMs, cellWidthMs)
 
 	cellKeys := make([]string, len(freshBuckets))
 	cellEntries := make([]cachetypes.Cacheable, len(freshBuckets))
@@ -211,7 +210,7 @@ func (bc *bucketCache) Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Que
 			cellEntry = cellEntries[i].(*qbtypes.CachedData)
 		}
 
-		cellBuckets, changed := bc.mergeFreshBucketIntoCell(ctx, cellEntry.Buckets, freshBucket, execStatsForQueriedTimeRanges)
+		cellBuckets, changed := bc.mergeFreshBucketIntoCell(ctx, cellEntry.Buckets, freshBucket)
 		if !changed {
 			continue
 		}
@@ -464,7 +463,7 @@ func (bc *bucketCache) filterRelevantBuckets(buckets []*qbtypes.CachedBucket, st
 }
 
 // mergeBuckets combines multiple cached buckets into a single result.
-func (bc *bucketCache) mergeBuckets(ctx context.Context, buckets []*qbtypes.CachedBucket, warnings []string, startMs, endMs uint64) *qbtypes.Result {
+func (bc *bucketCache) mergeBuckets(ctx context.Context, buckets []*qbtypes.CachedBucket, warnings []string) *qbtypes.Result {
 	if len(buckets) == 0 {
 		return &qbtypes.Result{}
 	}
@@ -472,13 +471,12 @@ func (bc *bucketCache) mergeBuckets(ctx context.Context, buckets []*qbtypes.Cach
 	// All buckets should have the same type
 	resultType := buckets[0].Type
 
-	// A bucket can reach past the window; only the part inside it is served
+	// Aggregate stats
 	var totalStats qbtypes.ExecStats
 	for _, bucket := range buckets {
-		servedStats := bucket.ProrateStatsToWindow(startMs, endMs)
-		totalStats.RowsScanned += servedStats.RowsScanned
-		totalStats.BytesScanned += servedStats.BytesScanned
-		totalStats.DurationMS += servedStats.DurationMS
+		totalStats.RowsScanned += bucket.Stats.RowsScanned
+		totalStats.BytesScanned += bucket.Stats.BytesScanned
+		totalStats.DurationMS += bucket.Stats.DurationMS
 	}
 
 	// Merge values based on type
@@ -676,7 +674,7 @@ func (bc *bucketCache) isEmptyResult(result *qbtypes.Result) (isEmpty bool, isFi
 }
 
 // resultToBuckets converts a query result into time-based buckets.
-func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Result, startMs, endMs, cellWidthMs uint64, execStatsForQueriedTimeRanges map[qbtypes.TimeRange]qbtypes.ExecStats) []*qbtypes.CachedBucket {
+func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Result, startMs, endMs, cellWidthMs uint64) []*qbtypes.CachedBucket {
 	// Check if result is empty
 	isEmpty, isFiltered := bc.isEmptyResult(result)
 
@@ -688,7 +686,7 @@ func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Resu
 	}
 
 	// Empty filtered results still become buckets, so the range is not re-queried
-	perCellBuckets, err := result.SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs, execStatsForQueriedTimeRanges)
+	perCellBuckets, err := result.SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs)
 	if err != nil {
 		bc.logger.ErrorContext(ctx, "failed to convert result to buckets", errors.Attr(err))
 		return nil
@@ -700,7 +698,7 @@ func (bc *bucketCache) resultToBuckets(ctx context.Context, result *qbtypes.Resu
 // and reports whether the cell changed: a bucket already covering the fresh
 // one leaves it as is, buckets inside the fresh one are replaced, buckets
 // overlapping or edge to edge with it are unioned, and the rest are kept apart.
-func (bc *bucketCache) mergeFreshBucketIntoCell(ctx context.Context, cellBuckets []*qbtypes.CachedBucket, freshBucket *qbtypes.CachedBucket, execStatsForQueriedTimeRanges map[qbtypes.TimeRange]qbtypes.ExecStats) ([]*qbtypes.CachedBucket, bool) {
+func (bc *bucketCache) mergeFreshBucketIntoCell(ctx context.Context, cellBuckets []*qbtypes.CachedBucket, freshBucket *qbtypes.CachedBucket) ([]*qbtypes.CachedBucket, bool) {
 	keptBuckets := make([]*qbtypes.CachedBucket, 0, len(cellBuckets)+1)
 	touchingBuckets := []*qbtypes.CachedBucket{}
 	for _, cellBucket := range cellBuckets {
@@ -713,7 +711,7 @@ func (bc *bucketCache) mergeFreshBucketIntoCell(ctx context.Context, cellBuckets
 			keptBuckets = append(keptBuckets, cellBucket)
 		}
 	}
-	keptBuckets = append(keptBuckets, bc.unionBuckets(ctx, freshBucket, touchingBuckets, execStatsForQueriedTimeRanges))
+	keptBuckets = append(keptBuckets, bc.unionBuckets(ctx, freshBucket, touchingBuckets))
 
 	slices.SortFunc(keptBuckets, func(a, b *qbtypes.CachedBucket) int {
 		return cmp.Compare(a.StartMs, b.StartMs)
@@ -724,16 +722,7 @@ func (bc *bucketCache) mergeFreshBucketIntoCell(ctx context.Context, cellBuckets
 // unionBuckets widens the fresh bucket by the buckets it touches. Buckets
 // inside it are replaced outright, so only a genuine partial overlap decodes
 // anything.
-func (bc *bucketCache) unionBuckets(ctx context.Context, freshBucket *qbtypes.CachedBucket, touchingBuckets []*qbtypes.CachedBucket, execStatsForQueriedTimeRanges map[qbtypes.TimeRange]qbtypes.ExecStats) *qbtypes.CachedBucket {
-	// Data queried again takes the new query's cost, which the fresh bucket
-	// carries; a touching bucket keeps its cost only for what was not queried again
-	for _, touchingBucket := range touchingBuckets {
-		keptStats := touchingBucket.ProrateStatsToUnqueried(execStatsForQueriedTimeRanges)
-		freshBucket.Stats.RowsScanned += keptStats.RowsScanned
-		freshBucket.Stats.BytesScanned += keptStats.BytesScanned
-		freshBucket.Stats.DurationMS += keptStats.DurationMS
-	}
-
+func (bc *bucketCache) unionBuckets(ctx context.Context, freshBucket *qbtypes.CachedBucket, touchingBuckets []*qbtypes.CachedBucket) *qbtypes.CachedBucket {
 	bucketsToMerge := []*qbtypes.CachedBucket{freshBucket}
 	for _, touchingBucket := range touchingBuckets {
 		if !freshBucket.Contains(touchingBucket) {
@@ -754,11 +743,14 @@ func (bc *bucketCache) unionBuckets(ctx context.Context, freshBucket *qbtypes.Ca
 		EndMs:   freshBucket.EndMs,
 		Type:    freshBucket.Type,
 		Value:   value,
-		Stats:   freshBucket.Stats,
+		Stats:   qbtypes.ExecStats{StepIntervals: freshBucket.Stats.StepIntervals},
 	}
 	for _, mergedBucket := range bucketsToMerge {
 		unionBucket.StartMs = min(unionBucket.StartMs, mergedBucket.StartMs)
 		unionBucket.EndMs = max(unionBucket.EndMs, mergedBucket.EndMs)
+		unionBucket.Stats.RowsScanned += mergedBucket.Stats.RowsScanned
+		unionBucket.Stats.BytesScanned += mergedBucket.Stats.BytesScanned
+		unionBucket.Stats.DurationMS += mergedBucket.Stats.DurationMS
 	}
 	return unionBucket
 }

pkg/querier/bucket_cache_bench_test.go

@@ -30,7 +30,7 @@ func BenchmarkBucketCache_GetMissRanges(b *testing.B) {
 			endMs:       uint64((i + 1) * 10000),
 		}
 		result := createBenchmarkResult(query.startMs, query.endMs, 1000)
-		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	}
 
 	// Create test queries with varying cache hit patterns
@@ -121,7 +121,7 @@ func BenchmarkBucketCache_Put(b *testing.B) {
 
 			for i := 0; i < b.N; i++ {
 				for j := 0; j < tc.numQueries; j++ {
-					bc.Put(ctx, orgID, queries[j], qbtypes.Step{Duration: 1000 * time.Millisecond}, results[j], map[qbtypes.TimeRange]qbtypes.ExecStats{{From: queries[j].startMs, To: queries[j].endMs}: results[j].Stats})
+					bc.Put(ctx, orgID, queries[j], qbtypes.Step{Duration: 1000 * time.Millisecond}, results[j])
 				}
 			}
 		})
@@ -259,7 +259,7 @@ func BenchmarkBucketCache_ConcurrentOperations(b *testing.B) {
 			endMs:       uint64((i + 1) * 10000),
 		}
 		result := createBenchmarkResult(query.startMs, query.endMs, 1000)
-		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	}
 
 	b.ResetTimer()
@@ -284,7 +284,7 @@ func BenchmarkBucketCache_ConcurrentOperations(b *testing.B) {
 					endMs:       uint64((i + 1) * 10000),
 				}
 				result := createBenchmarkResult(query.startMs, query.endMs, 1000)
-				bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+				bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 			case 2: // Partial read
 				query := &mockQuery{
 					fingerprint: fmt.Sprintf("concurrent-query-%d", i%100),

pkg/querier/bucket_cache_step_test.go

@@ -59,7 +59,7 @@ func TestBucketCacheStepAlignment(t *testing.T) {
 	}
 
 	// Put result in cache
-	bc.Put(ctx, orgID, query, step, result, nil)
+	bc.Put(ctx, orgID, query, step, result)
 
 	// Get cached data
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
@@ -109,7 +109,7 @@ func TestBucketCacheNoStepInterval(t *testing.T) {
 	}
 
 	// Should cache the entire range when step is 0
-	bc.Put(ctx, orgID, query, step, result, nil)
+	bc.Put(ctx, orgID, query, step, result)
 
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
 	assert.NotNil(t, cached)

pkg/querier/bucket_cache_test.go

@@ -156,7 +156,7 @@ func TestBucketCache_Put_And_Get(t *testing.T) {
 	}
 
 	// Store in cache
-	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Wait a bit for cache to be written
 	time.Sleep(10 * time.Millisecond)
@@ -189,7 +189,7 @@ func TestBucketCache_PartialHit(t *testing.T) {
 		Type:  qbtypes.RequestTypeTimeSeries,
 		Value: createTestTimeSeries("A", 1000, 3000, 1000),
 	}
-	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1, nil)
+	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1)
 
 	// Wait for cache write
 	time.Sleep(10 * time.Millisecond)
@@ -225,7 +225,7 @@ func TestBucketCache_MultipleBuckets(t *testing.T) {
 	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 100 * time.Millisecond}, &qbtypes.Result{
 		Type:  qbtypes.RequestTypeTimeSeries,
 		Value: createTestTimeSeries("A", 1000, 2000, 100),
-	}, nil)
+	})
 
 	query2 := &mockQuery{
 		fingerprint: "test-query",
@@ -235,7 +235,7 @@ func TestBucketCache_MultipleBuckets(t *testing.T) {
 	bc.Put(context.Background(), valuer.UUID{}, query2, qbtypes.Step{Duration: 100 * time.Millisecond}, &qbtypes.Result{
 		Type:  qbtypes.RequestTypeTimeSeries,
 		Value: createTestTimeSeries("A", 3000, 4000, 100),
-	}, nil)
+	})
 
 	// Wait for cache writes
 	time.Sleep(10 * time.Millisecond)
@@ -280,7 +280,7 @@ func TestBucketCache_FluxInterval(t *testing.T) {
 	}
 
 	// This should not be cached due to flux interval
-	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Wait a bit
 	time.Sleep(10 * time.Millisecond)
@@ -358,7 +358,7 @@ func TestBucketCache_MergeTimeSeriesResults(t *testing.T) {
 				{Series: []*qbtypes.TimeSeries{series1}},
 			},
 		},
-	}, nil)
+	})
 
 	// Cache second part
 	query2 := &mockQuery{
@@ -374,7 +374,7 @@ func TestBucketCache_MergeTimeSeriesResults(t *testing.T) {
 				{Series: []*qbtypes.TimeSeries{series2}},
 			},
 		},
-	}, nil)
+	})
 
 	// Wait for cache writes
 	time.Sleep(10 * time.Millisecond)
@@ -441,7 +441,7 @@ func TestBucketCache_RawData(t *testing.T) {
 		Value: rawData,
 	}
 
-	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	time.Sleep(10 * time.Millisecond)
 
 	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
@@ -481,7 +481,7 @@ func TestBucketCache_ScalarData(t *testing.T) {
 		Value: scalarData,
 	}
 
-	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	time.Sleep(10 * time.Millisecond)
 
 	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
@@ -509,7 +509,7 @@ func TestBucketCache_EmptyFingerprint(t *testing.T) {
 		Value: createTestTimeSeries("A", 1000, 5000, 1000),
 	}
 
-	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	time.Sleep(10 * time.Millisecond)
 
 	// Should still be able to retrieve
@@ -564,7 +564,7 @@ func TestBucketCache_ConcurrentAccess(t *testing.T) {
 				Type:  qbtypes.RequestTypeTimeSeries,
 				Value: createTestTimeSeries(fmt.Sprintf("Q%d", id), query.startMs, query.endMs, 100),
 			}
-			bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 100 * time.Microsecond}, result, nil)
+			bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 100 * time.Microsecond}, result)
 			done <- true
 		}(i)
 	}
@@ -624,7 +624,7 @@ func TestBucketCache_GetMissRanges_FluxInterval(t *testing.T) {
 		},
 	}
 
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, cachedResult, nil)
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, cachedResult)
 
 	// Get miss ranges
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
@@ -686,7 +686,7 @@ func TestBucketCache_Put_FluxIntervalTrimming(t *testing.T) {
 	}
 
 	// Put the result
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Retrieve cached data
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
@@ -756,7 +756,7 @@ func TestBucketCache_Put_EntireRangeInFluxInterval(t *testing.T) {
 	}
 
 	// Put the result - should not cache anything
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Try to get cached data - should have no cached data
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
@@ -862,7 +862,7 @@ func TestBucketCache_EmptyDataHandling(t *testing.T) {
 			}
 
 			// Put the result
-			bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, tt.result, nil)
+			bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, tt.result)
 
 			// Wait a bit for cache to be written
 			time.Sleep(10 * time.Millisecond)
@@ -927,7 +927,7 @@ func TestBucketCache_PartialValues(t *testing.T) {
 	}
 
 	// Put the result
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: query.startMs, To: query.endMs}: result.Stats})
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Wait for cache to be written
 	time.Sleep(10 * time.Millisecond)
@@ -997,7 +997,7 @@ func TestBucketCache_AllPartialValues(t *testing.T) {
 	}
 
 	// Put the result
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 
 	// Wait for cache to be written
 	time.Sleep(10 * time.Millisecond)
@@ -1058,7 +1058,7 @@ func TestBucketCache_FilteredCachedResults(t *testing.T) {
 	}
 
 	// Cache the wide range
-	bc.Put(ctx, orgID, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1, nil)
+	bc.Put(ctx, orgID, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1)
 	time.Sleep(10 * time.Millisecond)
 
 	// Now query for a smaller range (2000-3500ms)
@@ -1125,7 +1125,7 @@ func TestBucketCache_PromQLKeepsTheValueAtTheWindowEnd(t *testing.T) {
 				}},
 			}},
 		},
-	}, nil)
+	})
 	time.Sleep(10 * time.Millisecond)
 
 	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
@@ -1291,7 +1291,7 @@ func TestBucketCache_PartialValueDetection(t *testing.T) {
 		}
 
 		// Put the result
-		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 		time.Sleep(10 * time.Millisecond)
 
 		// Get cached data
@@ -1345,7 +1345,7 @@ func TestBucketCache_PartialValueDetection(t *testing.T) {
 		}
 
 		// Put the result
-		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 		time.Sleep(10 * time.Millisecond)
 
 		// Get cached data
@@ -1397,7 +1397,7 @@ func TestBucketCache_PartialValueDetection(t *testing.T) {
 		}
 
 		// Put the result
-		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 		time.Sleep(10 * time.Millisecond)
 
 		// Get cached data
@@ -1454,7 +1454,7 @@ func TestBucketCache_NoCache(t *testing.T) {
 	}
 
 	// Put the result in cache
-	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result, nil)
+	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
 	time.Sleep(10 * time.Millisecond)
 
 	// Verify data is cached
@@ -1475,12 +1475,11 @@ func TestBucketCachePutSlicesAtCellBoundaries(t *testing.T) {
 
 	// a 1s step gives 60s cells, so 30s to 150s spans three of them
 	query := &mockQuery{fingerprint: "sliced-query", startMs: 30000, endMs: 150000}
-	result := &qbtypes.Result{
+	bc.Put(ctx, orgID, query, step, &qbtypes.Result{
 		Type:  qbtypes.RequestTypeTimeSeries,
 		Value: createTestTimeSeries("A", 30000, 150000, 1000),
 		Stats: qbtypes.ExecStats{RowsScanned: 120, BytesScanned: 1200, DurationMS: 12},
-	}
-	bc.Put(ctx, orgID, query, step, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: 30000, To: 150000}: result.Stats})
+	})
 
 	type bucketShape struct {
 		cell, startMs, endMs, rowsScanned uint64
@@ -1540,7 +1539,7 @@ func TestBucketCachePutAbsorbsWritesWithinACell(t *testing.T) {
 			name:                  "OverlappingWrites_BecomeOne",
 			firstWindow:           qbtypes.TimeRange{From: 1000, To: 4000},
 			secondWindow:          qbtypes.TimeRange{From: 3000, To: 6000},
-			expectedBuckets:       []bucketShape{{1000, 6000, 5}},
+			expectedBuckets:       []bucketShape{{1000, 6000, 6}},
 			expectedMissingRanges: []*qbtypes.TimeRange{},
 			expectedValueCount:    5,
 		},
@@ -1571,13 +1570,12 @@ func TestBucketCachePutAbsorbsWritesWithinACell(t *testing.T) {
 
 			for _, window := range []qbtypes.TimeRange{testCase.firstWindow, testCase.secondWindow} {
 				query := &mockQuery{fingerprint: "absorb-query", startMs: window.From, endMs: window.To}
-				result := &qbtypes.Result{
+				bc.Put(ctx, orgID, query, step, &qbtypes.Result{
 					Type:  qbtypes.RequestTypeTimeSeries,
 					Value: createTestTimeSeries("A", window.From, window.To, 1000),
-					// one row per second, so a bucket's stats read as the seconds of data it holds
+					// one row per second, so a bucket's stats read as the seconds it was scanned for
 					Stats: qbtypes.ExecStats{RowsScanned: (window.To - window.From) / 1000},
-				}
-				bc.Put(ctx, orgID, query, step, result, map[qbtypes.TimeRange]qbtypes.ExecStats{window: result.Stats})
+				})
 			}
 
 			query := &mockQuery{
@@ -1611,7 +1609,7 @@ func TestBucketCachePutLeavesAnUnchangedCellAlone(t *testing.T) {
 		Type:     qbtypes.RequestTypeTimeSeries,
 		Value:    createTestTimeSeries("A", 1000, 10000, 1000),
 		Warnings: []string{"from the wide write"},
-	}, nil)
+	})
 
 	// a write already covered by the cell's bucket must not rewrite the entry,
 	// which shows as its warnings never arriving
@@ -1620,7 +1618,7 @@ func TestBucketCachePutLeavesAnUnchangedCellAlone(t *testing.T) {
 		Type:     qbtypes.RequestTypeTimeSeries,
 		Value:    createTestTimeSeries("A", 3000, 5000, 1000),
 		Warnings: []string{"from the inside write"},
-	}, nil)
+	})
 
 	var cellEntry qbtypes.CachedData
 	require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(wide, 0), &cellEntry))

pkg/querier/querier.go

@@ -823,7 +823,7 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 				return nil, err
 			}
 			// Store in cache for future use
-			q.bucketCache.Put(ctx, orgID, query, step, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: startMs, To: endMs}: result.Stats})
+			q.bucketCache.Put(ctx, orgID, query, step, result)
 			return result, nil
 		}
 	}
@@ -879,19 +879,16 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 			if err != nil {
 				return nil, err
 			}
-			startMs, endMs := query.Window()
-			q.bucketCache.Put(ctx, orgID, query, step, result, map[qbtypes.TimeRange]qbtypes.ExecStats{{From: startMs, To: endMs}: result.Stats})
+			q.bucketCache.Put(ctx, orgID, query, step, result)
 			return result, nil
 		}
 	}
 
 	// Calculate total stats and filter out nil results
 	validResults := make([]*qbtypes.Result, 0, len(freshResults))
-	execStatsForQueriedTimeRanges := make(map[qbtypes.TimeRange]qbtypes.ExecStats, len(freshResults))
-	for i, result := range freshResults {
+	for _, result := range freshResults {
 		if result != nil {
 			validResults = append(validResults, result)
-			execStatsForQueriedTimeRanges[*missingRanges[i]] = result.Stats
 			totalStats.RowsScanned += result.Stats.RowsScanned
 			totalStats.BytesScanned += result.Stats.BytesScanned
 			totalStats.DurationMS += result.Stats.DurationMS
@@ -906,7 +903,7 @@ func (q *querier) executeWithCache(ctx context.Context, orgID valuer.UUID, query
 	mergedResult.Stats.DurationMS += totalStats.DurationMS
 
 	// Store merged result in cache
-	q.bucketCache.Put(ctx, orgID, query, step, mergedResult, execStatsForQueriedTimeRanges)
+	q.bucketCache.Put(ctx, orgID, query, step, mergedResult)
 
 	return mergedResult, nil
 }

pkg/query-service/app/http_handler.go

@@ -3,10 +3,8 @@ package app
 import (
 	"bytes"
 	"context"
-	"database/sql"
 	"encoding/json"
 	"fmt"
-	"io"
 
 	"github.com/SigNoz/signoz/pkg/clickhousesql"
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -360,14 +358,6 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/query_range", am.ViewAccess(aH.queryRangeMetrics)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/query", am.ViewAccess(aH.queryMetrics)).Methods(http.MethodGet)
 
-	router.HandleFunc("/api/v1/rules", am.ViewAccess(aH.listRules)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/rules/{id}", am.ViewAccess(aH.getRule)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/rules", am.EditAccess(aH.createRule)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.editRule)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.deleteRule)).Methods(http.MethodDelete)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.patchRule)).Methods(http.MethodPatch)
-	router.HandleFunc("/api/v1/testRule", am.EditAccess(aH.testRule)).Methods(http.MethodPost)
-
 	router.HandleFunc("/api/v2/variables/query", am.ViewAccess(aH.queryDashboardVarsV2)).Methods(http.MethodPost)
 
 	router.HandleFunc("/api/v1/explorer/views", am.ViewAccess(aH.Signoz.Handlers.SavedView.List)).Methods(http.MethodGet)
@@ -496,166 +486,6 @@ func (aH *APIHandler) PopulateTemporality(ctx context.Context, orgID valuer.UUID
 	return nil
 }
 
-func (aH *APIHandler) listRules(w http.ResponseWriter, r *http.Request) {
-
-	rules, err := aH.ruleManager.ListRuleStates(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
-		return
-	}
-
-	// todo(amol): need to add sorter
-
-	aH.Respond(w, rules)
-}
-
-func (aH *APIHandler) getRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	ruleResponse, err := aH.ruleManager.GetRule(r.Context(), id)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
-		return
-	}
-	aH.Respond(w, ruleResponse)
-}
-
-func (aH *APIHandler) createRule(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for create rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	rule, err := aH.ruleManager.CreateRule(r.Context(), string(body))
-	if err != nil {
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, rule)
-}
-
-func (aH *APIHandler) editRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for edit rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	err = aH.ruleManager.EditRule(r.Context(), string(body), id)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, "rule successfully edited")
-}
-
-func (aH *APIHandler) deleteRule(w http.ResponseWriter, r *http.Request) {
-	id := mux.Vars(r)["id"]
-
-	err := aH.ruleManager.DeleteRule(r.Context(), id)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, "rule successfully deleted")
-}
-
-func (aH *APIHandler) patchRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for patch rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	gettableRule, err := aH.ruleManager.PatchRule(r.Context(), string(body), id)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, gettableRule)
-}
-
-func (aH *APIHandler) testRule(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for test rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
-	defer cancel()
-
-	alertCount, err := aH.ruleManager.TestNotification(ctx, orgID, string(body))
-	if err != nil {
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	response := map[string]interface{}{
-		"alertCount": alertCount,
-		"message":    "notification sent",
-	}
-	aH.Respond(w, response)
-}
-
 func prepareQuery(r *http.Request) (string, error) {
 	var postData *model.DashboardVars
 

pkg/query-service/rules/base_rule.go

@@ -34,10 +34,6 @@ type BaseRule struct {
 	ruleCondition *ruletypes.RuleCondition
 
 	Threshold ruletypes.RuleThreshold
-	// evalWindow is the time window used for evaluating the rule
-	// i.e. each time we lookback from the current time, we look at data for the last
-	// evalWindow duration
-	evalWindow valuer.TextDuration
 	// holdDuration is the duration for which the alert waits before firing
 	holdDuration valuer.TextDuration
 
@@ -49,10 +45,7 @@ type BaseRule struct {
 	// these are the same for all alerts created for this rule
 	labels      ruletypes.Labels
 	annotations ruletypes.Labels
-	// preferredChannels is the list of channels to send the alert to
-	// if the rule is triggered
-	preferredChannels []string
-	mtx               sync.Mutex
+	mtx         sync.Mutex
 	// the time it took to evaluate the rule (most recent evaluation)
 	evaluationDuration time.Duration
 	// the timestamp of the last evaluation
@@ -151,26 +144,27 @@ func NewBaseRule(
 	if err != nil {
 		return nil, err
 	}
+	if err := threshold.Validate(); err != nil {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid rule threshold spec: %v", err)
+	}
 	evaluation, err := p.Evaluation.GetEvaluation()
 	if err != nil {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to get evaluation: %v", err)
 	}
 
 	baseRule := &BaseRule{
-		id:                id,
-		orgID:             orgID,
-		externalURL:       externalURL,
-		name:              p.AlertName.StringValue(),
-		typ:               p.AlertType,
-		ruleCondition:     p.RuleCondition,
-		evalWindow:        p.EvalWindow,
-		labels:            ruletypes.FromMap(p.Labels),
-		annotations:       ruletypes.FromMap(p.Annotations),
-		preferredChannels: p.PreferredChannels,
-		health:            ruletypes.HealthUnknown,
-		Active:            map[uint64]*ruletypes.Alert{},
-		Threshold:         threshold,
-		evaluation:        evaluation,
+		id:            id,
+		orgID:         orgID,
+		externalURL:   externalURL,
+		name:          p.AlertName.StringValue(),
+		typ:           p.AlertType,
+		ruleCondition: p.RuleCondition,
+		labels:        ruletypes.FromMap(p.Labels),
+		annotations:   ruletypes.FromMap(p.Annotations),
+		health:        ruletypes.HealthUnknown,
+		Active:        map[uint64]*ruletypes.Alert{},
+		Threshold:     threshold,
+		evaluation:    evaluation,
 	}
 
 	// Store newGroupEvalDelay and groupBy keys from NotificationSettings
@@ -178,10 +172,6 @@ func NewBaseRule(
 		baseRule.newGroupEvalDelay = p.NotificationSettings.NewGroupEvalDelay
 	}
 
-	if baseRule.evalWindow.IsZero() {
-		baseRule.evalWindow = valuer.MustParseTextDuration("5m")
-	}
-
 	for _, opt := range opts {
 		opt(baseRule)
 	}
@@ -232,10 +222,6 @@ func (r *BaseRule) EvalDelay() valuer.TextDuration {
 	return r.evalDelay
 }
 
-func (r *BaseRule) EvalWindow() valuer.TextDuration {
-	return r.evalWindow
-}
-
 func (r *BaseRule) HoldDuration() valuer.TextDuration {
 	return r.holdDuration
 }
@@ -246,7 +232,6 @@ func (r *BaseRule) Name() string                        { return r.name }
 func (r *BaseRule) Condition() *ruletypes.RuleCondition { return r.ruleCondition }
 func (r *BaseRule) Labels() ruletypes.Labels            { return r.labels }
 func (r *BaseRule) Annotations() ruletypes.Labels       { return r.annotations }
-func (r *BaseRule) PreferredChannels() []string         { return r.preferredChannels }
 
 func (r *BaseRule) GeneratorURL() string {
 	params := url.Values{}

pkg/query-service/rules/manager.go

@@ -332,17 +332,28 @@ func (m *Manager) validateChannels(ctx context.Context, orgID string, rule *rule
 	}
 
 	known := make(map[string]struct{}, len(orgChannels))
+	displayNameByName := make(map[string]string, len(orgChannels))
 	for _, ch := range orgChannels {
 		known[ch.DisplayName] = struct{}{}
+		displayNameByName[ch.Name] = ch.DisplayName
 	}
 
-	var unknown []string
+	var unknown, byName []string
 	for _, name := range channels {
-		if _, ok := known[name]; !ok {
-			unknown = append(unknown, name)
+		if _, ok := known[name]; ok {
+			continue
 		}
+		if displayName, ok := displayNameByName[name]; ok {
+			byName = append(byName, fmt.Sprintf("%s (display name %q)", name, displayName))
+			continue
+		}
+		unknown = append(unknown, name)
 	}
 
+	if len(byName) > 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput,
+			"channels: rules reference channels by display name, not name: %v", byName)
+	}
 	if len(unknown) > 0 {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput,
 			"channels: the following channels do not exist: %v", unknown)
@@ -359,7 +370,7 @@ func (m *Manager) EditRule(ctx context.Context, ruleStr string, id valuer.UUID)
 	}
 	orgID := valuer.MustNewUUID(claims.OrgID)
 	parsedRule := ruletypes.PostableRule{}
-	err = json.Unmarshal([]byte(ruleStr), &parsedRule)
+	err = parsedRule.DecodeStrict(ruleStr)
 	if err != nil {
 		return err
 	}
@@ -438,7 +449,7 @@ func (m *Manager) editTask(_ context.Context, orgID valuer.UUID, rule *ruletypes
 	})
 	if err != nil {
 		m.logger.Error("loading tasks failed", errors.Attr(err))
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error preparing rule with given parameters, previous rule set restored")
+		return err
 	}
 
 	for _, r := range newTask.Rules() {
@@ -547,7 +558,7 @@ func (m *Manager) deleteTask(taskName string) {
 // starts an executor for the rule, unless the rule is disabled
 func (m *Manager) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error) {
 	parsedRule := ruletypes.PostableRule{}
-	if err := json.Unmarshal([]byte(ruleStr), &parsedRule); err != nil {
+	if err := parsedRule.DecodeStrict(ruleStr); err != nil {
 		return nil, err
 	}
 
@@ -659,7 +670,7 @@ func (m *Manager) addTask(_ context.Context, orgID valuer.UUID, rule *ruletypes.
 	})
 	if err != nil {
 		m.logger.Error("creating rule task failed", "name", taskName, errors.Attr(err))
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error loading rules, previous rule set restored")
+		return err
 	}
 
 	for _, r := range newTask.Rules() {
@@ -1048,8 +1059,10 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
 		m.logger.ErrorContext(ctx, "failed to unmarshal rule from db", slog.String("rule.id", id.StringValue()), errors.Attr(err))
 		return nil, err
 	}
+	// a rule stored before selectedQueryName was required resolves it the way evaluation does
+	storedRule.RuleCondition.SelectedQuery = storedRule.RuleCondition.SelectedQueryName()
 
-	if err := json.Unmarshal([]byte(ruleStr), &storedRule); err != nil {
+	if err := storedRule.DecodeStrict(ruleStr); err != nil {
 		m.logger.ErrorContext(ctx, "failed to unmarshal patched rule with given id", slog.String("rule.id", id.StringValue()), errors.Attr(err))
 		return nil, err
 	}
@@ -1105,9 +1118,9 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
 // sends a test notification. returns alert count and error (if any)
 func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error) {
 	parsedRule := ruletypes.PostableRule{}
-	err := json.Unmarshal([]byte(ruleStr), &parsedRule)
+	err := parsedRule.DecodeStrict(ruleStr)
 	if err != nil {
-		return 0, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to unmarshal rule")
+		return 0, err
 	}
 	if err := parsedRule.Validate(); err != nil {
 		return 0, err

pkg/query-service/rules/manager_test_data.go

@@ -49,13 +49,13 @@ func ThresholdRuleAtLeastOnceValueAbove(target float64, recovery *float64) rulet
 		Annotations: map[string]string{
 			"value": "{{$value}}",
 		},
-		Version: "v5",
+		Version:       "v5",
+		SchemaVersion: ruletypes.SchemaVersionV2Alpha1,
 		RuleCondition: &ruletypes.RuleCondition{
-			MatchType:       ruletypes.AtleastOnce,
-			CompareOperator: ruletypes.ValueIsAbove,
-			Target:          &target,
+			SelectedQuery: "A",
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
+				PanelType: ruletypes.PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -108,12 +108,10 @@ func BuildPromAtLeastOnceValueAbove(target float64, recovery *float64) ruletypes
 		Annotations: map[string]string{
 			"value": "{{$value}}",
 		},
-		Version: "v5",
+		Version:       "v5",
+		SchemaVersion: ruletypes.SchemaVersionV2Alpha1,
 		RuleCondition: &ruletypes.RuleCondition{
-			MatchType:       ruletypes.AtleastOnce,
-			SelectedQuery:   "A",
-			CompareOperator: ruletypes.ValueIsAbove,
-			Target:          &target,
+			SelectedQuery: "A",
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				PanelType: ruletypes.PanelTypeGraph,
@@ -138,7 +136,6 @@ func BuildPromAtLeastOnceValueAbove(target float64, recovery *float64) ruletypes
 						RecoveryTarget:  recovery,
 						MatchType:       ruletypes.AtleastOnce,
 						CompareOperator: ruletypes.ValueIsAbove,
-						Channels:        []string{"slack"},
 					},
 				},
 			},

pkg/query-service/rules/prom_rule.go

@@ -23,7 +23,6 @@ import (
 
 type PromRule struct {
 	*BaseRule
-	version    string
 	prometheus prometheus.Prometheus
 }
 
@@ -47,7 +46,6 @@ func NewPromRule(
 
 	p := PromRule{
 		BaseRule:   baseRule,
-		version:    postableRule.Version,
 		prometheus: prometheus,
 	}
 
@@ -356,12 +354,10 @@ func (r *PromRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 
 func (r *PromRule) String() string {
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.name),
-		RuleCondition:     r.ruleCondition,
-		EvalWindow:        r.evalWindow,
-		Labels:            r.labels.Map(),
-		Annotations:       r.annotations.Map(),
-		PreferredChannels: r.preferredChannels,
+		AlertName:     valuer.NewDisplayName(r.name),
+		RuleCondition: r.ruleCondition,
+		Labels:        r.labels.Map(),
+		Annotations:   r.annotations.Map(),
 	}
 
 	byt, err := json.Marshal(ar)

pkg/query-service/rules/prom_rule_test.go

@@ -690,13 +690,11 @@ func TestPromRuleEval(t *testing.T) {
 	logger := instrumentationtest.New().Logger()
 
 	for idx, c := range cases {
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
 				{
+					Name:            "critical",
 					TargetValue:     &c.target,
 					MatchType:       c.matchType,
 					CompareOperator: c.compareOperator,
@@ -905,11 +903,7 @@ func TestPromRuleUnitCombinations(t *testing.T) {
 
 		promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{Timeout: 2 * time.Minute}, telemetryStore)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = ruletypes.MatchType(c.matchType)
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1198,11 +1192,7 @@ func TestMultipleThresholdPromRule(t *testing.T) {
 
 		promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{Timeout: 2 * time.Minute}, telemetryStore)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1259,6 +1249,7 @@ func TestMultipleThresholdPromRule(t *testing.T) {
 
 func TestPromRule_NoData(t *testing.T) {
 	evalTime := time.Now()
+	target := 200.0
 
 	postableRule := ruletypes.PostableRule{
 		AlertName: valuer.NewDisplayName("Test no data"),
@@ -1269,8 +1260,6 @@ func TestPromRule_NoData(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1282,7 +1271,7 @@ func TestPromRule_NoData(t *testing.T) {
 			},
 			Thresholds: &ruletypes.RuleThresholdData{
 				Kind: ruletypes.BasicThresholdKind,
-				Spec: ruletypes.BasicRuleThresholds{{Name: "Test no data"}},
+				Spec: ruletypes.BasicRuleThresholds{{Name: "Test no data", TargetValue: &target, CompareOperator: ruletypes.ValueIsAbove, MatchType: ruletypes.AtleastOnce}},
 			},
 		},
 	}
@@ -1365,10 +1354,7 @@ func TestPromRule_NoData_AbsentFor(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			AlertOnAbsent:   true,
-			Target:          &target,
+			AlertOnAbsent: true,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1491,8 +1477,6 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1562,9 +1546,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 	for _, c := range cases {
 		rc := postableRule.RuleCondition
 
-		rc.Target = &targetForNoAlert
+		target := &targetForNoAlert
 		if c.alertCondition {
-			rc.Target = &targetForAlert
+			target = &targetForAlert
 		}
 		rc.RequireMinPoints = c.requireMinPoints
 		rc.RequiredNumPoints = c.requiredNumPoints
@@ -1573,9 +1557,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			Spec: ruletypes.BasicRuleThresholds{
 				{
 					Name:            postableRule.AlertName.StringValue(),
-					TargetValue:     rc.Target,
-					MatchType:       rc.MatchType,
-					CompareOperator: rc.CompareOperator,
+					TargetValue:     target,
+					MatchType:       ruletypes.AtleastOnce,
+					CompareOperator: ruletypes.ValueIsAbove,
 				},
 			},
 		}

pkg/query-service/rules/rule.go

@@ -20,15 +20,12 @@ type Rule interface {
 	Annotations() ruletypes.Labels
 	Condition() *ruletypes.RuleCondition
 	EvalDelay() valuer.TextDuration
-	EvalWindow() valuer.TextDuration
 	HoldDuration() valuer.TextDuration
 	State() ruletypes.AlertState
 	ActiveAlerts() []*ruletypes.Alert
 	// ActiveAlertsLabelFP returns a map of active alert labels fingerprint
 	ActiveAlertsLabelFP() map[uint64]struct{}
 
-	PreferredChannels() []string
-
 	// Eval evaluates the rule at the given timestamp and returns the number of active alerts.
 	Eval(context.Context, time.Time) (int, error)
 	String() string

pkg/query-service/rules/threshold_rule.go

@@ -61,16 +61,16 @@ func (r *ThresholdRule) Type() ruletypes.RuleType {
 }
 
 func (r *ThresholdRule) prepareQueryRange(ctx context.Context, ts time.Time) (*qbtypes.QueryRangeRequest, error) {
+	startTs, endTs := r.Timestamps(ts)
+	start, end := startTs.UnixMilli(), endTs.UnixMilli()
+
 	r.logger.InfoContext(
 		ctx, "prepare query range request v5",
 		slog.Int64("ts", ts.UnixMilli()),
-		slog.Int64("eval_window", r.evalWindow.Milliseconds()),
+		slog.Int64("eval_window", end-start),
 		slog.Int64("eval_delay", r.evalDelay.Milliseconds()),
 	)
 
-	startTs, endTs := r.Timestamps(ts)
-	start, end := startTs.UnixMilli(), endTs.UnixMilli()
-
 	req := &qbtypes.QueryRangeRequest{
 		Start:       uint64(start),
 		End:         uint64(end),
@@ -455,12 +455,10 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 
 func (r *ThresholdRule) String() string {
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.name),
-		RuleCondition:     r.ruleCondition,
-		EvalWindow:        r.evalWindow,
-		Labels:            r.labels.Map(),
-		Annotations:       r.annotations.Map(),
-		PreferredChannels: r.preferredChannels,
+		AlertName:     valuer.NewDisplayName(r.name),
+		RuleCondition: r.ruleCondition,
+		Labels:        r.labels.Map(),
+		Annotations:   r.annotations.Map(),
 	}
 
 	byt, err := json.Marshal(ar)

pkg/query-service/rules/threshold_rule_test.go

@@ -63,6 +63,7 @@ func TestThresholdRuleEvalWithoutRecoveryTarget(t *testing.T) {
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
 				{
+					Name:            "critical",
 					TargetValue:     &c.target,
 					MatchType:       c.matchType,
 					CompareOperator: c.compareOperator,
@@ -171,10 +172,7 @@ func TestPrepareParamsForLogs(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 	}
 
@@ -183,9 +181,10 @@ func TestPrepareParamsForLogs(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				Name:            "critical",
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -239,10 +238,7 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 		Version: "v5",
 	}
@@ -252,9 +248,10 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				Name:            "critical",
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -304,10 +301,7 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 		Version: "v5",
 	}
@@ -317,9 +311,10 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				Name:            "critical",
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -366,10 +361,7 @@ func TestPrepareParamsForTraces(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 	}
 
@@ -378,9 +370,10 @@ func TestPrepareParamsForTraces(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				Name:            "critical",
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -470,6 +463,7 @@ func TestThresholdRuleLabelNormalization(t *testing.T) {
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
 				{
+					Name:            "critical",
 					TargetValue:     &c.target,
 					MatchType:       c.matchType,
 					CompareOperator: c.compareOperator,
@@ -653,11 +647,7 @@ func TestThresholdRuleUnitCombinations(t *testing.T) {
 			ExpectQuery(queryString).
 			WithArgs(nil, nil, nil, nil, nil, nil, nil, nil).
 			WillReturnRows(rows)
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -867,11 +857,7 @@ func TestThresholdRuleTracesLink(t *testing.T) {
 
 		querier := prepareQuerierForTraces(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -975,11 +961,7 @@ func TestThresholdRuleAITracesLink(t *testing.T) {
 
 		querier := prepareQuerierForAITraces(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1083,11 +1065,7 @@ func TestThresholdRuleLogsLink(t *testing.T) {
 
 		querier := prepareQuerierForLogs(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1256,11 +1234,7 @@ func TestMultipleThresholdRule(t *testing.T) {
 		querier, mockMetadataStore := prepareQuerierForMetrics(t, telemetryStore)
 		mockMetadataStore.TypeMap["signoz_calls_total"] = metrictypes.SumType
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1930,8 +1904,6 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
 				Queries: []qbtypes.QueryEnvelope{{
@@ -2050,7 +2022,6 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 		mockMetadataStore.TypeMap["signoz_calls_total"] = metrictypes.SumType
 
 		rc := postableRule.RuleCondition
-		rc.Target = &c.target
 		rc.RequireMinPoints = c.requireMinPoints
 		rc.RequiredNumPoints = c.requiredNumPoints
 		rc.Thresholds = &ruletypes.RuleThresholdData{
@@ -2059,8 +2030,8 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 				{
 					Name:            postableRule.AlertName.StringValue(),
 					TargetValue:     &c.target,
-					MatchType:       rc.MatchType,
-					CompareOperator: rc.CompareOperator,
+					MatchType:       ruletypes.AtleastOnce,
+					CompareOperator: ruletypes.ValueIsAbove,
 				},
 			},
 		}

pkg/ruler/handler.go

@@ -3,7 +3,6 @@ package ruler
 import "net/http"
 
 type Handler interface {
-	ListRules(http.ResponseWriter, *http.Request)
 	ListRulesV3(http.ResponseWriter, *http.Request)
 	GetRuleByID(http.ResponseWriter, *http.Request)
 	CreateRule(http.ResponseWriter, *http.Request)

pkg/ruler/signozruler/handler.go

@@ -25,24 +25,6 @@ func NewHandler(ruler ruler.Ruler) ruler.Handler {
 	return &handler{ruler: ruler}
 }
 
-func (handler *handler) ListRules(rw http.ResponseWriter, req *http.Request) {
-	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
-	defer cancel()
-
-	rules, err := handler.ruler.ListRuleStates(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	view := make([]*ruletypes.Rule, 0, len(rules.Rules))
-	for _, rule := range rules.Rules {
-		view = append(view, ruletypes.NewRule(rule))
-	}
-
-	render.Success(rw, http.StatusOK, view)
-}
-
 func (handler *handler) ListRulesV3(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
@@ -72,7 +54,7 @@ func (handler *handler) GetRuleByID(rw http.ResponseWriter, req *http.Request) {
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -111,7 +93,7 @@ func (handler *handler) CloneRuleByID(rw http.ResponseWriter, req *http.Request)
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -130,7 +112,7 @@ func (handler *handler) UpdateRuleByID(rw http.ResponseWriter, req *http.Request
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -156,7 +138,7 @@ func (handler *handler) DeleteRuleByID(rw http.ResponseWriter, req *http.Request
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -175,7 +157,7 @@ func (handler *handler) PatchRuleByID(rw http.ResponseWriter, req *http.Request)
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -279,7 +261,7 @@ func (handler *handler) GetDowntimeScheduleByID(rw http.ResponseWriter, req *htt
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -328,7 +310,7 @@ func (handler *handler) UpdateDowntimeScheduleByID(rw http.ResponseWriter, req *
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -358,7 +340,7 @@ func (handler *handler) DeleteDowntimeScheduleByID(rw http.ResponseWriter, req *
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -448,7 +430,7 @@ func (handler *handler) UpdateRuleView(rw http.ResponseWriter, req *http.Request
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 
@@ -484,7 +466,7 @@ func (handler *handler) DeleteRuleView(rw http.ResponseWriter, req *http.Request
 
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
 		return
 	}
 

pkg/signoz/provider.go

@@ -271,6 +271,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewRenameSavedViewDeprecatedTraceFieldsFactory(),
 		sqlmigration.NewAddDowntimeTuplesFactory(sqlstore),
 		sqlmigration.NewAddRuleTuplesFactory(sqlstore),
+		sqlmigration.NewMigrateRulesV1ToV2Alpha1Factory(sqlstore),
 	)
 }
 

pkg/sqlmigration/144_migrate_rules_v1_to_v2alpha1.go

@@ -0,0 +1,629 @@
+package sqlmigration
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"maps"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+const (
+	schemaVersionV2Alpha1  = "v2alpha1"
+	ruleTypeThreshold      = "threshold_rule"
+	ruleTypeProm           = "promql_rule"
+	ruleTypeAnomaly        = "anomaly_rule"
+	queryTypeBuilder       = "builder"
+	queryTypePromQL        = "promql"
+	queryTypeClickHouseSQL = "clickhouse_sql"
+	panelTypeGraph         = "graph"
+	alertTypeMetric        = "METRIC_BASED_ALERT"
+	alertTypeTraces        = "TRACES_BASED_ALERT"
+	alertTypeLogs          = "LOGS_BASED_ALERT"
+	signalLogs             = "logs"
+	signalTraces           = "traces"
+	compareOperatorBelow   = "2"
+	criticalThresholdName  = "critical"
+	labelSeverity          = "severity"
+	defaultEvalWindow      = "5m"
+	defaultFrequency       = "1m"
+)
+
+// The values the write path accepts; a migrated rule outside them is written
+// disabled, for the user to fix.
+var (
+	supportedCompareOperators = []string{"1", "above", ">", "2", "below", "<", "3", "equal", "eq", "=", "4", "not_equal", "not_eq", "!=", "5", "above_or_equal", "above_or_eq", ">=", "6", "below_or_equal", "below_or_eq", "<=", "7", "outside_bounds"}
+	supportedMatchTypes       = []string{"1", "at_least_once", "2", "all_the_times", "3", "on_average", "avg", "4", "in_total", "sum", "5", "last"}
+)
+
+// The values the write path accepts; a migrated row outside them cannot be
+// edited until the field is supplied, so the migration derives them.
+var (
+	supportedAlertTypes = []string{"METRIC_BASED_ALERT", "TRACES_BASED_ALERT", "LOGS_BASED_ALERT", "EXCEPTIONS_BASED_ALERT", "AI_TRACES_BASED_ALERT"}
+	supportedQueryTypes = []string{"builder", "clickhouse_sql", "promql"}
+	supportedPanelTypes = []string{"value", "table", "graph"}
+)
+
+type migrateRulesV1ToV2Alpha1 struct {
+	sqlstore sqlstore.SQLStore
+	logger   *slog.Logger
+}
+
+func NewMigrateRulesV1ToV2Alpha1Factory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("migrate_rules_v1_to_v2alpha1"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &migrateRulesV1ToV2Alpha1{sqlstore: sqlstore, logger: ps.Logger}, nil
+	})
+}
+
+func (migration *migrateRulesV1ToV2Alpha1) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+// Up rewrites every v1 rule in every org as v2alpha1 in place. A row that does
+// not decode, or a v1 rule that cannot be rewritten, is logged and left as is;
+// a failed write aborts the run and rolls back every org.
+func (migration *migrateRulesV1ToV2Alpha1) Up(ctx context.Context, _ *bun.DB) error {
+	return migration.sqlstore.RunInTxCtx(ctx, nil, func(ctx context.Context) error {
+		var orgIDs []string
+		if err := migration.sqlstore.BunDBCtx(ctx).NewSelect().Table("organizations").Column("id").Scan(ctx, &orgIDs); err != nil {
+			return err
+		}
+
+		for _, orgID := range orgIDs {
+			if err := migration.convertOrg(ctx, orgID); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func (migration *migrateRulesV1ToV2Alpha1) Down(context.Context, *bun.DB) error {
+	return nil
+}
+
+func (migration *migrateRulesV1ToV2Alpha1) convertOrg(ctx context.Context, orgID string) error {
+	db := migration.sqlstore.BunDBCtx(ctx)
+
+	type ruleRow struct {
+		bun.BaseModel `bun:"table:rule"`
+
+		ID    string `bun:"id,pk"`
+		OrgID string `bun:"org_id"`
+		Data  string `bun:"data"`
+	}
+
+	allRules := make([]*ruleRow, 0)
+	if err := db.NewSelect().Model(&allRules).Where("org_id = ?", orgID).Scan(ctx); err != nil {
+		return err
+	}
+
+	allRoutePolicies := make([]*routePolicyRow, 0)
+	if err := db.NewSelect().Model(&allRoutePolicies).Where("org_id = ?", orgID).Scan(ctx); err != nil {
+		return err
+	}
+	// the name is not unique; a v1 rule has one threshold so one row, and any
+	// duplicate is as good as another
+	routePolicyNameToRoute := make(map[string]*routePolicyRow)
+	for _, route := range allRoutePolicies {
+		routePolicyNameToRoute[route.Name] = route
+	}
+
+	var migrated, disabled, skipped, undecodable, unmigratable int
+	for _, storedRule := range allRules {
+		storedRuleData := new(postableRule)
+		if err := json.Unmarshal([]byte(storedRule.Data), storedRuleData); err != nil {
+			undecodable++
+			migration.logger.WarnContext(ctx, "failed to decode stored rule", slog.String("org_id", orgID), slog.String("rule_id", storedRule.ID), errors.Attr(err))
+			continue
+		}
+		if storedRuleData.SchemaVersion == schemaVersionV2Alpha1 {
+			skipped++
+			continue
+		}
+
+		storedRoute := routePolicyNameToRoute[storedRule.ID]
+		if err := validateRoute(storedRoute, storedRuleData.PreferredChannels); err != nil {
+			unmigratable++
+			migration.logger.WarnContext(ctx, "leaving rule at v1", slog.String("org_id", orgID), slog.String("rule_id", storedRule.ID), errors.Attr(err))
+			continue
+		}
+
+		convertedRule, convertedRoute := convertRule(storedRule.ID, storedRuleData, storedRoute)
+		if cause := convertedRule.disableIfNeverFired(); cause != "" {
+			disabled++
+			migration.logger.WarnContext(ctx, "migrating rule as disabled, it never fired in v1", slog.String("org_id", orgID), slog.String("rule_id", storedRule.ID), slog.String("cause", cause))
+		}
+
+		data, err := marshalUnescaped(convertedRule)
+		if err != nil {
+			return err
+		}
+		storedRule.Data = string(data)
+		if _, err := db.NewUpdate().Model(storedRule).Column("data").WherePK().Exec(ctx); err != nil {
+			return err
+		}
+		if convertedRoute != nil && convertedRoute.Expression != storedRoute.Expression {
+			if _, err := db.NewUpdate().Model(convertedRoute).Column("expression").WherePK().Exec(ctx); err != nil {
+				return err
+			}
+		}
+		migrated++
+	}
+
+	migration.logger.InfoContext(ctx, "migrated rules from v1 to v2alpha1", slog.String("org_id", orgID), slog.Int("total", len(allRules)), slog.Int("migrated", migrated), slog.Int("disabled", disabled), slog.Int("skipped", skipped), slog.Int("undecodable", undecodable), slog.Int("unmigratable", unmigratable))
+	return nil
+}
+
+// validateRoute checks the rule's route_policy row, named after the rule. A
+// rule that never had channels got no row from migration 049 and migrates with
+// none; a rule with preferred channels but no row would lose them, so it is
+// left at v1.
+func validateRoute(route *routePolicyRow, preferredChannels []string) error {
+	if route == nil && len(preferredChannels) > 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "no route_policy row for a rule with %d preferred channels", len(preferredChannels))
+	}
+	return nil
+}
+
+// convertRule returns a v2alpha1 copy of storedRuleData, derived in the order
+// the v1 decode derived the same values, with the rule's route_policy row as it
+// must be stored alongside. Version and source are left as stored. A nil
+// storedRoute is a rule that never had channels.
+func convertRule(ruleID string, storedRuleData *postableRule, storedRoute *routePolicyRow) (*postableRule, *routePolicyRow) {
+	channels := []string{}
+	if storedRoute != nil {
+		channels = storedRoute.Channels
+	}
+
+	rule := storedRuleData.clone()
+	rule.fillDurationDefaults()
+	convertedRoute := storedRoute
+	// a null condition is written back null: nothing derives from it, the v2
+	// read path rejects it as v1 did, and the list still shows the rule, disabled
+	if rule.RuleCondition != nil {
+		rule.deriveAlertType()
+		rule.deriveQueryType()
+		rule.repairPanelType()
+		rule.disableUnmetMinPoints()
+		rule.deriveRuleType()
+		rule.deriveSelectedQuery()
+		rule.negateAnomalyBelowTarget()
+		convertedRoute = rule.repairEmptySeverity(ruleID, storedRoute)
+		rule.relocateThreshold(channels)
+	}
+	rule.relocateEvaluation()
+	rule.synthesizeNotificationSettings()
+	rule.SchemaVersion = schemaVersionV2Alpha1
+	rule.clearV1Fields()
+
+	return rule, convertedRoute
+}
+
+type routePolicyRow struct {
+	bun.BaseModel `bun:"table:route_policy"`
+
+	ID         string   `bun:"id,pk"`
+	OrgID      string   `bun:"org_id"`
+	Name       string   `bun:"name"`
+	Expression string   `bun:"expression"`
+	Channels   []string `bun:"channels,type:jsonb"`
+}
+
+// postableRule mirrors PostableRule key for key, in its order. Keys the
+// crosswalk reads or writes are typed; the rest pass through as stored.
+type postableRule struct {
+	AlertName            json.RawMessage       `json:"alert,omitempty"`
+	AlertType            string                `json:"alertType"`
+	Description          json.RawMessage       `json:"description,omitempty"`
+	RuleType             string                `json:"ruleType,omitempty"`
+	EvalWindow           textDuration          `json:"evalWindow,omitzero"`
+	Frequency            textDuration          `json:"frequency,omitzero"`
+	RuleCondition        *ruleCondition        `json:"condition"`
+	Labels               map[string]string     `json:"labels,omitempty"`
+	Annotations          json.RawMessage       `json:"annotations,omitempty"`
+	Disabled             json.RawMessage       `json:"disabled,omitempty"`
+	Source               json.RawMessage       `json:"source,omitempty"`
+	PreferredChannels    []string              `json:"preferredChannels,omitempty"`
+	Version              json.RawMessage       `json:"version,omitempty"`
+	Evaluation           *evaluationEnvelope   `json:"evaluation,omitempty"`
+	SchemaVersion        string                `json:"schemaVersion,omitempty"`
+	NotificationSettings *notificationSettings `json:"notificationSettings,omitempty"`
+}
+
+type ruleCondition struct {
+	CompositeQuery    *compositeQuery `json:"compositeQuery"`
+	CompareOperator   string          `json:"op,omitempty"`
+	Target            *float64        `json:"target,omitempty"`
+	AlertOnAbsent     bool            `json:"alertOnAbsent,omitempty"`
+	AbsentFor         json.RawMessage `json:"absentFor,omitempty"`
+	MatchType         string          `json:"matchType,omitempty"`
+	TargetUnit        string          `json:"targetUnit,omitempty"`
+	Seasonality       string          `json:"seasonality,omitempty"`
+	SelectedQuery     string          `json:"selectedQueryName,omitempty"`
+	RequireMinPoints  json.RawMessage `json:"requireMinPoints,omitempty"`
+	RequiredNumPoints json.RawMessage `json:"requiredNumPoints,omitempty"`
+	Thresholds        *ruleThresholds `json:"thresholds,omitempty"`
+}
+
+type compositeQuery struct {
+	Queries   json.RawMessage `json:"queries,omitempty"`
+	PanelType string          `json:"panelType"`
+	QueryType string          `json:"queryType"`
+	Unit      json.RawMessage `json:"unit,omitempty"`
+}
+
+// ruleQueryEnvelope reads the envelope keys the derivations need.
+type ruleQueryEnvelope struct {
+	Type string `json:"type"`
+	Spec struct {
+		Name     string `json:"name"`
+		Signal   string `json:"signal"`
+		Disabled bool   `json:"disabled"`
+	} `json:"spec"`
+}
+
+type ruleThresholds struct {
+	Kind string           `json:"kind"`
+	Spec []basicThreshold `json:"spec"`
+}
+
+type basicThreshold struct {
+	Name            string   `json:"name"`
+	TargetValue     *float64 `json:"target"`
+	TargetUnit      string   `json:"targetUnit"`
+	RecoveryTarget  *float64 `json:"recoveryTarget"`
+	MatchType       string   `json:"matchType"`
+	CompareOperator string   `json:"op"`
+	Channels        []string `json:"channels"`
+}
+
+type evaluationEnvelope struct {
+	Kind string        `json:"kind"`
+	Spec rollingWindow `json:"spec"`
+}
+
+type rollingWindow struct {
+	EvalWindow textDuration `json:"evalWindow"`
+	Frequency  textDuration `json:"frequency"`
+}
+
+type notificationSettings struct {
+	Renotify  *renotify `json:"renotify,omitempty"`
+	UsePolicy bool      `json:"usePolicy"`
+}
+
+type renotify struct {
+	Enabled          bool         `json:"enabled"`
+	ReNotifyInterval textDuration `json:"interval,omitzero"`
+	AlertStates      []string     `json:"alertStates,omitzero"`
+}
+
+// clone copies what the conversion writes to: the rule, its condition, the
+// composite query and the labels. Raw keys share their bytes.
+func (rule *postableRule) clone() *postableRule {
+	cloned := *rule
+	if rule.RuleCondition != nil {
+		condition := *rule.RuleCondition
+		if condition.CompositeQuery != nil {
+			query := *condition.CompositeQuery
+			condition.CompositeQuery = &query
+		}
+		cloned.RuleCondition = &condition
+	}
+	cloned.Labels = maps.Clone(rule.Labels)
+	return &cloned
+}
+
+// disableIfNeverFired disables a rule v1 stored but could never fire: a
+// negative evalWindow or frequency, which is reset to its default since no
+// read of a rolling window accepts it, a null condition or compositeQuery, one
+// with no queries or with every query disabled, or a threshold with a null target or
+// an op or matchType outside the supported sets, which the v2 write path
+// rejects. It reads the relocated fields, so it runs after convertRule, and
+// returns the offending fields, or "" when the rule stays enabled.
+func (rule *postableRule) disableIfNeverFired() string {
+	var causes []string
+	window := &rule.Evaluation.Spec
+	if !window.EvalWindow.IsPositive() {
+		causes = append(causes, fmt.Sprintf("evalWindow %s is negative", window.EvalWindow))
+		window.EvalWindow = mustParseTextDuration(defaultEvalWindow)
+	}
+	if !window.Frequency.IsPositive() {
+		causes = append(causes, fmt.Sprintf("frequency %s is negative", window.Frequency))
+		window.Frequency = mustParseTextDuration(defaultFrequency)
+	}
+	switch {
+	case rule.RuleCondition == nil:
+		causes = append(causes, "condition is null")
+	case rule.RuleCondition.CompositeQuery == nil:
+		causes = append(causes, "condition.compositeQuery is null")
+	case len(rule.decodeQueryEnvelopes()) == 0:
+		causes = append(causes, "condition.compositeQuery.queries is empty")
+	case rule.RuleCondition.SelectedQuery == "":
+		causes = append(causes, "condition.selectedQueryName is omitted and every query is disabled")
+	}
+	if rule.RuleCondition != nil {
+		threshold := rule.RuleCondition.Thresholds.Spec[0]
+		switch {
+		case threshold.TargetValue == nil:
+			causes = append(causes, "condition.target is null")
+		case !slices.Contains(supportedCompareOperators, threshold.CompareOperator):
+			causes = append(causes, fmt.Sprintf("condition.op: unsupported value %q", threshold.CompareOperator))
+		case !slices.Contains(supportedMatchTypes, threshold.MatchType):
+			causes = append(causes, fmt.Sprintf("condition.matchType: unsupported value %q", threshold.MatchType))
+		}
+	}
+	if len(causes) == 0 {
+		return ""
+	}
+	rule.Disabled = json.RawMessage("true")
+	return strings.Join(causes, ", ")
+}
+
+func (rule *postableRule) fillDurationDefaults() {
+	if rule.EvalWindow.IsZero() {
+		rule.EvalWindow = mustParseTextDuration(defaultEvalWindow)
+	}
+	if rule.Frequency.IsZero() {
+		rule.Frequency = mustParseTextDuration(defaultFrequency)
+	}
+}
+
+func (rule *postableRule) deriveAlertType() {
+	if slices.Contains(supportedAlertTypes, rule.AlertType) {
+		return
+	}
+	// promql, clickhouse and formula queries carry no signal; they alert on metrics
+	rule.AlertType = alertTypeMetric
+	for _, envelope := range rule.decodeQueryEnvelopes() {
+		switch envelope.Spec.Signal {
+		case signalLogs:
+			rule.AlertType = alertTypeLogs
+			return
+		case signalTraces:
+			rule.AlertType = alertTypeTraces
+			return
+		}
+	}
+}
+
+func (rule *postableRule) deriveQueryType() {
+	query := rule.RuleCondition.CompositeQuery
+	if query == nil || slices.Contains(supportedQueryTypes, query.QueryType) {
+		return
+	}
+	envelopes := rule.decodeQueryEnvelopes()
+	if len(envelopes) == 0 {
+		return
+	}
+	// a promql or clickhouse_sql envelope spells its type like the composite query does; every other envelope is a builder one
+	switch envelopes[0].Type {
+	case queryTypePromQL, queryTypeClickHouseSQL:
+		query.QueryType = envelopes[0].Type
+	default:
+		query.QueryType = queryTypeBuilder
+	}
+}
+
+func (rule *postableRule) repairPanelType() {
+	query := rule.RuleCondition.CompositeQuery
+	// nothing reads panelType; both alert forms write graph
+	if query != nil && !slices.Contains(supportedPanelTypes, query.PanelType) {
+		query.PanelType = panelTypeGraph
+	}
+}
+
+func (rule *postableRule) disableUnmetMinPoints() {
+	condition := rule.RuleCondition
+	if string(condition.RequireMinPoints) != "true" {
+		return
+	}
+	points := 0.0
+	if len(condition.RequiredNumPoints) > 0 {
+		if err := json.Unmarshal(condition.RequiredNumPoints, &points); err != nil {
+			return
+		}
+	}
+	if points > 0 {
+		return
+	}
+	// zero required points is a check every series passes
+	condition.RequireMinPoints = json.RawMessage("false")
+}
+
+func (rule *postableRule) decodeQueryEnvelopes() []ruleQueryEnvelope {
+	query := rule.RuleCondition.CompositeQuery
+	if query == nil {
+		return nil
+	}
+	var envelopes []ruleQueryEnvelope
+	if err := json.Unmarshal(query.Queries, &envelopes); err != nil {
+		return nil
+	}
+	return envelopes
+}
+
+func (rule *postableRule) deriveRuleType() {
+	query := rule.RuleCondition.CompositeQuery
+	if query == nil {
+		return
+	}
+	switch query.QueryType {
+	case queryTypeBuilder, queryTypeClickHouseSQL:
+		if rule.RuleType == "" {
+			rule.RuleType = ruleTypeThreshold
+		}
+	case queryTypePromQL:
+		rule.RuleType = ruleTypeProm
+	}
+}
+
+// deriveSelectedQuery fills an omitted selectedQueryName the way v1 resolved it
+// at evaluation: F1 when enabled, else the enabled query with the highest name.
+func (rule *postableRule) deriveSelectedQuery() {
+	condition := rule.RuleCondition
+	if condition.SelectedQuery != "" {
+		return
+	}
+	for _, envelope := range rule.decodeQueryEnvelopes() {
+		if envelope.Spec.Disabled {
+			continue
+		}
+		if envelope.Spec.Name == "F1" {
+			condition.SelectedQuery = "F1"
+			return
+		}
+		condition.SelectedQuery = max(condition.SelectedQuery, envelope.Spec.Name)
+	}
+}
+
+// negateAnomalyBelowTarget stores "below 3" as -3, since anomaly scores are
+// signed. Only the raw "2" negates; "below" and "<" keep the sign the rule
+// evaluates with today.
+func (rule *postableRule) negateAnomalyBelowTarget() {
+	condition := rule.RuleCondition
+	if rule.RuleType != ruleTypeAnomaly || condition.CompareOperator != compareOperatorBelow || condition.Target == nil {
+		return
+	}
+	negated := -*condition.Target
+	condition.Target = &negated
+}
+
+// repairEmptySeverity rewrites a severity of "" as critical in labels and in
+// the route expression that matches alerts on it, since a threshold named ""
+// fails every later read. It returns storedRoute, or a copy with the new
+// expression.
+func (rule *postableRule) repairEmptySeverity(ruleID string, storedRoute *routePolicyRow) *routePolicyRow {
+	if severity, ok := rule.Labels[labelSeverity]; !ok || severity != "" {
+		return storedRoute
+	}
+	rule.Labels[labelSeverity] = criticalThresholdName
+	if storedRoute == nil {
+		return nil
+	}
+	route := *storedRoute
+	route.Expression = fmt.Sprintf(`threshold.name == "%s" && ruleId == "%s"`, criticalThresholdName, ruleID)
+	return &route
+}
+
+func (rule *postableRule) relocateThreshold(channels []string) {
+	thresholdName := criticalThresholdName
+	if severity, ok := rule.Labels[labelSeverity]; ok {
+		thresholdName = severity
+	}
+
+	condition := rule.RuleCondition
+	condition.Thresholds = &ruleThresholds{
+		Kind: "basic",
+		Spec: []basicThreshold{{
+			Name:            thresholdName,
+			TargetValue:     condition.Target,
+			TargetUnit:      condition.TargetUnit,
+			MatchType:       condition.MatchType,
+			CompareOperator: condition.CompareOperator,
+			Channels:        channels,
+		}},
+	}
+}
+
+func (rule *postableRule) relocateEvaluation() {
+	rule.Evaluation = &evaluationEnvelope{
+		Kind: "rolling",
+		Spec: rollingWindow{EvalWindow: rule.EvalWindow, Frequency: rule.Frequency},
+	}
+}
+
+func (rule *postableRule) synthesizeNotificationSettings() {
+	alertStates := []string{"firing"}
+	if rule.RuleCondition != nil && rule.RuleCondition.AlertOnAbsent {
+		alertStates = append(alertStates, "nodata")
+	}
+	rule.NotificationSettings = &notificationSettings{
+		Renotify: &renotify{
+			Enabled:          true,
+			ReNotifyInterval: mustParseTextDuration("4h"),
+			AlertStates:      alertStates,
+		},
+		UsePolicy: false,
+	}
+}
+
+func (rule *postableRule) clearV1Fields() {
+	rule.EvalWindow = textDuration{}
+	rule.Frequency = textDuration{}
+	rule.PreferredChannels = nil
+	if condition := rule.RuleCondition; condition != nil {
+		condition.Target = nil
+		condition.CompareOperator = ""
+		condition.MatchType = ""
+		condition.TargetUnit = ""
+	}
+}
+
+// textDuration decodes a duration the way the app's TextDuration does, a
+// string or a number of nanoseconds, and writes a string back in its stored
+// spelling.
+type textDuration struct {
+	text  string
+	value time.Duration
+}
+
+func mustParseTextDuration(text string) textDuration {
+	value, err := time.ParseDuration(text)
+	if err != nil {
+		panic(err)
+	}
+	return textDuration{text: text, value: value}
+}
+
+func (d textDuration) IsZero() bool {
+	return d.value == 0
+}
+
+func (d textDuration) IsPositive() bool {
+	return d.value > 0
+}
+
+func (d textDuration) String() string {
+	if d.text != "" {
+		return d.text
+	}
+	return d.value.String()
+}
+
+func (d textDuration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+func (d *textDuration) UnmarshalJSON(data []byte) error {
+	var raw any
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+	switch value := raw.(type) {
+	case float64:
+		*d = textDuration{value: time.Duration(value)}
+		return nil
+	case string:
+		parsed, err := time.ParseDuration(value)
+		if err != nil {
+			return err
+		}
+		*d = textDuration{text: value, value: parsed}
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid duration %s", data)
+	}
+}

pkg/types/alertmanagertypes/config.go

@@ -619,10 +619,6 @@ type ConfigStore interface {
 
 	// ListAllChannels returns the list of channels for all organizations.
 	ListAllChannels(context.Context) ([]*Channel, error)
-
-	// GetMatchers gets a list of matchers per organization.
-	// Matchers is an array of ruleId to receiver names.
-	GetMatchers(context.Context, string) (map[string][]string, error)
 }
 
 // MarshalSecretValue if set to true will expose Secret type

pkg/types/querybuildertypes/querybuildertypesv5/cached.go

@@ -43,23 +43,6 @@ func (c *CachedBucket) Touches(other *CachedBucket) bool {
 	return c.StartMs <= other.EndMs && other.StartMs <= c.EndMs
 }
 
-// ProrateStatsToWindow returns the share of the stats for the part of the
-// bucket inside [startMs, endMs).
-func (c *CachedBucket) ProrateStatsToWindow(startMs, endMs uint64) ExecStats {
-	return c.Stats.prorate(overlapMs(c.StartMs, c.EndMs, startMs, endMs), c.EndMs-c.StartMs)
-}
-
-// ProrateStatsToUnqueried returns the share of the stats for the part of the
-// bucket no queried range covers.
-func (c *CachedBucket) ProrateStatsToUnqueried(execStatsForQueriedTimeRanges map[TimeRange]ExecStats) ExecStats {
-	widthMs := c.EndMs - c.StartMs
-	queriedMs := uint64(0)
-	for queried := range execStatsForQueriedTimeRanges {
-		queriedMs += overlapMs(c.StartMs, c.EndMs, queried.From, queried.To)
-	}
-	return c.Stats.prorate(widthMs-min(queriedMs, widthMs), widthMs)
-}
-
 // CachedData represents the full cached data for a query.
 type CachedData struct {
 	Buckets  []*CachedBucket `json:"buckets"`
@@ -105,7 +88,7 @@ func (c *CachedData) Cost() int64 {
 	return size
 }
 
-func (r *Result) SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs uint64, execStatsForQueriedTimeRanges map[TimeRange]ExecStats) ([]*CachedBucket, error) {
+func (r *Result) SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs uint64) ([]*CachedBucket, error) {
 	tsData, ok := r.Value.(*TimeSeriesData)
 	if !ok || tsData == nil {
 		return nil, errors.NewInternalf(errors.CodeInternal, "result of type %s cannot be bucketed", r.Type.StringValue())
@@ -128,39 +111,18 @@ func (r *Result) SplitIntoCacheCellBuckets(startMs, endMs, cellWidthMs uint64, e
 		if err != nil {
 			return nil, err
 		}
-		// A slice costs what was queried inside it; the rest of the result came
-		// out of the cache and is costed there already
-		sliceStats := ExecStats{StepIntervals: maps.Clone(r.Stats.StepIntervals)}
-		for queried, stats := range execStatsForQueriedTimeRanges {
-			queriedMs := overlapMs(from, to, queried.From, queried.To)
-			if queriedMs == 0 {
-				continue
-			}
-			share := stats.prorate(queriedMs, queried.To-queried.From)
-			sliceStats.RowsScanned += share.RowsScanned
-			sliceStats.BytesScanned += share.BytesScanned
-			sliceStats.DurationMS += share.DurationMS
-		}
 		cellBuckets = append(cellBuckets, &CachedBucket{
 			StartMs: from,
 			EndMs:   to,
 			Type:    r.Type,
 			Value:   value,
-			Stats:   sliceStats,
+			Stats:   r.Stats.prorate(to-from, endMs-startMs),
 		})
 		from = to
 	}
 	return cellBuckets, nil
 }
 
-// overlapMs is the length of [aFromMs, aToMs) ∩ [bFromMs, bToMs).
-func overlapMs(aFromMs, aToMs, bFromMs, bToMs uint64) uint64 {
-	if fromMs, toMs := max(aFromMs, bFromMs), min(aToMs, bToMs); fromMs < toMs {
-		return toMs - fromMs
-	}
-	return 0
-}
-
 // prorate returns the share of the stats that partMs out of wholeMs of the
 // scanned window accounts for.
 func (e ExecStats) prorate(partMs, wholeMs uint64) ExecStats {

pkg/types/rulestatehistorytypes/query.go

@@ -32,5 +32,10 @@ func (q *Query) Validate() error {
 	if q.Order != qbtypes.OrderDirectionAsc && q.Order != qbtypes.OrderDirectionDesc {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "order must be asc or desc")
 	}
+	if !q.State.IsZero() {
+		if err := q.State.Validate(); err != nil {
+			return err
+		}
+	}
 	return nil
 }

pkg/types/ruletypes/alert_state.go

@@ -1,6 +1,9 @@
 package ruletypes
 
-import "github.com/SigNoz/signoz/pkg/valuer"
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
 
 type AlertState struct {
 	valuer.String
@@ -26,6 +29,15 @@ func (AlertState) Enum() []any {
 	}
 }
 
+func (a AlertState) Validate() error {
+	switch a {
+	case StateInactive, StatePending, StateRecovering, StateFiring, StateNoData, StateDisabled:
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "state: unsupported value %q; must be one of inactive, pending, recovering, firing, nodata, disabled", a.StringValue())
+	}
+}
+
 var alertStateSeverity = map[AlertState]int{
 	StateInactive:   0,
 	StatePending:    1,

pkg/types/ruletypes/alerting.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -77,6 +78,15 @@ func (PanelType) Enum() []any {
 	}
 }
 
+func (p PanelType) Validate() error {
+	switch p {
+	case PanelTypeValue, PanelTypeTable, PanelTypeGraph:
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.panelType: unsupported value %q; must be one of value, table, graph", p.StringValue())
+	}
+}
+
 // Note: this is used to represent the state of the alert query
 // i.e the active tab which should be used to represent the selection
 
@@ -99,6 +109,15 @@ func (QueryType) Enum() []any {
 	}
 }
 
+func (q QueryType) Validate() error {
+	switch q {
+	case QueryTypeBuilder, QueryTypeClickHouseSQL, QueryTypePromQL:
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.queryType: unsupported value %q; must be one of builder, clickhouse_sql, promql", q.StringValue())
+	}
+}
+
 type AlertCompositeQuery struct {
 	Queries []qbtypes.QueryEnvelope `json:"queries" required:"true" description:"The queries to evaluate, at least one. Every envelope type must match queryType: builder_query and builder_formula for builder, promql for promql, clickhouse_sql for clickhouse_sql."`
 
@@ -109,18 +128,13 @@ type AlertCompositeQuery struct {
 
 type RuleCondition struct {
 	CompositeQuery    *AlertCompositeQuery `json:"compositeQuery" required:"true" description:"The queries whose result is compared against the thresholds."`
-	CompareOperator   CompareOperator      `json:"op,omitzero" description:"schemaVersion v1 only: how the value is compared with target. Accepted as above, below, equal, not_equal, above_or_equal, below_or_equal or outside_bounds, their symbols, or the legacy codes as strings, '1' to '7'. Required for v1; v2alpha1 sets op on each threshold."`
-	Target            *float64             `json:"target,omitempty" format:"double" description:"schemaVersion v1 only: the value compared against, in targetUnit. Required for v1; v2alpha1 sets target on each threshold."`
-	AlertOnAbsent     bool                 `json:"alertOnAbsent,omitempty" description:"Whether to fire a nodata alert when the query returns no data. Defaults to false."`
-	AbsentFor         uint64               `json:"absentFor,omitempty" description:"How many minutes without data pass before the nodata alert fires. Ignored unless alertOnAbsent is true."`
-	MatchType         MatchType            `json:"matchType,omitzero" description:"schemaVersion v1 only: which points in the window must satisfy op. Accepted as at_least_once, all_the_times, on_average, in_total or last, their aliases avg and sum, or the legacy codes as strings, '1' to '5'. Required for v1; v2alpha1 sets matchType on each threshold."`
-	TargetUnit        string               `json:"targetUnit,omitempty" description:"schemaVersion v1 only: the unit of target, such as percent or ms. Converted to compositeQuery.unit before comparison when the two differ."`
-	Algorithm         string               `json:"algorithm,omitempty" description:"anomaly_rule only: the anomaly detection algorithm. The supported value is standard."`
+	AlertOnAbsent     bool                 `json:"alertOnAbsent" description:"Whether to fire a nodata alert when the query returns no data. Defaults to false."`
+	AbsentFor         uint64               `json:"absentFor" description:"How many minutes without data pass before the nodata alert fires. Ignored unless alertOnAbsent is true."`
 	Seasonality       Seasonality          `json:"seasonality,omitzero" description:"anomaly_rule only: the seasonal period the history is compared against, hourly, daily or weekly."`
-	SelectedQuery     string               `json:"selectedQueryName,omitempty" required:"true" description:"The name of the query whose result is evaluated, such as A or F1. Must match a query in compositeQuery."`
+	SelectedQuery     string               `json:"selectedQueryName" required:"true" description:"The name of the query whose result is evaluated, such as A or F1. Must match a query in compositeQuery."`
 	RequireMinPoints  bool                 `json:"requireMinPoints,omitempty" description:"Whether a series is skipped until it has at least requiredNumPoints points in the window. Defaults to false."`
 	RequiredNumPoints int                  `json:"requiredNumPoints,omitempty" description:"The minimum number of points a series needs before it is evaluated. Must be greater than 0 when requireMinPoints is true."`
-	Thresholds        *RuleThresholdData   `json:"thresholds,omitempty" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
+	Thresholds        *RuleThresholdData   `json:"thresholds" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
 }
 
 func (rc *RuleCondition) SelectedQueryName() string {

pkg/types/ruletypes/api_params.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"slices"
+	"strings"
 	"time"
 	"unicode/utf8"
 
@@ -12,6 +13,7 @@ import (
 	"github.com/swaggest/jsonschema-go"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -49,7 +51,6 @@ func (t AlertType) BuilderQueryType() qbtypes.QueryType {
 }
 
 const (
-	DefaultSchemaVersion  = "v1"
 	SchemaVersionV2Alpha1 = "v2alpha1"
 )
 
@@ -61,12 +62,10 @@ const (
 
 // PostableRule is used to create alerting rule from HTTP api.
 type PostableRule struct {
-	AlertName   valuer.DisplayName  `json:"alert" required:"true" description:"The display name of the alert rule."`
-	AlertType   AlertType           `json:"alertType" required:"true" description:"The signal the rule evaluates: METRIC_BASED_ALERT, TRACES_BASED_ALERT, LOGS_BASED_ALERT, EXCEPTIONS_BASED_ALERT or AI_TRACES_BASED_ALERT."`
-	Description string              `json:"description,omitempty" description:"A human readable description of what the rule monitors."`
-	RuleType    RuleType            `json:"ruleType" required:"true" description:"The evaluation strategy: threshold_rule compares against thresholds, promql_rule evaluates a PromQL expression, anomaly_rule scores deviation from seasonal history. Defaults to threshold_rule for builder and clickhouse_sql queries and is forced to promql_rule for promql queries."`
-	EvalWindow  valuer.TextDuration `json:"evalWindow,omitzero" description:"The lookback window as a Go duration such as 5m. Only read when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec instead."`
-	Frequency   valuer.TextDuration `json:"frequency,omitzero" description:"How often the rule is evaluated, as a Go duration such as 1m. Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set it in evaluation.spec instead."`
+	AlertName   valuer.DisplayName `json:"alert" required:"true" description:"The display name of the alert rule."`
+	AlertType   AlertType          `json:"alertType" required:"true" description:"The signal the rule evaluates: METRIC_BASED_ALERT, TRACES_BASED_ALERT, LOGS_BASED_ALERT, EXCEPTIONS_BASED_ALERT or AI_TRACES_BASED_ALERT."`
+	Description string             `json:"description,omitempty" description:"A human readable description of what the rule monitors."`
+	RuleType    RuleType           `json:"ruleType" required:"true" description:"The evaluation strategy: threshold_rule compares against thresholds, promql_rule evaluates a PromQL expression, anomaly_rule scores deviation from seasonal history. Defaults to threshold_rule for builder and clickhouse_sql queries and is forced to promql_rule for promql queries."`
 
 	RuleCondition *RuleCondition    `json:"condition" required:"true" description:"The query to evaluate and the thresholds applied to its result."`
 	Labels        map[string]string `json:"labels,omitempty" description:"Labels attached to every alert the rule fires. Keys match [a-zA-Z_.][a-zA-Z0-9_.]*; values may use Go templates such as {{$labels.service_name}}. severity is the conventional routing label."`
@@ -76,14 +75,12 @@ type PostableRule struct {
 
 	Source string `json:"source,omitempty" description:"The URL of the page the rule was created from. Informational; it is not used for evaluation."`
 
-	PreferredChannels []string `json:"preferredChannels,omitempty" description:"The displayName of each notification channel to notify, for schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries its own channels."`
-
 	Version string `json:"version" description:"The query payload version. Nothing reads it."`
 
-	Evaluation    *EvaluationEnvelope `json:"evaluation,omitempty" required:"true" description:"The evaluation window, as a kind and spec."`
-	SchemaVersion string              `json:"schemaVersion,omitempty" required:"true" enum:"v2alpha1" description:"The rule payload schema."`
+	Evaluation    *EvaluationEnvelope `json:"evaluation" required:"true" description:"The evaluation window, as a kind and spec."`
+	SchemaVersion string              `json:"schemaVersion" required:"true" enum:"v2alpha1" description:"The rule payload schema."`
 
-	NotificationSettings *NotificationSettings `json:"notificationSettings,omitempty" required:"true" description:"Grouping, re-notification and routing behaviour."`
+	NotificationSettings *NotificationSettings `json:"notificationSettings" required:"true" description:"Grouping, re-notification and routing behaviour."`
 }
 
 type NotificationSettings struct {
@@ -228,101 +225,15 @@ func (ns *NotificationSettings) UnmarshalJSON(data []byte) error {
 // processRuleDefaults applies the default values
 // for the rule options that are blank or unset.
 func (r *PostableRule) processRuleDefaults() {
-	if r.SchemaVersion == "" {
-		r.SchemaVersion = DefaultSchemaVersion
-	}
-
-	// TODO(srikanthccv): remove as this is now a legacy field
-	if r.Version == "" {
-		r.Version = "v5"
-	}
-
-	// v2alpha1 uses the Evaluation envelope for window/frequency;
-	// only default top-level fields for v1.
-	if r.SchemaVersion != SchemaVersionV2Alpha1 {
-		if r.EvalWindow.IsZero() {
-			r.EvalWindow = valuer.MustParseTextDuration("5m")
-		}
-
-		if r.Frequency.IsZero() {
-			r.Frequency = valuer.MustParseTextDuration("1m")
-		}
-	}
-
 	if r.RuleCondition != nil && r.RuleCondition.CompositeQuery != nil {
 		switch r.RuleCondition.CompositeQuery.QueryType {
-		case QueryTypeBuilder:
+		case QueryTypeBuilder, QueryTypeClickHouseSQL:
 			if r.RuleType.IsZero() {
 				r.RuleType = RuleTypeThreshold
 			}
 		case QueryTypePromQL:
 			r.RuleType = RuleTypeProm
 		}
-
-		if r.SchemaVersion == DefaultSchemaVersion {
-			thresholdName := CriticalThresholdName
-			if r.Labels != nil {
-				if severity, ok := r.Labels["severity"]; ok {
-					thresholdName = severity
-				}
-			}
-
-			// For anomaly detection with ValueIsBelow, negate the target
-			targetValue := r.RuleCondition.Target
-			if r.RuleType == RuleTypeAnomaly && r.RuleCondition.CompareOperator == ValueIsBelow && targetValue != nil {
-				negated := -1 * *targetValue
-				targetValue = &negated
-			}
-
-			thresholdData := RuleThresholdData{
-				Kind: BasicThresholdKind,
-				Spec: BasicRuleThresholds{{
-					Name:            thresholdName,
-					TargetUnit:      r.RuleCondition.TargetUnit,
-					TargetValue:     targetValue,
-					MatchType:       r.RuleCondition.MatchType,
-					CompareOperator: r.RuleCondition.CompareOperator,
-					Channels:        r.PreferredChannels,
-				}},
-			}
-			r.RuleCondition.Thresholds = &thresholdData
-			r.Evaluation = &EvaluationEnvelope{RollingEvaluation, RollingWindow{EvalWindow: r.EvalWindow, Frequency: r.Frequency}}
-			r.NotificationSettings = &NotificationSettings{
-				Renotify: &Renotify{
-					Enabled:          true,
-					ReNotifyInterval: valuer.MustParseTextDuration("4h"),
-					AlertStates:      []AlertState{StateFiring},
-				},
-			}
-			if r.RuleCondition.AlertOnAbsent {
-				r.NotificationSettings.Renotify.AlertStates = append(r.NotificationSettings.Renotify.AlertStates, StateNoData)
-			}
-		}
-	}
-}
-
-func (r *PostableRule) MarshalJSON() ([]byte, error) {
-	type Alias PostableRule
-
-	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
 	}
 }
 
@@ -336,6 +247,20 @@ func (r *PostableRule) UnmarshalJSON(bytes []byte) error {
 	return r.validate()
 }
 
+func (r *PostableRule) DecodeStrict(ruleStr string) error {
+	err := json.Unmarshal([]byte(ruleStr), r)
+	if err == nil {
+		// the alias has no UnmarshalJSON, so a strict pass sees every key the rule has no field for
+		type plainRule PostableRule
+		return binding.JSON.BindBody(strings.NewReader(ruleStr), new(plainRule), binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("alert rule"))
+	}
+	if errors.Ast(err, errors.TypeInvalidInput) {
+		return err
+	}
+	// a syntax error is raised before any UnmarshalJSON runs, so it is the one untyped error
+	return errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to parse json: %v", err)
+}
+
 var _ jsonschema.Preparer = PostableRule{}
 
 // PrepareJSONSchema marks version and source deprecated: nothing reads them,
@@ -376,10 +301,6 @@ func (r *PostableRule) validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.Version != "v5" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
-	}
-
 	for k, v := range r.Labels {
 		if !isValidLabelName(k) {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid label name: %s", k))
@@ -423,11 +344,9 @@ func (r *PostableRule) Validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.Version != "v5" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
-	}
-
-	if r.AlertType != "" {
+	if r.AlertType == "" {
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "alertType: field is required"))
+	} else {
 		switch r.AlertType {
 		case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces:
 		default:
@@ -452,6 +371,12 @@ func (r *PostableRule) Validate() error {
 	if r.RuleCondition.CompositeQuery == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery: field is required"))
 	} else {
+		if err := r.RuleCondition.CompositeQuery.QueryType.Validate(); err != nil {
+			errs = append(errs, err)
+		}
+		if err := r.RuleCondition.CompositeQuery.PanelType.Validate(); err != nil {
+			errs = append(errs, err)
+		}
 		if len(r.RuleCondition.CompositeQuery.Queries) == 0 {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.queries: must have at least one query"))
 		} else {
@@ -462,7 +387,9 @@ func (r *PostableRule) Validate() error {
 		}
 	}
 
-	if r.RuleCondition.SelectedQuery != "" && r.RuleCondition.CompositeQuery != nil && len(r.RuleCondition.CompositeQuery.Queries) > 0 {
+	if r.RuleCondition.SelectedQuery == "" {
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.selectedQueryName: field is required"))
+	} else if r.RuleCondition.CompositeQuery != nil && len(r.RuleCondition.CompositeQuery.Queries) > 0 {
 		found := false
 		for _, query := range r.RuleCondition.CompositeQuery.Queries {
 			if query.GetQueryName() == r.RuleCondition.SelectedQuery {
@@ -514,74 +441,43 @@ func (r *PostableRule) Validate() error {
 
 func (r *PostableRule) validateSchemaVersion() []error {
 	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		return r.validateV1()
 	case SchemaVersionV2Alpha1:
 		return r.validateV2Alpha1()
 	default:
 		return []error{errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"schemaVersion: unsupported value %q; must be one of %q, %q",
-			r.SchemaVersion, DefaultSchemaVersion, SchemaVersionV2Alpha1)}
+			"schemaVersion: unsupported value %q; must be %q",
+			r.SchemaVersion, SchemaVersionV2Alpha1)}
 	}
 }
 
-func (r *PostableRule) validateV1() []error {
-	var errs []error
-
-	if r.RuleCondition.Target == nil {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.target: field is required for schemaVersion %q", DefaultSchemaVersion))
-	}
-	if r.RuleCondition.CompareOperator.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.op: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.CompareOperator.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-	if r.RuleCondition.MatchType.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.matchType: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.MatchType.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-
-	return errs
-}
-
 func (r *PostableRule) validateV2Alpha1() []error {
 	var errs []error
 
-	// TODO(srikanthccv): reject v1-only fields?
-	// if r.RuleCondition.Target != nil {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.target: field is not used in schemaVersion %q; set target in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.CompareOperator.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.op: field is not used in schemaVersion %q; set op in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.MatchType.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.matchType: field is not used in schemaVersion %q; set matchType in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if len(r.PreferredChannels) > 0 {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"preferredChannels: field is not used in schemaVersion %q; set channels in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-
 	// Require v2alpha1-specific fields
 	if r.RuleCondition.Thresholds == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
 			"condition.thresholds: field is required for schemaVersion %q", SchemaVersionV2Alpha1))
+	} else if threshold, err := r.RuleCondition.Thresholds.GetRuleThreshold(); err == nil {
+		if err := threshold.Validate(); err != nil {
+			errs = append(errs, err)
+		}
+		if thresholds, ok := threshold.(BasicRuleThresholds); ok {
+			if err := thresholds.validateUniqueNames(); err != nil {
+				errs = append(errs, err)
+			}
+			if err := thresholds.validateRecoveryTargets(); err != nil {
+				errs = append(errs, err)
+			}
+		}
 	}
 
 	if r.Evaluation == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
 			"evaluation: field is required for schemaVersion %q", SchemaVersionV2Alpha1))
+	} else if evaluation, err := r.Evaluation.GetEvaluation(); err == nil {
+		if err := evaluation.validateDurationText(); err != nil {
+			errs = append(errs, err)
+		}
 	}
 	if r.NotificationSettings == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
@@ -591,11 +487,24 @@ func (r *PostableRule) validateV2Alpha1() []error {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
 				"notificationSettings.renotify.interval: must be a positive duration when renotify is enabled"))
 		}
+		if r.NotificationSettings.Renotify != nil {
+			if err := validateDurationText("notificationSettings.renotify.interval", r.NotificationSettings.Renotify.ReNotifyInterval); err != nil {
+				errs = append(errs, err)
+			}
+		}
 	}
 
 	return errs
 }
 
+// validateDurationText rejects a bare number, which decodes as nanoseconds.
+func validateDurationText(field string, duration valuer.TextDuration) error {
+	if duration.IsZero() || duration.HasText() {
+		return nil
+	}
+	return errors.NewInvalidInputf(errors.CodeInvalidInput, "%s: must be a duration string such as \"5m\"", field)
+}
+
 func testTemplateParsing(rl *PostableRule) (errs []error) {
 	if rl.AlertName.IsZero() {
 		// Not an alerting rule.
@@ -656,31 +565,6 @@ type GettableRule struct {
 	UpdatedBy *string   `json:"updateBy" nullable:"true" description:"The identifier of the user who last updated the rule."`
 }
 
-func (g *GettableRule) MarshalJSON() ([]byte, error) {
-	type Alias GettableRule
-
-	switch g.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	}
-}
-
 // Rule is the v2 API read model for an alerting rule. It aligns audit fields
 // with the canonical types.TimeAuditable / types.UserAuditable shape used by
 // PlannedMaintenance and other entities. v1 handlers keep serializing
@@ -709,28 +593,3 @@ func NewRule(g *GettableRule) *Rule {
 	}
 	return r
 }
-
-func (r *Rule) MarshalJSON() ([]byte, error) {
-	type Alias Rule
-
-	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	}
-}

pkg/types/ruletypes/api_params_test.go

@@ -3,10 +3,8 @@ package ruletypes
 import (
 	"encoding/json"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -29,8 +27,7 @@ func TestParseIntoRule(t *testing.T) {
 				"alertType": "METRIC_BASED_ALERT",
 				"description": "Test description",
 				"ruleType": "threshold_rule",
-				"evalWindow": "5m",
-				"frequency": "1m",
+				"schemaVersion": "v2alpha1",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -45,11 +42,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"target": 10.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 10.0, "matchType": "1", "op": "1"}]},
+					"selectedQueryName": "A"
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -63,46 +60,6 @@ func TestParseIntoRule(t *testing.T) {
 				if rule.RuleCondition.Thresholds.Kind.IsZero() {
 					t.Error("Expected thresholds to be populated")
 				}
-				if rule.RuleCondition.Target == nil {
-					t.Error("Expected target to be populated")
-				}
-			},
-		},
-		{
-			name:     "rule with default values applied",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "DefaultsRule",
-				"ruleType": "threshold_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test_metric", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 5.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.EvalWindow.Duration() != 5*time.Minute {
-					t.Errorf("Expected default eval window '5m', got '%v'", rule.EvalWindow)
-				}
-				if rule.Frequency.Duration() != time.Minute {
-					t.Errorf("Expected default frequency '1m', got '%v'", rule.Frequency)
-				}
 			},
 		},
 		{
@@ -110,6 +67,7 @@ func TestParseIntoRule(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "PromQLRule",
+				"schemaVersion": "v2alpha1",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -123,11 +81,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"target": 10.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 10.0, "matchType": "1", "op": "1"}]},
+					"selectedQueryName": "A"
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -138,9 +96,6 @@ func TestParseIntoRule(t *testing.T) {
 				if rule.RuleCondition.Thresholds.Kind.IsZero() {
 					t.Error("Expected thresholds to be populated")
 				}
-				if rule.RuleCondition.Target == nil {
-					t.Error("Expected target to be populated")
-				}
 			},
 		},
 	}
@@ -177,233 +132,6 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 		expectValidateError bool // Validate() error (write path only)
 		validate            func(*testing.T, *PostableRule)
 	}{
-		{
-			name:     "schema v1 - threshold name from severity label",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "SeverityLabelTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "cpu_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}],
-						"unit": "percent"
-					},
-					"target": 85.0,
-					"targetUnit": "%",
-					"matchType": "1",
-					"op": "1"
-				},
-				"labels": {
-					"severity": "warning",
-					"team": "platform"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated for v1")
-				}
-
-				threshold := rule.RuleCondition.Thresholds
-				if threshold.Kind != BasicThresholdKind {
-					t.Errorf("Expected BasicThresholdKind, got %s", threshold.Kind)
-				}
-
-				specs, ok := threshold.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", threshold.Spec)
-				}
-
-				if len(specs) != 1 {
-					t.Fatalf("Expected 1 threshold spec, got %d", len(specs))
-				}
-
-				spec := specs[0]
-				if spec.Name != "warning" {
-					t.Errorf("Expected threshold name 'warning' from severity label, got '%s'", spec.Name)
-				}
-
-				if spec.TargetUnit != "%" {
-					t.Errorf("Expected TargetUnit '%%', got '%s'", spec.TargetUnit)
-				}
-				if *spec.TargetValue != 85.0 {
-					t.Errorf("Expected TargetValue 85.0, got %v", *spec.TargetValue)
-				}
-				if spec.MatchType != rule.RuleCondition.MatchType {
-					t.Error("Expected MatchType to be copied from RuleCondition")
-				}
-				if spec.CompareOperator != rule.RuleCondition.CompareOperator {
-					t.Error("Expected CompareOp to be copied from RuleCondition")
-				}
-
-				// Verify evaluation envelope is populated
-				if rule.Evaluation == nil {
-					t.Fatal("Expected Evaluation to be populated for v1")
-				}
-				if rule.Evaluation.Kind != RollingEvaluation {
-					t.Errorf("Expected RollingEvaluation, got %s", rule.Evaluation.Kind)
-				}
-
-				// Verify evaluation window matches rule settings
-				if window, ok := rule.Evaluation.Spec.(RollingWindow); ok {
-					if !window.EvalWindow.Equal(rule.EvalWindow) {
-						t.Errorf("Expected Evaluation EvalWindow %v, got %v", rule.EvalWindow, window.EvalWindow)
-					}
-					if !window.Frequency.Equal(rule.Frequency) {
-						t.Errorf("Expected Evaluation Frequency %v, got %v", rule.Frequency, window.Frequency)
-					}
-				} else {
-					t.Errorf("Expected RollingWindow spec, got %T", rule.Evaluation.Spec)
-				}
-			},
-		},
-		{
-			name:     "schema v1 - uses critical threshold when no labels",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "NoLabelsTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "memory_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 90.0,
-					"matchType": "1",
-					"op": "1"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated")
-				}
-
-				specs, ok := rule.RuleCondition.Thresholds.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", rule.RuleCondition.Thresholds.Spec)
-				}
-				spec := specs[0]
-				// Should default to CriticalThresholdName when no severity label
-				if spec.Name != CriticalThresholdName {
-					t.Errorf("Expected threshold name '%s', got '%s'", CriticalThresholdName, spec.Name)
-				}
-			},
-		},
-		{
-			name:     "schema v1 - overwrites existing thresholds and evaluation",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "OverwriteTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "cpu_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}],
-						"unit": "percent"
-					},
-					"target": 80.0,
-					"targetUnit": "%",
-					"matchType": "1",
-					"op": "1",
-					"thresholds": {
-						"kind": "basic",
-						"spec": [{
-							"name": "existing_threshold",
-							"target": 50.0,
-							"targetUnit": "MB",
-							"ruleUnit": "bytes",
-							"matchType": "1",
-							"op": "1"
-						}]
-					}
-				},
-				"evaluation": {
-					"kind": "rolling",
-					"spec": {
-						"evalWindow": "10m",
-						"frequency": "2m"
-					}
-				},
-				"frequency":"7m",
-				"evalWindow":"11m",
-				"labels": {
-					"severity": "critical"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated")
-				}
-
-				specs, ok := rule.RuleCondition.Thresholds.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", rule.RuleCondition.Thresholds.Spec)
-				}
-
-				if len(specs) != 1 {
-					t.Fatalf("Expected 1 threshold spec, got %d", len(specs))
-				}
-
-				spec := specs[0]
-				if spec.Name != "critical" {
-					t.Errorf("Expected threshold name 'critical' (overwritten), got '%s'", spec.Name)
-				}
-
-				if *spec.TargetValue != 80.0 {
-					t.Errorf("Expected TargetValue 80.0 (overwritten), got %v", *spec.TargetValue)
-				}
-				if spec.TargetUnit != "%" {
-					t.Errorf("Expected TargetUnit '%%' (overwritten), got '%s'", spec.TargetUnit)
-				}
-
-				if rule.Evaluation == nil {
-					t.Fatal("Expected Evaluation to be populated")
-				}
-				if window, ok := rule.Evaluation.Spec.(RollingWindow); ok {
-					if !window.EvalWindow.Equal(rule.EvalWindow) {
-						t.Errorf("Expected Evaluation EvalWindow to be overwritten to %v, got %v", rule.EvalWindow, window.EvalWindow)
-					}
-					if !window.Frequency.Equal(rule.Frequency) {
-						t.Errorf("Expected Evaluation Frequency to be overwritten to %v, got %v", rule.Frequency, window.Frequency)
-					}
-				} else {
-					t.Errorf("Expected RollingWindow spec, got %T", rule.Evaluation.Spec)
-				}
-			},
-		},
 		{
 			name:     "schema v2alpha1 - uses explicit thresholds and evaluation",
 			initRule: PostableRule{},
@@ -645,19 +373,19 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"target": 100.0,
-					"matchType": "1",
-					"op": "1"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 100.0, "matchType": "1", "op": "1"}]}
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:                RuleDataKindJson,
 			expectValidateError: true,
 		},
 		{
-			name:     "default schema version - defaults to v1 behavior",
+			name:     "missing schema version - rejected on write",
 			initRule: PostableRule{},
 			content: []byte(`{
-				"alert": "DefaultSchemaTest",
+				"alert": "MissingSchemaTest",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -672,24 +400,13 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"target": 75.0,
-					"matchType": "1",
-					"op": "1"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 75.0, "matchType": "1", "op": "1"}]}
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.SchemaVersion != DefaultSchemaVersion {
-					t.Errorf("Expected default schemaVersion '%s', got '%s'", DefaultSchemaVersion, rule.SchemaVersion)
-				}
-				if rule.RuleCondition.Thresholds == nil {
-					t.Error("Expected Thresholds to be populated for default schema version")
-				}
-				if rule.Evaluation == nil {
-					t.Error("Expected Evaluation to be populated for default schema version")
-				}
-			},
+			kind:                RuleDataKindJson,
+			expectValidateError: true,
 		},
 	}
 
@@ -737,11 +454,7 @@ func TestParseIntoRuleThresholdGeneration(t *testing.T) {
 					}
 				}]
 			},
-			"target": 100.0,
-			"matchType": "1",
-			"op": "1",
-			"selectedQuery": "A",
-			"targetUnit": "ms",
+			"selectedQueryName": "A",
 			"thresholds": {
 				"kind": "basic",
 				"spec": [
@@ -906,449 +619,3 @@ func TestParseIntoRuleMultipleThresholds(t *testing.T) {
 
 	assert.Equal(t, 1, len(vector))
 }
-
-func TestAnomalyNegationEval(t *testing.T) {
-	tests := []struct {
-		name          string
-		ruleJSON      []byte
-		series        *qbtypes.TimeSeries
-		shouldAlert   bool
-		expectedValue float64
-	}{
-		{
-			name: "anomaly rule with ValueIsBelow - should alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyBelowTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "1",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: -2.1}, // below & at least once, should alert
-					{Timestamp: 2000, Value: -2.3},
-				},
-			},
-			shouldAlert:   true,
-			expectedValue: -2.1,
-		},
-		{
-			name: "anomaly rule with ValueIsBelow; should not alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyBelowTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "1",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`), // below & at least once, no value below -2.0
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: -1.9},
-					{Timestamp: 2000, Value: -1.8},
-				},
-			},
-			shouldAlert: false,
-		},
-		{
-			name: "anomaly rule with ValueIsAbove; should alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyAboveTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
-			}`), // above & at least once, should alert
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: 2.1}, // above 2.0, should alert
-					{Timestamp: 2000, Value: 2.2},
-				},
-			},
-			shouldAlert:   true,
-			expectedValue: 2.1,
-		},
-		{
-			name: "anomaly rule with ValueIsAbove; should not alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyAboveTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: 1.1},
-					{Timestamp: 2000, Value: 1.2},
-				},
-			},
-			shouldAlert: false,
-		},
-		{
-			name: "anomaly rule with ValueIsBelow and AllTheTimes; should alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyBelowAllTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "2",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`), // below and all the times
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: -2.1}, // all below -2
-					{Timestamp: 2000, Value: -2.2},
-					{Timestamp: 3000, Value: -2.5},
-				},
-			},
-			shouldAlert:   true,
-			expectedValue: -2.1, // max value when all are below threshold
-		},
-		{
-			name: "anomaly rule with ValueIsBelow and AllTheTimes; should not alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyBelowAllTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 2.0,
-					"matchType": "2",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: -3.0},
-					{Timestamp: 2000, Value: -1.0}, // above -2, breaks condition
-					{Timestamp: 3000, Value: -2.5},
-				},
-			},
-			shouldAlert: false,
-		},
-		{
-			name: "anomaly rule with ValueOutsideBounds; should alert",
-			ruleJSON: []byte(`{
-				"alert": "AnomalyOutOfBoundsTest",
-				"ruleType": "anomaly_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 7.0,
-					"matchType": "1",
-					"op": "7",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: -8.0}, // abs(−8) >= 7, alert
-					{Timestamp: 2000, Value: 5.0},
-				},
-			},
-			shouldAlert:   true,
-			expectedValue: -8.0,
-		},
-		{
-			name: "non-anomaly threshold rule with ValueIsBelow; should alert",
-			ruleJSON: []byte(`{
-				"alert": "ThresholdTest",
-				"ruleType": "threshold_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 90.0,
-					"matchType": "1",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: 80.0}, // below 90, should alert
-					{Timestamp: 2000, Value: 85.0},
-				},
-			},
-			shouldAlert:   true,
-			expectedValue: 80.0,
-		},
-		{
-			name: "non-anomaly rule with ValueIsBelow - should not alert",
-			ruleJSON: []byte(`{
-				"alert": "ThresholdTest",
-				"ruleType": "threshold_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 50.0,
-					"matchType": "1",
-					"op": "2",
-					"selectedQuery": "A"
-				}
-			}`),
-			series: &qbtypes.TimeSeries{
-				Labels: []*qbtypes.Label{
-					{
-						Key: telemetrytypes.TelemetryFieldKey{
-							Name: "host",
-						},
-						Value: "server1",
-					},
-				},
-				Values: []*qbtypes.TimeSeriesValue{
-					{Timestamp: 1000, Value: 60.0}, // below, should alert
-					{Timestamp: 2000, Value: 90.0},
-				},
-			},
-			shouldAlert: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			rule := PostableRule{}
-			err := json.Unmarshal(tt.ruleJSON, &rule)
-			if err != nil {
-				t.Fatalf("Failed to unmarshal rule: %v", err)
-			}
-
-			ruleThreshold, err := rule.RuleCondition.Thresholds.GetRuleThreshold()
-			if err != nil {
-				t.Fatalf("unexpected error from GetRuleThreshold: %v", err)
-			}
-
-			resultVector, err := ruleThreshold.Eval(tt.series, "", EvalData{})
-			if err != nil {
-				t.Fatalf("unexpected error from Eval: %v", err)
-			}
-
-			shouldAlert := len(resultVector) > 0
-
-			if shouldAlert != tt.shouldAlert {
-				t.Errorf("Expected shouldAlert=%v, got %v. %s",
-					tt.shouldAlert, shouldAlert, tt.name)
-			}
-
-			if tt.shouldAlert && len(resultVector) > 0 {
-				sample := resultVector[0]
-				if sample.V != tt.expectedValue {
-					t.Errorf("Expected alert value=%.2f, got %.2f. %s",
-						tt.expectedValue, sample.V, tt.name)
-				}
-			}
-		})
-	}
-}
-
-func TestVersionDefaultsToV5(t *testing.T) {
-	content := `{
-		"alert": "cpu high",
-		"alertType": "METRIC_BASED_ALERT",
-		"ruleType": "threshold_rule",
-		"schemaVersion": "v2alpha1",
-		"condition": {
-			"compositeQuery": {
-				"queries": [{"type": "promql", "spec": {"name": "A", "query": "up"}}],
-				"panelType": "graph",
-				"queryType": "promql"
-			},
-			"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 90, "matchType": "1", "op": "1"}]}
-		},
-		"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
-		"notificationSettings": {"usePolicy": false}
-	}`
-
-	rule := PostableRule{}
-	require.NoError(t, json.Unmarshal([]byte(content), &rule))
-	assert.Equal(t, "v5", rule.Version)
-	assert.NoError(t, rule.Validate())
-}

pkg/types/ruletypes/evaluation.go

@@ -29,6 +29,9 @@ func (EvaluationKind) Enum() []any {
 type Evaluation interface {
 	NextWindowFor(curr time.Time) (time.Time, time.Time)
 	GetFrequency() valuer.TextDuration
+	// validateDurationText runs on the write path only; a stored window may
+	// hold a bare number and still evaluate.
+	validateDurationText() error
 }
 
 type RollingWindow struct {
@@ -36,6 +39,13 @@ type RollingWindow struct {
 	Frequency  valuer.TextDuration `json:"frequency" required:"true" description:"How often the rule is evaluated, as a Go duration such as 1m. Must be positive."`
 }
 
+func (rollingWindow RollingWindow) validateDurationText() error {
+	if err := validateDurationText("evaluation.spec.evalWindow", rollingWindow.EvalWindow); err != nil {
+		return err
+	}
+	return validateDurationText("evaluation.spec.frequency", rollingWindow.Frequency)
+}
+
 func (rollingWindow RollingWindow) Validate() error {
 	if !rollingWindow.EvalWindow.IsPositive() {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "evalWindow must be greater than zero")
@@ -60,6 +70,10 @@ type CumulativeWindow struct {
 	Timezone  string              `json:"timezone" required:"true" description:"The IANA time zone the schedule is resolved in, such as UTC or Asia/Kolkata."`
 }
 
+func (cumulativeWindow CumulativeWindow) validateDurationText() error {
+	return validateDurationText("evaluation.spec.frequency", cumulativeWindow.Frequency)
+}
+
 type CumulativeSchedule struct {
 	Type    ScheduleType `json:"type" required:"true" description:"How often the window resets: hourly, daily, weekly or monthly."`
 	Minute  *int         `json:"minute,omitempty" description:"The minute of the reset boundary, 0 to 59. Required for every type."`
@@ -328,6 +342,9 @@ func (e *EvaluationEnvelope) UnmarshalJSON(data []byte) error {
 }
 
 func (e *EvaluationEnvelope) GetEvaluation() (Evaluation, error) {
+	if e == nil {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "evaluation is nil")
+	}
 	if e.Kind.IsZero() {
 		e.Kind = RollingEvaluation
 	}

pkg/types/ruletypes/listable_rule.go

@@ -33,6 +33,11 @@ type storedRuleData struct {
 	RuleType    RuleType          `json:"ruleType"`
 	Disabled    bool              `json:"disabled"`
 	Labels      map[string]string `json:"labels"`
+	Condition   struct {
+		CompositeQuery struct {
+			QueryType QueryType `json:"queryType"`
+		} `json:"compositeQuery"`
+	} `json:"condition"`
 }
 
 // ToListableRule leaves State zero; the caller overlays evaluation state.
@@ -42,6 +47,15 @@ func (rule *StorableRule) ToListableRule() (*ListableRule, error) {
 		return nil, err
 	}
 
+	switch data.Condition.CompositeQuery.QueryType {
+	case QueryTypeBuilder, QueryTypeClickHouseSQL:
+		if data.RuleType.IsZero() {
+			data.RuleType = RuleTypeThreshold
+		}
+	case QueryTypePromQL:
+		data.RuleType = RuleTypeProm
+	}
+
 	return &ListableRule{
 		Id:            rule.ID.StringValue(),
 		AlertName:     data.AlertName,

pkg/types/ruletypes/roundtrip_test.go

@@ -147,7 +147,7 @@ func TestV2MinimalReadShape(t *testing.T) {
 
 	body := readBody(t, stored)
 
-	for _, field := range []string{"labels", "annotations", "description", "preferredChannels", "evalWindow", "frequency"} {
+	for _, field := range []string{"labels", "annotations", "description"} {
 		assert.NotContains(t, body, field)
 	}
 
@@ -159,7 +159,7 @@ func TestV2MinimalReadShape(t *testing.T) {
 	assert.JSONEq(t, `false`, string(ns["usePolicy"]))
 
 	assert.JSONEq(t, `false`, string(body["disabled"]))
-	assert.JSONEq(t, `"v5"`, string(body["version"]))
+	assert.JSONEq(t, `""`, string(body["version"]))
 
 	var condition struct {
 		Thresholds struct {
@@ -297,6 +297,7 @@ func TestPatchMergePreservesUnpatchedFields(t *testing.T) {
 				"panelType": "graph",
 				"queryType": "promql"
 			},
+			"selectedQueryName": "A",
 			"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 90, "matchType": "at_least_once", "op": "above"}]}
 		},
 		"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},

pkg/types/ruletypes/threshold.go

@@ -85,9 +85,6 @@ func (r *RuleThresholdData) UnmarshalJSON(data []byte) error {
 		if err := json.Unmarshal(raw["spec"], &basicThresholds); err != nil {
 			return errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to unmarshal rule threshold spec: %v", err)
 		}
-		if err := basicThresholds.Validate(); err != nil {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid rule threshold spec: %v", err)
-		}
 		r.Spec = basicThresholds
 
 	default:
@@ -130,6 +127,9 @@ type RuleThreshold interface {
 	// using the given EvalData and returns the matching series
 	Eval(series *qbtypes.TimeSeries, unit string, evalData EvalData) (Vector, error)
 	GetRuleReceivers() []RuleReceivers
+	// Validate runs on the write path and before a task is built; a stored
+	// rule may hold a threshold that fails it and still decode.
+	Validate() error
 }
 
 type BasicRuleThreshold struct {
@@ -170,6 +170,37 @@ func (r BasicRuleThresholds) Validate() error {
 	return errors.Join(errs...)
 }
 
+func (r BasicRuleThresholds) validateUniqueNames() error {
+	names := make(map[string]struct{}, len(r))
+	for _, basicThreshold := range r {
+		if _, seen := names[basicThreshold.Name]; seen {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.thresholds.spec: duplicate threshold name %q", basicThreshold.Name)
+		}
+		names[basicThreshold.Name] = struct{}{}
+	}
+	return nil
+}
+
+func (r BasicRuleThresholds) validateRecoveryTargets() error {
+	for _, basicThreshold := range r {
+		if basicThreshold.RecoveryTarget == nil || basicThreshold.TargetValue == nil {
+			continue
+		}
+		// equal, not_equal and outside_bounds have no recovering side
+		switch basicThreshold.CompareOperator.Normalize() {
+		case ValueIsAbove, ValueAboveOrEq:
+			if *basicThreshold.RecoveryTarget >= *basicThreshold.TargetValue {
+				return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.thresholds.spec: recoveryTarget must be below target for op %s", basicThreshold.CompareOperator.StringValue())
+			}
+		case ValueIsBelow, ValueBelowOrEq:
+			if *basicThreshold.RecoveryTarget <= *basicThreshold.TargetValue {
+				return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.thresholds.spec: recoveryTarget must be above target for op %s", basicThreshold.CompareOperator.StringValue())
+			}
+		}
+	}
+	return nil
+}
+
 func (r BasicRuleThresholds) Eval(s *qbtypes.TimeSeries, unit string, evalData EvalData) (Vector, error) {
 
 	series := &qbtypes.TimeSeries{

pkg/valuer/text_duration.go

@@ -54,6 +54,12 @@ func (d TextDuration) IsPositive() bool {
 	return d.value > 0
 }
 
+// HasText reports whether the duration came as text; a bare JSON number
+// decodes to nanoseconds and keeps none.
+func (d TextDuration) HasText() bool {
+	return d.text != ""
+}
+
 // String implements the [fmt.Stringer] interface.
 func (d TextDuration) String() string {
 	if len(d.text) > 0 {

tests/e2e/tests/traces-funnels/steps.spec.ts

@@ -114,6 +114,7 @@ test.describe('Trace funnels, steps', () => {
 		await expect(funnels.stepDeleteAction()).toBeDisabled();
 		// The trigger toggles the popover closed again.
 		await funnels.stepActionsTrigger(0).click();
+		await expect(funnels.stepDeleteAction()).toBeHidden();
 
 		await funnels.addStep();
 		await expect(funnels.stepsCount()).toHaveText('3 steps');

tests/fixtures/alerts.py

@@ -32,12 +32,12 @@ def create_alert_rule(signoz: types.SigNoz, get_token: Callable[[str, str], str]
 
     def _create_alert_rule(rule_data: dict) -> str:
         response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v1/rules"),
+            signoz.self.host_configs["8080"].get("/api/v2/rules"),
             json=rule_data,
             headers={"Authorization": f"Bearer {admin_token}"},
             timeout=5,
         )
-        assert response.status_code == HTTPStatus.OK, f"Failed to create rule, api returned {response.status_code} with response: {response.text}"
+        assert response.status_code == HTTPStatus.CREATED, f"Failed to create rule, api returned {response.status_code} with response: {response.text}"
         rule_id = response.json()["data"]["id"]
         rule_ids.append(rule_id)
         return rule_id
@@ -45,11 +45,11 @@ def create_alert_rule(signoz: types.SigNoz, get_token: Callable[[str, str], str]
     def _delete_alert_rule(rule_id: str):
         logger.info("Deleting rule: %s", {"rule_id": rule_id})
         response = requests.delete(
-            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule_id}"),
+            signoz.self.host_configs["8080"].get(f"/api/v2/rules/{rule_id}"),
             headers={"Authorization": f"Bearer {admin_token}"},
             timeout=5,
         )
-        if response.status_code != HTTPStatus.OK:
+        if response.status_code != HTTPStatus.NO_CONTENT:
             raise Exception(  # pylint: disable=broad-exception-raised
                 f"Failed to delete rule, api returned {response.status_code} with response: {response.text}"
             )
@@ -156,19 +156,22 @@ def create_downtime_schedule(signoz: types.SigNoz, get_token: Callable[[str, str
 
 
 def delete_all_rules(signoz: types.SigNoz, token: str) -> None:
+    # the v3 list is paginated; 200 is its maximum page and more rules than
+    # that would mean a seeding bug, not a second page
     response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v2/rules"),
+        signoz.self.host_configs["8080"].get("/api/v3/rules"),
+        params={"limit": 200},
         headers={"Authorization": f"Bearer {token}"},
         timeout=5,
     )
     assert response.status_code == HTTPStatus.OK
-    for rule in response.json()["data"]:
+    for rule in response.json()["data"]["rules"]:
         delete_response = requests.delete(
-            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule['id']}"),
+            signoz.self.host_configs["8080"].get(f"/api/v2/rules/{rule['id']}"),
             headers={"Authorization": f"Bearer {token}"},
             timeout=5,
         )
-        assert delete_response.status_code == HTTPStatus.OK, f"failed to delete rule {rule['id']}: {delete_response.text}"
+        assert delete_response.status_code == HTTPStatus.NO_CONTENT, f"failed to delete rule {rule['id']}: {delete_response.text}"
 
 
 @pytest.fixture(name="seed_alert_rules", scope="function")

tests/integration/tests/queriermetrics/17_cache.py

@@ -442,55 +442,3 @@ def test_builder_refreshing_a_sliding_time_range(
     assert uncached.status_code == HTTPStatus.OK, uncached.text
 
     assert_results_equal(from_cache.json(), uncached.json(), "A", "the twentieth refresh")
-
-
-def test_builder_refreshing_does_not_inflate_rows_scanned(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_metrics: Callable[[list[Metrics]], None],
-) -> None:
-    metric_name = f"cache_rows_scanned_{uuid4().hex[:8]}"
-
-    # 90 minutes back so even the last refresh closes clear of the flux
-    # interval, which holds recent data out of the cache
-    start_time = datetime.fromtimestamp(int((datetime.now(tz=UTC) - timedelta(minutes=90)).timestamp()) // 60 * 60, tz=UTC)
-    start_time_ms = int(start_time.timestamp() * 1000)
-
-    query = [build_builder_query("A", metric_name, "max", "max")]
-
-    insert_metrics(
-        [
-            Metrics(
-                metric_name=metric_name,
-                labels={"service": "api"},
-                timestamp=start_time + timedelta(minutes=minute),
-                value=minute,
-                type_="Gauge",
-                is_monotonic=False,
-            )
-            for minute in range(70)
-        ]
-    )
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    # a dashboard left open on a thirty minute range, re-running a minute later
-    # each time. rowsScanned is a cost indicator, so a refresh served mostly out
-    # of the cache cannot claim more than every read made so far: the first
-    # full read and then one new minute per refresh, measured with the cache off
-    uncached_rows_scanned_so_far = 0
-    for refresh in range(10):
-        refresh_start_ms = start_time_ms + refresh * MINUTE_MS
-        refresh_end_ms = refresh_start_ms + 30 * MINUTE_MS
-
-        uncached_start_ms = refresh_start_ms if refresh == 0 else refresh_end_ms - MINUTE_MS
-        uncached_response = make_query_request(signoz, token, uncached_start_ms, refresh_end_ms, query, no_cache=True)
-        assert uncached_response.status_code == HTTPStatus.OK, f"refresh {refresh}: uncached read failed: {uncached_response.text}"
-        uncached_rows_scanned_so_far += uncached_response.json()["data"]["meta"]["rowsScanned"]
-        assert uncached_rows_scanned_so_far > 0, f"refresh {refresh}: uncached read reported no rows scanned"
-
-        cached_response = make_query_request(signoz, token, refresh_start_ms, refresh_end_ms, query, no_cache=False)
-        assert cached_response.status_code == HTTPStatus.OK, f"refresh {refresh}: cached read failed: {cached_response.text}"
-        cached_rows_scanned = cached_response.json()["data"]["meta"]["rowsScanned"]
-        assert cached_rows_scanned <= uncached_rows_scanned_so_far, f"refresh {refresh}: cached read reported {cached_rows_scanned} rows scanned, more than the {uncached_rows_scanned_so_far} rows all uncached reads scanned so far"

tests/integration/tests/ruler/05_list_rules_v3.py

@@ -573,24 +573,3 @@ def test_error_contract(
         error = response.json()["error"]
         assert error["code"] == expected_code, f"params {params!r}"
         assert expected_message_part in error["message"], f"params {params!r}: {error['message']}"
-
-
-def test_v2_list_still_serves_bare_array(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    seed_alert_rules: Callable[[str, list[dict]], None],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    seed_alert_rules(SEED_CHANNEL_NAME, SEED_RULES)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v2/rules"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-
-    assert response.status_code == HTTPStatus.OK
-    data = response.json()["data"]
-    assert isinstance(data, list), "deprecated v2 must keep returning a bare array"
-    assert {rule["alert"] for rule in data} == {r["alert"] for r in SEED_RULES}

tests/integration/tests/ruler/08_rule_validation.py

@@ -0,0 +1,446 @@
+import time
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.types import Operation, SigNoz
+
+BASE_URL = "/api/v2/rules"
+
+VALID_RULE = {
+    "alert": "validation probe",
+    "alertType": "METRIC_BASED_ALERT",
+    "ruleType": "threshold_rule",
+    "condition": {
+        "thresholds": {
+            "kind": "basic",
+            "spec": [{"name": "critical", "target": 90, "matchType": "at_least_once", "op": "above", "channels": []}],
+        },
+        "compositeQuery": {
+            "queryType": "builder",
+            "panelType": "graph",
+            "queries": [
+                {
+                    "type": "builder_query",
+                    "spec": {
+                        "name": "A",
+                        "signal": "metrics",
+                        "aggregations": [{"metricName": "validation_probe_cpu", "timeAggregation": "avg", "spaceAggregation": "max"}],
+                    },
+                }
+            ],
+        },
+        "selectedQueryName": "A",
+    },
+    "labels": {"severity": "critical"},
+    "annotations": {"summary": "s", "description": "d"},
+    "disabled": True,
+    "evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+    "notificationSettings": {"usePolicy": False, "renotify": {"enabled": False}},
+    "schemaVersion": "v2alpha1",
+}
+
+
+def test_create_rejects_missing_alert_type(
+    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)
+
+    rule = {key: value for key, value in VALID_RULE.items() if key != "alertType"}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": "alertType: field is required", "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_unknown_panel_type(
+    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)
+
+    rule = {**VALID_RULE, "condition": {**VALID_RULE["condition"], "compositeQuery": {**VALID_RULE["condition"]["compositeQuery"], "panelType": "pie"}}}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": 'condition.compositeQuery.panelType: unsupported value "pie"; must be one of value, table, graph', "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_malformed_json(
+    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(BASE_URL),
+        data='{"alert": ',
+        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "failed to parse json: unexpected end of JSON input",
+            "errors": [],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_unnamed_threshold(
+    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)
+
+    rule = {**VALID_RULE, "condition": {**VALID_RULE["condition"], "thresholds": {"kind": "basic", "spec": [{"name": "", "target": 90, "matchType": "at_least_once", "op": "above", "channels": []}]}}}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": "threshold name cannot be empty", "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_duplicate_threshold_names(
+    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)
+
+    threshold = {"name": "critical", "target": 90, "matchType": "at_least_once", "op": "above", "channels": []}
+    rule = {**VALID_RULE, "condition": {**VALID_RULE["condition"], "thresholds": {"kind": "basic", "spec": [threshold, {**threshold, "target": 95}]}}}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": 'condition.thresholds.spec: duplicate threshold name "critical"', "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_empty_schema_version(
+    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(BASE_URL),
+        json={**VALID_RULE, "schemaVersion": ""},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": 'schemaVersion: unsupported value ""; must be "v2alpha1"', "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_defaults_clickhouse_rule_type(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_alert_rule: Callable[[dict], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    rule = {key: value for key, value in VALID_RULE.items() if key != "ruleType"}
+    rule["condition"] = {**VALID_RULE["condition"], "compositeQuery": {"queryType": "clickhouse_sql", "panelType": "graph", "queries": [{"type": "clickhouse_sql", "spec": {"name": "A", "query": "SELECT now() AS ts, 1 AS value"}}]}}
+    rule_id = create_alert_rule(rule)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["data"]["ruleType"] == "threshold_rule"
+
+
+def test_get_echoes_alert_on_absent_false(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_alert_rule: Callable[[dict], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    rule_id = create_alert_rule({**VALID_RULE, "condition": {**VALID_RULE["condition"], "alertOnAbsent": False, "absentFor": 0}})
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["data"]["condition"]["alertOnAbsent"] is False
+    assert response.json()["data"]["condition"]["absentFor"] == 0
+
+
+def test_timeline_rejects_unknown_state(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_alert_rule: Callable[[dict], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    rule_id = create_alert_rule(VALID_RULE)
+
+    end_ms = int(time.time() * 1000)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}/history/timeline"),
+        params={"start": end_ms - 3_600_000, "end": end_ms, "state": "bogus"},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "invalid query parameters",
+            "errors": [],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_unknown_field(
+    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(BASE_URL),
+        json={**VALID_RULE, "preferredChannels": ["slack"]},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": 'unknown field "preferredChannels" in alert rule',
+            "errors": [],
+            "suggestions": ["valid fields are `alert`, `alertType`, `description`, `ruleType`, `condition`, `labels`, `annotations`, `disabled`, `source`, `version`, `evaluation`, `schemaVersion`, `notificationSettings`"],
+        },
+    }
+
+
+def test_create_rejects_numeric_eval_window(
+    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(BASE_URL),
+        json={**VALID_RULE, "evaluation": {"kind": "rolling", "spec": {"evalWindow": 300, "frequency": "1m"}}},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": 'evaluation.spec.evalWindow: must be a duration string such as "5m"', "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_recovery_target_past_target(
+    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)
+
+    thresholds = {"kind": "basic", "spec": [{**VALID_RULE["condition"]["thresholds"]["spec"][0], "recoveryTarget": 95}]}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json={**VALID_RULE, "condition": {**VALID_RULE["condition"], "thresholds": thresholds}},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": "condition.thresholds.spec: recoveryTarget must be below target for op above", "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_list_defaults_rule_type(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_alert_rule: Callable[[dict], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    rule_id = create_alert_rule({key: value for key, value in VALID_RULE.items() if key != "ruleType"})
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v3/rules"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    listed = next(rule for rule in response.json()["data"]["rules"] if rule["id"] == rule_id)
+    assert listed["ruleType"] == "threshold_rule"
+
+
+def test_update_rejects_malformed_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.put(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/not-a-uuid"),
+        json=VALID_RULE,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "id is not a valid uuid",
+            "errors": [],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_channel_by_name(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_webhook_notification_channel: Callable[[str, str, dict, bool], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    channel_id = create_webhook_notification_channel(f"Rule Validation {time.time_ns()}", "http://localhost:9/alert", {}, False)
+    channel = requests.get(
+        signoz.self.host_configs["8080"].get(f"/api/v2/notification_channels/{channel_id}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    ).json()["data"]
+
+    thresholds = {"kind": "basic", "spec": [{**VALID_RULE["condition"]["thresholds"]["spec"][0], "channels": [channel["name"]]}]}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json={**VALID_RULE, "condition": {**VALID_RULE["condition"], "thresholds": thresholds}},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": f'channels: rules reference channels by display name, not name: [{channel["name"]} (display name "{channel["displayName"]}")]',
+            "errors": [],
+            "suggestions": [],
+        },
+    }

tests/integration/tests/ruler/09_threshold_validation.py

@@ -0,0 +1,119 @@
+from collections.abc import Callable
+from http import HTTPStatus
+
+import pytest
+import requests
+
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.types import Operation, SigNoz
+
+BASE_URL = "/api/v2/rules"
+
+VALID_RULE = {
+    "alert": "threshold probe",
+    "alertType": "METRIC_BASED_ALERT",
+    "ruleType": "threshold_rule",
+    "condition": {
+        "thresholds": {
+            "kind": "basic",
+            "spec": [{"name": "critical", "target": 90, "matchType": "at_least_once", "op": "above", "channels": []}],
+        },
+        "compositeQuery": {
+            "queryType": "builder",
+            "panelType": "graph",
+            "queries": [
+                {
+                    "type": "builder_query",
+                    "spec": {
+                        "name": "A",
+                        "signal": "metrics",
+                        "aggregations": [{"metricName": "threshold_probe_cpu", "timeAggregation": "avg", "spaceAggregation": "max"}],
+                    },
+                }
+            ],
+        },
+        "selectedQueryName": "A",
+    },
+    "labels": {"severity": "critical"},
+    "annotations": {"summary": "s", "description": "d"},
+    "disabled": True,
+    "evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+    "notificationSettings": {"usePolicy": False, "renotify": {"enabled": False}},
+    "schemaVersion": "v2alpha1",
+}
+
+
+@pytest.mark.parametrize(
+    ("threshold", "expected_message"),
+    [
+        (
+            {"name": "critical", "target": None, "matchType": "at_least_once", "op": "above", "channels": []},
+            "target value cannot be nil",
+        ),
+        (
+            {"name": "critical", "target": 90, "matchType": "at_least_once", "op": "", "channels": []},
+            'condition.op: unsupported value ""; must be one of above, below, equal, not_equal, above_or_equal, below_or_equal, outside_bounds',
+        ),
+        (
+            {"name": "critical", "target": 90, "matchType": "0", "op": "above", "channels": []},
+            'condition.matchType: unsupported value "0"; must be one of at_least_once, all_the_times, on_average, in_total, last',
+        ),
+    ],
+    ids=["null_target", "empty_op", "unknown_match_type"],
+)
+def test_create_rejects_invalid_threshold(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    threshold: dict,
+    expected_message: str,
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    rule = {**VALID_RULE, "condition": {**VALID_RULE["condition"], "thresholds": {"kind": "basic", "spec": [threshold]}}}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": expected_message, "suggestions": []}],
+            "suggestions": [],
+        },
+    }
+
+
+def test_create_rejects_omitted_selected_query_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)
+
+    rule = {**VALID_RULE, "condition": {key: value for key, value in VALID_RULE["condition"].items() if key != "selectedQueryName"}}
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=rule,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json() == {
+        "status": "error",
+        "error": {
+            "type": "invalid-input",
+            "code": "invalid_input",
+            "message": "alert rule is not valid",
+            "errors": [{"message": "condition.selectedQueryName: field is required", "suggestions": []}],
+            "suggestions": [],
+        },
+    }