refactor(saved-views): use the source page instead of mapping from DataSource

Callers already know the source page; going through DataSource could not
tell meter or AI observability apart.

docs/api/openapi.yml

@@ -11381,10 +11381,20 @@ 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
@@ -11396,6 +11406,13 @@ 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'
@@ -11505,10 +11522,20 @@ 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
@@ -11523,6 +11550,13 @@ 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'
@@ -11576,10 +11610,28 @@ 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.
@@ -11597,6 +11649,17 @@ 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'
@@ -25057,6 +25120,56 @@ 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,7 +34,8 @@ type AnomalyRule struct {
 
 	provider anomaly.Provider
 
-	logger *slog.Logger
+	version string
+	logger  *slog.Logger
 
 	seasonality anomaly.Seasonality
 }
@@ -62,6 +63,7 @@ func NewAnomalyRule(
 	r := AnomalyRule{
 		BaseRule: baseRule,
 		querier:  querier,
+		version:  p.Version,
 		logger:   logger.With(slog.String("rule.id", id)),
 	}
 
@@ -103,15 +105,15 @@ func (r *AnomalyRule) Type() ruletypes.RuleType {
 }
 
 func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) *qbtypes.QueryRangeRequest {
-	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.window_ms", r.EvalWindow().Milliseconds()),
 		slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()),
 	)
 
+	startTs, endTs := r.Timestamps(ts)
+	start, end := startTs.UnixMilli(), endTs.UnixMilli()
+
 	req := &qbtypes.QueryRangeRequest{
 		Start:       uint64(start),
 		End:         uint64(end),
@@ -418,10 +420,12 @@ 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(),
-		Labels:        r.Labels().Map(),
-		Annotations:   r.Annotations().Map(),
+		AlertName:         valuer.NewDisplayName(r.Name()),
+		RuleCondition:     r.Condition(),
+		EvalWindow:        r.EvalWindow(),
+		Labels:            r.Labels().Map(),
+		Annotations:       r.Annotations().Map(),
+		PreferredChannels: r.PreferredChannels(),
 	}
 
 	byt, err := json.Marshal(ar)

ee/query-service/rules/anomaly_test.go

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

frontend/src/components/LogDetail/index.tsx

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

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

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

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

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

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

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

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

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

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

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

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

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

frontend/src/container/LogsExplorerList/index.tsx

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

frontend/src/container/LogsExplorerViews/LogsActionsContainer.tsx

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

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

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

frontend/src/container/OptionsMenu/constants.ts

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

frontend/src/container/OptionsMenu/useOptionsMenu.ts

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

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

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

frontend/src/container/SavedViews/constants.ts

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

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

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

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

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

frontend/src/container/SavedViews/types.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

frontend/src/pages/TracesExplorer/index.tsx

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

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

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

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

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

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

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

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

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

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

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

frontend/src/providers/preferences/constants.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

frontend/src/providers/preferences/utils.ts

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

pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/config.go

@@ -9,6 +9,8 @@ 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 {
@@ -237,6 +239,37 @@ 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,13 +245,25 @@ 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")
+		service.settings.Logger().InfoContext(ctx, "mismatch found, updating config to match channels and matchers")
 		return config, nil
 	}
 

pkg/apiserver/signozapiserver/ruler.go

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

pkg/query-service/app/http_handler.go

@@ -3,8 +3,10 @@ package app
 import (
 	"bytes"
 	"context"
+	"database/sql"
 	"encoding/json"
 	"fmt"
+	"io"
 
 	"github.com/SigNoz/signoz/pkg/clickhousesql"
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -358,6 +360,14 @@ 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)
@@ -486,6 +496,166 @@ 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,6 +34,10 @@ 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
 
@@ -45,7 +49,10 @@ type BaseRule struct {
 	// these are the same for all alerts created for this rule
 	labels      ruletypes.Labels
 	annotations ruletypes.Labels
-	mtx         sync.Mutex
+	// preferredChannels is the list of channels to send the alert to
+	// if the rule is triggered
+	preferredChannels []string
+	mtx               sync.Mutex
 	// the time it took to evaluate the rule (most recent evaluation)
 	evaluationDuration time.Duration
 	// the timestamp of the last evaluation
@@ -144,27 +151,26 @@ 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,
-		labels:        ruletypes.FromMap(p.Labels),
-		annotations:   ruletypes.FromMap(p.Annotations),
-		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,
+		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,
 	}
 
 	// Store newGroupEvalDelay and groupBy keys from NotificationSettings
@@ -172,6 +178,10 @@ func NewBaseRule(
 		baseRule.newGroupEvalDelay = p.NotificationSettings.NewGroupEvalDelay
 	}
 
+	if baseRule.evalWindow.IsZero() {
+		baseRule.evalWindow = valuer.MustParseTextDuration("5m")
+	}
+
 	for _, opt := range opts {
 		opt(baseRule)
 	}
@@ -222,6 +232,10 @@ 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
 }
@@ -232,6 +246,7 @@ 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,28 +332,17 @@ 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, byName []string
+	var unknown []string
 	for _, name := range channels {
-		if _, ok := known[name]; ok {
-			continue
+		if _, ok := known[name]; !ok {
+			unknown = append(unknown, name)
 		}
-		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)
@@ -370,7 +359,7 @@ func (m *Manager) EditRule(ctx context.Context, ruleStr string, id valuer.UUID)
 	}
 	orgID := valuer.MustNewUUID(claims.OrgID)
 	parsedRule := ruletypes.PostableRule{}
-	err = parsedRule.DecodeStrict(ruleStr)
+	err = json.Unmarshal([]byte(ruleStr), &parsedRule)
 	if err != nil {
 		return err
 	}
@@ -449,7 +438,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 err
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error preparing rule with given parameters, previous rule set restored")
 	}
 
 	for _, r := range newTask.Rules() {
@@ -558,7 +547,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 := parsedRule.DecodeStrict(ruleStr); err != nil {
+	if err := json.Unmarshal([]byte(ruleStr), &parsedRule); err != nil {
 		return nil, err
 	}
 
@@ -670,7 +659,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 err
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error loading rules, previous rule set restored")
 	}
 
 	for _, r := range newTask.Rules() {
@@ -1059,10 +1048,8 @@ 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 := storedRule.DecodeStrict(ruleStr); err != nil {
+	if err := json.Unmarshal([]byte(ruleStr), &storedRule); 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
 	}
@@ -1118,9 +1105,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 := parsedRule.DecodeStrict(ruleStr)
+	err := json.Unmarshal([]byte(ruleStr), &parsedRule)
 	if err != nil {
-		return 0, err
+		return 0, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to unmarshal rule")
 	}
 	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",
-		SchemaVersion: ruletypes.SchemaVersionV2Alpha1,
+		Version: "v5",
 		RuleCondition: &ruletypes.RuleCondition{
-			SelectedQuery: "A",
+			MatchType:       ruletypes.AtleastOnce,
+			CompareOperator: ruletypes.ValueIsAbove,
+			Target:          &target,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
-				PanelType: ruletypes.PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -108,10 +108,12 @@ func BuildPromAtLeastOnceValueAbove(target float64, recovery *float64) ruletypes
 		Annotations: map[string]string{
 			"value": "{{$value}}",
 		},
-		Version:       "v5",
-		SchemaVersion: ruletypes.SchemaVersionV2Alpha1,
+		Version: "v5",
 		RuleCondition: &ruletypes.RuleCondition{
-			SelectedQuery: "A",
+			MatchType:       ruletypes.AtleastOnce,
+			SelectedQuery:   "A",
+			CompareOperator: ruletypes.ValueIsAbove,
+			Target:          &target,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				PanelType: ruletypes.PanelTypeGraph,
@@ -136,6 +138,7 @@ 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,6 +23,7 @@ import (
 
 type PromRule struct {
 	*BaseRule
+	version    string
 	prometheus prometheus.Prometheus
 }
 
@@ -46,6 +47,7 @@ func NewPromRule(
 
 	p := PromRule{
 		BaseRule:   baseRule,
+		version:    postableRule.Version,
 		prometheus: prometheus,
 	}
 
@@ -354,10 +356,12 @@ 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,
-		Labels:        r.labels.Map(),
-		Annotations:   r.annotations.Map(),
+		AlertName:         valuer.NewDisplayName(r.name),
+		RuleCondition:     r.ruleCondition,
+		EvalWindow:        r.evalWindow,
+		Labels:            r.labels.Map(),
+		Annotations:       r.annotations.Map(),
+		PreferredChannels: r.preferredChannels,
 	}
 
 	byt, err := json.Marshal(ar)

pkg/query-service/rules/prom_rule_test.go

@@ -690,11 +690,13 @@ 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,
@@ -903,7 +905,11 @@ 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{
@@ -1192,7 +1198,11 @@ 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{
@@ -1249,7 +1259,6 @@ 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"),
@@ -1260,6 +1269,8 @@ 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{
@@ -1271,7 +1282,7 @@ func TestPromRule_NoData(t *testing.T) {
 			},
 			Thresholds: &ruletypes.RuleThresholdData{
 				Kind: ruletypes.BasicThresholdKind,
-				Spec: ruletypes.BasicRuleThresholds{{Name: "Test no data", TargetValue: &target, CompareOperator: ruletypes.ValueIsAbove, MatchType: ruletypes.AtleastOnce}},
+				Spec: ruletypes.BasicRuleThresholds{{Name: "Test no data"}},
 			},
 		},
 	}
@@ -1354,7 +1365,10 @@ func TestPromRule_NoData_AbsentFor(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			AlertOnAbsent: true,
+			CompareOperator: ruletypes.ValueIsAbove,
+			MatchType:       ruletypes.AtleastOnce,
+			AlertOnAbsent:   true,
+			Target:          &target,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1477,6 +1491,8 @@ 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{
@@ -1546,9 +1562,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 	for _, c := range cases {
 		rc := postableRule.RuleCondition
 
-		target := &targetForNoAlert
+		rc.Target = &targetForNoAlert
 		if c.alertCondition {
-			target = &targetForAlert
+			rc.Target = &targetForAlert
 		}
 		rc.RequireMinPoints = c.requireMinPoints
 		rc.RequiredNumPoints = c.requiredNumPoints
@@ -1557,9 +1573,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			Spec: ruletypes.BasicRuleThresholds{
 				{
 					Name:            postableRule.AlertName.StringValue(),
-					TargetValue:     target,
-					MatchType:       ruletypes.AtleastOnce,
-					CompareOperator: ruletypes.ValueIsAbove,
+					TargetValue:     rc.Target,
+					MatchType:       rc.MatchType,
+					CompareOperator: rc.CompareOperator,
 				},
 			},
 		}

pkg/query-service/rules/rule.go

@@ -20,12 +20,15 @@ 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", end-start),
+		slog.Int64("eval_window", r.evalWindow.Milliseconds()),
 		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,10 +455,12 @@ 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,
-		Labels:        r.labels.Map(),
-		Annotations:   r.annotations.Map(),
+		AlertName:         valuer.NewDisplayName(r.name),
+		RuleCondition:     r.ruleCondition,
+		EvalWindow:        r.evalWindow,
+		Labels:            r.labels.Map(),
+		Annotations:       r.annotations.Map(),
+		PreferredChannels: r.preferredChannels,
 	}
 
 	byt, err := json.Marshal(ar)

pkg/query-service/rules/threshold_rule_test.go

@@ -63,7 +63,6 @@ func TestThresholdRuleEvalWithoutRecoveryTarget(t *testing.T) {
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
 				{
-					Name:            "critical",
 					TargetValue:     &c.target,
 					MatchType:       c.matchType,
 					CompareOperator: c.compareOperator,
@@ -172,7 +171,10 @@ func TestPrepareParamsForLogs(t *testing.T) {
 					},
 				},
 			},
-			SelectedQuery: "A",
+			CompareOperator: ruletypes.ValueIsNotEq,
+			MatchType:       ruletypes.AtleastOnce,
+			Target:          &[]float64{0.0}[0],
+			SelectedQuery:   "A",
 		},
 	}
 
@@ -181,10 +183,9 @@ func TestPrepareParamsForLogs(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				Name:            "critical",
-				TargetValue:     &[]float64{0.0}[0],
-				MatchType:       ruletypes.AtleastOnce,
-				CompareOperator: ruletypes.ValueIsNotEq,
+				TargetValue:     postableRule.RuleCondition.Target,
+				MatchType:       postableRule.RuleCondition.MatchType,
+				CompareOperator: postableRule.RuleCondition.CompareOperator,
 			},
 		},
 	}
@@ -238,7 +239,10 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			SelectedQuery: "A",
+			CompareOperator: ruletypes.ValueIsNotEq,
+			MatchType:       ruletypes.AtleastOnce,
+			Target:          &[]float64{0.0}[0],
+			SelectedQuery:   "A",
 		},
 		Version: "v5",
 	}
@@ -248,10 +252,9 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				Name:            "critical",
-				TargetValue:     &[]float64{0.0}[0],
-				MatchType:       ruletypes.AtleastOnce,
-				CompareOperator: ruletypes.ValueIsNotEq,
+				TargetValue:     postableRule.RuleCondition.Target,
+				MatchType:       postableRule.RuleCondition.MatchType,
+				CompareOperator: postableRule.RuleCondition.CompareOperator,
 			},
 		},
 	}
@@ -301,7 +304,10 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			SelectedQuery: "A",
+			CompareOperator: ruletypes.ValueIsNotEq,
+			MatchType:       ruletypes.AtleastOnce,
+			Target:          &[]float64{0.0}[0],
+			SelectedQuery:   "A",
 		},
 		Version: "v5",
 	}
@@ -311,10 +317,9 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				Name:            "critical",
-				TargetValue:     &[]float64{0.0}[0],
-				MatchType:       ruletypes.AtleastOnce,
-				CompareOperator: ruletypes.ValueIsNotEq,
+				TargetValue:     postableRule.RuleCondition.Target,
+				MatchType:       postableRule.RuleCondition.MatchType,
+				CompareOperator: postableRule.RuleCondition.CompareOperator,
 			},
 		},
 	}
@@ -361,7 +366,10 @@ func TestPrepareParamsForTraces(t *testing.T) {
 					},
 				},
 			},
-			SelectedQuery: "A",
+			CompareOperator: ruletypes.ValueIsNotEq,
+			MatchType:       ruletypes.AtleastOnce,
+			Target:          &[]float64{0.0}[0],
+			SelectedQuery:   "A",
 		},
 	}
 
@@ -370,10 +378,9 @@ func TestPrepareParamsForTraces(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				Name:            "critical",
-				TargetValue:     &[]float64{0.0}[0],
-				MatchType:       ruletypes.AtleastOnce,
-				CompareOperator: ruletypes.ValueIsNotEq,
+				TargetValue:     postableRule.RuleCondition.Target,
+				MatchType:       postableRule.RuleCondition.MatchType,
+				CompareOperator: postableRule.RuleCondition.CompareOperator,
 			},
 		},
 	}
@@ -463,7 +470,6 @@ func TestThresholdRuleLabelNormalization(t *testing.T) {
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
 				{
-					Name:            "critical",
 					TargetValue:     &c.target,
 					MatchType:       c.matchType,
 					CompareOperator: c.compareOperator,
@@ -647,7 +653,11 @@ 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{
@@ -857,7 +867,11 @@ 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{
@@ -961,7 +975,11 @@ 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{
@@ -1065,7 +1083,11 @@ 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{
@@ -1234,7 +1256,11 @@ 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{
@@ -1904,6 +1930,8 @@ 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{{
@@ -2022,6 +2050,7 @@ 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{
@@ -2030,8 +2059,8 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 				{
 					Name:            postableRule.AlertName.StringValue(),
 					TargetValue:     &c.target,
-					MatchType:       ruletypes.AtleastOnce,
-					CompareOperator: ruletypes.ValueIsAbove,
+					MatchType:       rc.MatchType,
+					CompareOperator: rc.CompareOperator,
 				},
 			},
 		}

pkg/ruler/handler.go

@@ -3,6 +3,7 @@ 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,6 +25,24 @@ 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()
@@ -54,7 +72,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -93,7 +111,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -112,7 +130,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -138,7 +156,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -157,7 +175,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -261,7 +279,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -304,7 +322,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -334,7 +352,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -418,7 +436,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 
@@ -454,7 +472,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"))
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
 

pkg/signoz/provider.go

@@ -267,7 +267,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddGCPConnectionMethodFactory(),
 		sqlmigration.NewDeleteOrphanSARolesFactory(),
 		sqlmigration.NewAddRoutePolicyTuplesFactory(sqlstore),
-		sqlmigration.NewMigrateRulesV1ToV2Alpha1Factory(sqlstore),
 	)
 }
 

pkg/sqlmigration/141_migrate_rules_v1_to_v2alpha1.go

@@ -1,602 +0,0 @@
-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, err := convertRule(storedRule.ID, storedRuleData, storedRoute)
-		if 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
-		}
-		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, error) {
-	if storedRuleData.RuleCondition == nil {
-		return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition in stored rule data is null")
-	}
-	channels := []string{}
-	if storedRoute != nil {
-		channels = storedRoute.Channels
-	}
-
-	rule := storedRuleData.clone()
-	rule.fillDurationDefaults()
-	rule.deriveAlertType()
-	rule.deriveQueryType()
-	rule.repairPanelType()
-	rule.disableUnmetMinPoints()
-	rule.deriveRuleType()
-	rule.negateAnomalyBelowTarget()
-	convertedRoute := rule.repairEmptySeverity(ruleID, storedRoute)
-	rule.relocateThreshold(channels)
-	rule.relocateEvaluation()
-	rule.synthesizeNotificationSettings()
-	rule.SchemaVersion = schemaVersionV2Alpha1
-	rule.clearV1Fields()
-
-	return rule, convertedRoute, nil
-}
-
-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     json.RawMessage `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 two envelope keys the derivations need.
-type ruleQueryEnvelope struct {
-	Type string `json:"type"`
-	Spec struct {
-		Signal string `json:"signal"`
-	} `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 compositeQuery or one with no
-// queries, 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.CompositeQuery == nil:
-		causes = append(causes, "condition.compositeQuery is null")
-	case len(rule.decodeQueryEnvelopes()) == 0:
-		causes = append(causes, "condition.compositeQuery.queries is empty")
-	}
-	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
-	}
-}
-
-// 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.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
-	rule.RuleCondition.Target = nil
-	rule.RuleCondition.CompareOperator = ""
-	rule.RuleCondition.MatchType = ""
-	rule.RuleCondition.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,6 +619,10 @@ 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/rulestatehistorytypes/query.go

@@ -32,10 +32,5 @@ 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,9 +1,6 @@
 package ruletypes
 
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
+import "github.com/SigNoz/signoz/pkg/valuer"
 
 type AlertState struct {
 	valuer.String
@@ -29,15 +26,6 @@ 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,7 +5,6 @@ import (
 	"sort"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -78,15 +77,6 @@ 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
 
@@ -109,15 +99,6 @@ 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."`
 
@@ -128,13 +109,18 @@ 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."`
 	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" 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,omitempty" 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" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
+	Thresholds        *RuleThresholdData   `json:"thresholds,omitempty" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
 }
 
 func (rc *RuleCondition) SelectedQueryName() string {

pkg/types/ruletypes/api_params.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"slices"
-	"strings"
 	"time"
 	"unicode/utf8"
 
@@ -13,7 +12,6 @@ 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"
@@ -51,6 +49,7 @@ func (t AlertType) BuilderQueryType() qbtypes.QueryType {
 }
 
 const (
+	DefaultSchemaVersion  = "v1"
 	SchemaVersionV2Alpha1 = "v2alpha1"
 )
 
@@ -62,10 +61,12 @@ 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."`
+	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."`
 
 	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."`
@@ -75,12 +76,14 @@ 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" required:"true" description:"The evaluation window, as a kind and spec."`
-	SchemaVersion string              `json:"schemaVersion" required:"true" enum:"v2alpha1" description:"The rule payload schema."`
+	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."`
 
-	NotificationSettings *NotificationSettings `json:"notificationSettings" required:"true" description:"Grouping, re-notification and routing behaviour."`
+	NotificationSettings *NotificationSettings `json:"notificationSettings,omitempty" required:"true" description:"Grouping, re-notification and routing behaviour."`
 }
 
 type NotificationSettings struct {
@@ -225,15 +228,101 @@ 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, QueryTypeClickHouseSQL:
+		case QueryTypeBuilder:
 			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)
 	}
 }
 
@@ -247,20 +336,6 @@ 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,
@@ -301,6 +376,10 @@ 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))
@@ -344,9 +423,11 @@ func (r *PostableRule) Validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.AlertType == "" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "alertType: field is required"))
-	} else {
+	if r.Version != "v5" {
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
+	}
+
+	if r.AlertType != "" {
 		switch r.AlertType {
 		case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces:
 		default:
@@ -371,12 +452,6 @@ 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 {
@@ -387,9 +462,7 @@ func (r *PostableRule) Validate() error {
 		}
 	}
 
-	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 {
+	if r.RuleCondition.SelectedQuery != "" && 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 {
@@ -441,43 +514,74 @@ 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 %q",
-			r.SchemaVersion, SchemaVersionV2Alpha1)}
+			"schemaVersion: unsupported value %q; must be one of %q, %q",
+			r.SchemaVersion, DefaultSchemaVersion, 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,
@@ -487,24 +591,11 @@ 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.
@@ -565,6 +656,31 @@ 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
@@ -593,3 +709,28 @@ 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,8 +3,10 @@ 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"
@@ -27,7 +29,8 @@ func TestParseIntoRule(t *testing.T) {
 				"alertType": "METRIC_BASED_ALERT",
 				"description": "Test description",
 				"ruleType": "threshold_rule",
-				"schemaVersion": "v2alpha1",
+				"evalWindow": "5m",
+				"frequency": "1m",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -42,11 +45,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"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"]}}
+					"target": 10.0,
+					"matchType": "1",
+					"op": "1",
+					"selectedQuery": "A"
+				}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -60,6 +63,46 @@ 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)
+				}
 			},
 		},
 		{
@@ -67,7 +110,6 @@ func TestParseIntoRule(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "PromQLRule",
-				"schemaVersion": "v2alpha1",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -81,11 +123,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"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"]}}
+					"target": 10.0,
+					"matchType": "1",
+					"op": "1",
+					"selectedQuery": "A"
+				}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -96,6 +138,9 @@ 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")
+				}
 			},
 		},
 	}
@@ -132,6 +177,233 @@ 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{},
@@ -373,19 +645,19 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"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"]}}
+					"target": 100.0,
+					"matchType": "1",
+					"op": "1"
+				}
 			}`),
 			kind:                RuleDataKindJson,
 			expectValidateError: true,
 		},
 		{
-			name:     "missing schema version - rejected on write",
+			name:     "default schema version - defaults to v1 behavior",
 			initRule: PostableRule{},
 			content: []byte(`{
-				"alert": "MissingSchemaTest",
+				"alert": "DefaultSchemaTest",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -400,13 +672,24 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"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"]}}
+					"target": 75.0,
+					"matchType": "1",
+					"op": "1"
+				}
 			}`),
-			kind:                RuleDataKindJson,
-			expectValidateError: true,
+			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")
+				}
+			},
 		},
 	}
 
@@ -454,7 +737,11 @@ func TestParseIntoRuleThresholdGeneration(t *testing.T) {
 					}
 				}]
 			},
-			"selectedQueryName": "A",
+			"target": 100.0,
+			"matchType": "1",
+			"op": "1",
+			"selectedQuery": "A",
+			"targetUnit": "ms",
 			"thresholds": {
 				"kind": "basic",
 				"spec": [
@@ -619,3 +906,449 @@ 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,9 +29,6 @@ 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 {
@@ -39,13 +36,6 @@ 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")
@@ -70,10 +60,6 @@ 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."`
@@ -342,9 +328,6 @@ 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,11 +33,6 @@ 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.
@@ -47,15 +42,6 @@ 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"} {
+	for _, field := range []string{"labels", "annotations", "description", "preferredChannels", "evalWindow", "frequency"} {
 		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, `""`, string(body["version"]))
+	assert.JSONEq(t, `"v5"`, string(body["version"]))
 
 	var condition struct {
 		Thresholds struct {
@@ -297,7 +297,6 @@ 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,6 +85,9 @@ 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:
@@ -127,9 +130,6 @@ 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,37 +170,6 @@ 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,12 +54,6 @@ 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/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/v2/rules"),
+            signoz.self.host_configs["8080"].get("/api/v1/rules"),
             json=rule_data,
             headers={"Authorization": f"Bearer {admin_token}"},
             timeout=5,
         )
-        assert response.status_code == HTTPStatus.CREATED, f"Failed to create rule, api returned {response.status_code} with response: {response.text}"
+        assert response.status_code == HTTPStatus.OK, 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/v2/rules/{rule_id}"),
+            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule_id}"),
             headers={"Authorization": f"Bearer {admin_token}"},
             timeout=5,
         )
-        if response.status_code != HTTPStatus.NO_CONTENT:
+        if response.status_code != HTTPStatus.OK:
             raise Exception(  # pylint: disable=broad-exception-raised
                 f"Failed to delete rule, api returned {response.status_code} with response: {response.text}"
             )
@@ -156,22 +156,19 @@ 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/v3/rules"),
-        params={"limit": 200},
+        signoz.self.host_configs["8080"].get("/api/v2/rules"),
         headers={"Authorization": f"Bearer {token}"},
         timeout=5,
     )
     assert response.status_code == HTTPStatus.OK
-    for rule in response.json()["data"]["rules"]:
+    for rule in response.json()["data"]:
         delete_response = requests.delete(
-            signoz.self.host_configs["8080"].get(f"/api/v2/rules/{rule['id']}"),
+            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule['id']}"),
             headers={"Authorization": f"Bearer {token}"},
             timeout=5,
         )
-        assert delete_response.status_code == HTTPStatus.NO_CONTENT, f"failed to delete rule {rule['id']}: {delete_response.text}"
+        assert delete_response.status_code == HTTPStatus.OK, f"failed to delete rule {rule['id']}: {delete_response.text}"
 
 
 @pytest.fixture(name="seed_alert_rules", scope="function")

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

@@ -573,3 +573,24 @@ 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

@@ -1,426 +0,0 @@
-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_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/08_threshold_validation.py

@@ -1,119 +0,0 @@
-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": [],
-        },
-    }