fix: 400 on malformed JSON, missing alertType, unknown enums

# Conflicts:
#	pkg/query-service/app/http_handler.go

docs/api/openapi.yml

@@ -9535,35 +9535,34 @@ components:
           type: string
         disabled:
           type: boolean
-        evalWindow:
-          type: string
         evaluation:
           $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
-        frequency:
-          type: string
         labels:
           additionalProperties:
             type: string
           type: object
         notificationSettings:
           $ref: '#/components/schemas/RuletypesNotificationSettings'
-        preferredChannels:
-          items:
-            type: string
-          type: array
         ruleType:
           $ref: '#/components/schemas/RuletypesRuleType'
         schemaVersion:
+          enum:
+          - v2alpha1
           type: string
         source:
+          deprecated: true
           type: string
         version:
+          deprecated: true
           type: string
       required:
       - alert
       - alertType
       - ruleType
       - condition
+      - evaluation
+      - schemaVersion
+      - notificationSettings
       type: object
     RuletypesPostableRuleView:
       properties:
@@ -9624,12 +9623,8 @@ components:
           type: string
         disabled:
           type: boolean
-        evalWindow:
-          type: string
         evaluation:
           $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
-        frequency:
-          type: string
         id:
           type: string
         labels:
@@ -9638,15 +9633,14 @@ components:
           type: object
         notificationSettings:
           $ref: '#/components/schemas/RuletypesNotificationSettings'
-        preferredChannels:
-          items:
-            type: string
-          type: array
         ruleType:
           $ref: '#/components/schemas/RuletypesRuleType'
         schemaVersion:
+          enum:
+          - v2alpha1
           type: string
         source:
+          deprecated: true
           type: string
         state:
           $ref: '#/components/schemas/RuletypesAlertState'
@@ -9656,6 +9650,7 @@ components:
         updatedBy:
           type: string
         version:
+          deprecated: true
           type: string
       required:
       - id
@@ -9664,6 +9659,9 @@ components:
       - alertType
       - ruleType
       - condition
+      - evaluation
+      - schemaVersion
+      - notificationSettings
       type: object
     RuletypesRuleCondition:
       properties:
@@ -9676,10 +9674,6 @@ components:
           type: string
         compositeQuery:
           $ref: '#/components/schemas/RuletypesAlertCompositeQuery'
-        matchType:
-          $ref: '#/components/schemas/RuletypesMatchType'
-        op:
-          $ref: '#/components/schemas/RuletypesCompareOperator'
         requireMinPoints:
           type: boolean
         requiredNumPoints:
@@ -9688,16 +9682,11 @@ components:
           $ref: '#/components/schemas/RuletypesSeasonality'
         selectedQueryName:
           type: string
-        target:
-          format: double
-          nullable: true
-          type: number
-        targetUnit:
-          type: string
         thresholds:
           $ref: '#/components/schemas/RuletypesRuleThresholdData'
       required:
       - compositeQuery
+      - thresholds
       type: object
     RuletypesRuleThresholdData:
       discriminator:
@@ -22318,56 +22307,6 @@ paths:
       - rules
       x-signoz-stability: alpha
   /api/v2/rules:
-    get:
-      deprecated: true
-      description: 'This endpoint lists all alert rules with their current evaluation
-        state. Deprecated: use ListRulesV3, which supports filtering, sorting and
-        pagination.'
-      operationId: ListRules
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/RuletypesRule'
-                    type: array
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List alert rules
-      tags:
-      - rules
-      x-signoz-stability: alpha
     post:
       deprecated: false
       description: This endpoint creates a new alert rule
@@ -22526,13 +22465,13 @@ paths:
                   schemaVersion: v2alpha1
                   version: v5
               metric_anomaly:
-                description: Anomaly rules are not yet supported under schemaVersion
-                  v2alpha1, so this example uses the v1 shape. Wraps a builder query
-                  in the `anomaly` function with daily seasonality SigNoz compares
-                  each point against the forecast for that time of day. Fires when
-                  the anomaly score stays below the threshold for the entire window;
-                  `requireMinPoints` guards against noisy intervals.
-                summary: Metric anomaly rule (v1 only)
+                description: Wraps a builder query in the `anomaly` function with
+                  daily seasonality, so SigNoz compares each point against the forecast
+                  for that time of day. The threshold is compared against the signed
+                  anomaly score, so `below` with a target of -2 fires when an abrupt
+                  drop holds for the entire window; `requireMinPoints` guards against
+                  noisy intervals.
+                summary: Metric anomaly rule
                 value:
                   alert: Anomalous drop in ingested spans
                   alertType: METRIC_BASED_ALERT
@@ -22567,22 +22506,36 @@ paths:
                           stepInterval: 21600
                         type: builder_query
                       queryType: builder
-                    matchType: all_the_times
-                    op: below
                     requireMinPoints: true
                     requiredNumPoints: 3
                     seasonality: daily
                     selectedQueryName: A
-                    target: 2
+                    thresholds:
+                      kind: basic
+                      spec:
+                      - channels:
+                        - slack-ingestion
+                        matchType: all_the_times
+                        name: warning
+                        op: below
+                        target: -2
                   description: Detect an abrupt drop in span ingestion using a z-score
                     anomaly function
-                  evalWindow: 24h
-                  frequency: 3h
+                  evaluation:
+                    kind: rolling
+                    spec:
+                      evalWindow: 24h
+                      frequency: 3h
                   labels:
                     severity: warning
-                  preferredChannels:
-                  - slack-ingestion
+                  notificationSettings:
+                    renotify:
+                      alertStates:
+                      - firing
+                      enabled: true
+                      interval: 4h
                   ruleType: anomaly_rule
+                  schemaVersion: v2alpha1
                   version: v5
               metric_promql:
                 description: PromQL expression instead of the builder. Dotted OTEL
@@ -23478,13 +23431,13 @@ paths:
                   schemaVersion: v2alpha1
                   version: v5
               metric_anomaly:
-                description: Anomaly rules are not yet supported under schemaVersion
-                  v2alpha1, so this example uses the v1 shape. Wraps a builder query
-                  in the `anomaly` function with daily seasonality SigNoz compares
-                  each point against the forecast for that time of day. Fires when
-                  the anomaly score stays below the threshold for the entire window;
-                  `requireMinPoints` guards against noisy intervals.
-                summary: Metric anomaly rule (v1 only)
+                description: Wraps a builder query in the `anomaly` function with
+                  daily seasonality, so SigNoz compares each point against the forecast
+                  for that time of day. The threshold is compared against the signed
+                  anomaly score, so `below` with a target of -2 fires when an abrupt
+                  drop holds for the entire window; `requireMinPoints` guards against
+                  noisy intervals.
+                summary: Metric anomaly rule
                 value:
                   alert: Anomalous drop in ingested spans
                   alertType: METRIC_BASED_ALERT
@@ -23519,22 +23472,36 @@ paths:
                           stepInterval: 21600
                         type: builder_query
                       queryType: builder
-                    matchType: all_the_times
-                    op: below
                     requireMinPoints: true
                     requiredNumPoints: 3
                     seasonality: daily
                     selectedQueryName: A
-                    target: 2
+                    thresholds:
+                      kind: basic
+                      spec:
+                      - channels:
+                        - slack-ingestion
+                        matchType: all_the_times
+                        name: warning
+                        op: below
+                        target: -2
                   description: Detect an abrupt drop in span ingestion using a z-score
                     anomaly function
-                  evalWindow: 24h
-                  frequency: 3h
+                  evaluation:
+                    kind: rolling
+                    spec:
+                      evalWindow: 24h
+                      frequency: 3h
                   labels:
                     severity: warning
-                  preferredChannels:
-                  - slack-ingestion
+                  notificationSettings:
+                    renotify:
+                      alertStates:
+                      - firing
+                      enabled: true
+                      interval: 4h
                   ruleType: anomaly_rule
+                  schemaVersion: v2alpha1
                   version: v5
               metric_promql:
                 description: PromQL expression instead of the builder. Dotted OTEL
@@ -24331,13 +24298,13 @@ paths:
                   schemaVersion: v2alpha1
                   version: v5
               metric_anomaly:
-                description: Anomaly rules are not yet supported under schemaVersion
-                  v2alpha1, so this example uses the v1 shape. Wraps a builder query
-                  in the `anomaly` function with daily seasonality SigNoz compares
-                  each point against the forecast for that time of day. Fires when
-                  the anomaly score stays below the threshold for the entire window;
-                  `requireMinPoints` guards against noisy intervals.
-                summary: Metric anomaly rule (v1 only)
+                description: Wraps a builder query in the `anomaly` function with
+                  daily seasonality, so SigNoz compares each point against the forecast
+                  for that time of day. The threshold is compared against the signed
+                  anomaly score, so `below` with a target of -2 fires when an abrupt
+                  drop holds for the entire window; `requireMinPoints` guards against
+                  noisy intervals.
+                summary: Metric anomaly rule
                 value:
                   alert: Anomalous drop in ingested spans
                   alertType: METRIC_BASED_ALERT
@@ -24372,22 +24339,36 @@ paths:
                           stepInterval: 21600
                         type: builder_query
                       queryType: builder
-                    matchType: all_the_times
-                    op: below
                     requireMinPoints: true
                     requiredNumPoints: 3
                     seasonality: daily
                     selectedQueryName: A
-                    target: 2
+                    thresholds:
+                      kind: basic
+                      spec:
+                      - channels:
+                        - slack-ingestion
+                        matchType: all_the_times
+                        name: warning
+                        op: below
+                        target: -2
                   description: Detect an abrupt drop in span ingestion using a z-score
                     anomaly function
-                  evalWindow: 24h
-                  frequency: 3h
+                  evaluation:
+                    kind: rolling
+                    spec:
+                      evalWindow: 24h
+                      frequency: 3h
                   labels:
                     severity: warning
-                  preferredChannels:
-                  - slack-ingestion
+                  notificationSettings:
+                    renotify:
+                      alertStates:
+                      - firing
+                      enabled: true
+                      interval: 4h
                   ruleType: anomaly_rule
+                  schemaVersion: v2alpha1
                   version: v5
               metric_promql:
                 description: PromQL expression instead of the builder. Dotted OTEL
@@ -25762,13 +25743,13 @@ paths:
                   schemaVersion: v2alpha1
                   version: v5
               metric_anomaly:
-                description: Anomaly rules are not yet supported under schemaVersion
-                  v2alpha1, so this example uses the v1 shape. Wraps a builder query
-                  in the `anomaly` function with daily seasonality SigNoz compares
-                  each point against the forecast for that time of day. Fires when
-                  the anomaly score stays below the threshold for the entire window;
-                  `requireMinPoints` guards against noisy intervals.
-                summary: Metric anomaly rule (v1 only)
+                description: Wraps a builder query in the `anomaly` function with
+                  daily seasonality, so SigNoz compares each point against the forecast
+                  for that time of day. The threshold is compared against the signed
+                  anomaly score, so `below` with a target of -2 fires when an abrupt
+                  drop holds for the entire window; `requireMinPoints` guards against
+                  noisy intervals.
+                summary: Metric anomaly rule
                 value:
                   alert: Anomalous drop in ingested spans
                   alertType: METRIC_BASED_ALERT
@@ -25803,22 +25784,36 @@ paths:
                           stepInterval: 21600
                         type: builder_query
                       queryType: builder
-                    matchType: all_the_times
-                    op: below
                     requireMinPoints: true
                     requiredNumPoints: 3
                     seasonality: daily
                     selectedQueryName: A
-                    target: 2
+                    thresholds:
+                      kind: basic
+                      spec:
+                      - channels:
+                        - slack-ingestion
+                        matchType: all_the_times
+                        name: warning
+                        op: below
+                        target: -2
                   description: Detect an abrupt drop in span ingestion using a z-score
                     anomaly function
-                  evalWindow: 24h
-                  frequency: 3h
+                  evaluation:
+                    kind: rolling
+                    spec:
+                      evalWindow: 24h
+                      frequency: 3h
                   labels:
                     severity: warning
-                  preferredChannels:
-                  - slack-ingestion
+                  notificationSettings:
+                    renotify:
+                      alertStates:
+                      - firing
+                      enabled: true
+                      interval: 4h
                   ruleType: anomaly_rule
+                  schemaVersion: v2alpha1
                   version: v5
               metric_promql:
                 description: PromQL expression instead of the builder. Dotted OTEL

ee/query-service/rules/anomaly.go

@@ -105,15 +105,15 @@ func (r *AnomalyRule) Type() ruletypes.RuleType {
 }
 
 func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) *qbtypes.QueryRangeRequest {
-	r.logger.InfoContext(
-		ctx, "prepare query range request", slog.Int64("ts", ts.UnixMilli()),
-		slog.Int64("eval.window_ms", r.EvalWindow().Milliseconds()),
-		slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()),
-	)
-
 	startTs, endTs := r.Timestamps(ts)
 	start, end := startTs.UnixMilli(), endTs.UnixMilli()
 
+	r.logger.InfoContext(
+		ctx, "prepare query range request", slog.Int64("ts", ts.UnixMilli()),
+		slog.Int64("eval.window_ms", end-start),
+		slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()),
+	)
+
 	req := &qbtypes.QueryRangeRequest{
 		Start:       uint64(start),
 		End:         uint64(end),
@@ -423,12 +423,10 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 func (r *AnomalyRule) String() string {
 
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.Name()),
-		RuleCondition:     r.Condition(),
-		EvalWindow:        r.EvalWindow(),
-		Labels:            r.Labels().Map(),
-		Annotations:       r.Annotations().Map(),
-		PreferredChannels: r.PreferredChannels(),
+		AlertName:     valuer.NewDisplayName(r.Name()),
+		RuleCondition: r.Condition(),
+		Labels:        r.Labels().Map(),
+		Annotations:   r.Annotations().Map(),
 	}
 
 	byt, err := json.Marshal(ar)

ee/query-service/rules/anomaly_test.go

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

frontend/src/pages/DashboardPage/DashboardContainer/VariablesBar/__tests__/ValueSelector.test.tsx

@@ -193,40 +193,6 @@ describe('ValueSelector', () => {
 
 			expect(onSearch).toHaveBeenLastCalledWith('pay');
 		});
-
-		it('commits ALL even when the selection holds a value outside the list', async () => {
-			// A search pick, or one an older time window offered: ALL must still go out as
-			// `__all__`, not as a list that filters the panels to the truncated options.
-			const onChange = jest.fn();
-			const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
-			render(
-				<ValueSelector
-					options={OPTIONS}
-					variableType="dynamic"
-					multiSelect
-					showAllOption
-					selection={{ value: ['searched'], allSelected: false }}
-					onChange={onChange}
-					emptyFallback={{ value: null, allSelected: true }}
-					testId="variable-select-env"
-					dynamic={{
-						values: OPTIONS,
-						relatedValues: [],
-						complete: false,
-						onSearch: jest.fn(),
-						onSearchReset: jest.fn(),
-					}}
-				/>,
-			);
-
-			await openDropdown();
-			await user.click(screen.getByText('ALL'));
-			await user.keyboard('{Escape}');
-
-			expect(onChange).toHaveBeenLastCalledWith(
-				expect.objectContaining({ allSelected: true }),
-			);
-		});
 	});
 
 	describe('clearing', () => {

frontend/src/pages/DashboardPage/DashboardContainer/VariablesBar/__tests__/selectionUtils.test.ts

@@ -12,7 +12,6 @@ function commit(
 		values,
 		options: OPTIONS,
 		showAllOption: true,
-		isDynamic: false,
 		emptyFallback: FALLBACK,
 		...overrides,
 	});
@@ -61,20 +60,6 @@ describe('selectionFromCommittedValues', () => {
 		});
 	});
 
-	// A dynamic ALL is sent as `__all__`, so reading it as a list would filter the
-	// panels down to the truncated option set.
-	it('reads every option PLUS a value outside the list as ALL for a dynamic variable', () => {
-		expect(
-			commit([...OPTIONS, 'searched'], { isDynamic: true }).allSelected,
-		).toBe(true);
-	});
-
-	it('does not read a dynamic subset PLUS a value outside the list as ALL', () => {
-		expect(
-			commit(['checkout', 'searched'], { isDynamic: true }).allSelected,
-		).toBe(false);
-	});
-
 	// Derived from the values + options at commit time, never from the old selection.
 	it('recomputes the marker: a typed value the data now offers is a normal pick', () => {
 		expect(

frontend/src/pages/DashboardPage/DashboardContainer/VariablesBar/components/selectors/ValueSelector.tsx

@@ -102,7 +102,6 @@ function ValueSelector({
 			values,
 			options,
 			showAllOption,
-			isDynamic: !!dynamic,
 			emptyFallback,
 		});
 

frontend/src/pages/DashboardPage/DashboardContainer/VariablesBar/utils/selectionUtils.ts

@@ -51,7 +51,6 @@ interface CommittedValues {
 	values: string[];
 	options: string[];
 	showAllOption: boolean;
-	isDynamic: boolean;
 	emptyFallback: VariableSelection;
 }
 
@@ -63,7 +62,6 @@ export function selectionFromCommittedValues({
 	values,
 	options,
 	showAllOption,
-	isDynamic,
 	emptyFallback,
 }: CommittedValues): VariableSelection {
 	if (values.length === 0) {
@@ -73,12 +71,10 @@ export function selectionFromCommittedValues({
 	const customValues = values.filter((value) => !options.includes(value));
 	// ALL re-materializes to the option set, so a set carrying a typed value is not ALL
 	// — the next refetch would expand it back and drop what the user typed.
-	// A dynamic ALL travels as `__all__` and is never re-materialized, so a value outside
-	// its truncated list (a search pick, an older window's pick) loses nothing.
 	const allSelected =
 		showAllOption &&
 		options.length > 0 &&
-		(isDynamic || customValues.length === 0) &&
+		customValues.length === 0 &&
 		options.every((option) => values.includes(option));
 
 	return {

frontend/src/pages/TraceDetailsV3/EntityMetadata/EntityMetadataItem.tsx

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
-import { Tooltip, TooltipProps } from '@signozhq/ui/tooltip';
+import { Tooltip } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
 
 import styles from './EntityMetadataItem.module.scss';
 
 interface EntityMetadataItemProps {
-	tooltip: TooltipProps['title'];
+	tooltip: string;
 	icon?: ReactNode;
 	children: ReactNode;
 }

frontend/src/pages/TraceDetailsV3/EntityMetadata/EntityMetadataRow.module.scss

@@ -8,12 +8,3 @@
 	// Keep Typography.Text at the row's size (it reads this var, not inherited font-size).
 	--typography-font-size: var(--periscope-font-size-base);
 }
-
-.tokenTooltip {
-	composes: tooltipBody from '../shared.module.scss';
-	min-width: 180px;
-}
-
-.tokenTooltipTitle {
-	padding-bottom: var(--spacing-4);
-}

frontend/src/pages/TraceDetailsV3/EntityMetadata/EntityMetadataRow.tsx

@@ -1,18 +1,10 @@
-import { CalendarClock, Coins, Landmark, Server, Timer } from '@signozhq/icons';
+import { CalendarClock, Server, Timer } from '@signozhq/icons';
 import { Badge } from '@signozhq/ui/badge';
 import cx from 'classnames';
 import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
 import HttpStatusBadge from 'components/HttpStatusBadge/HttpStatusBadge';
 
-import {
-	AiTokenCounts,
-	formatCost,
-	formatTokens,
-	getTotalInputTokens,
-	hasValue,
-} from '../utils/aiTraceUtils';
 import EntityMetadataItem from './EntityMetadataItem';
-import TokenUsageTooltip from './TokenUsageTooltip';
 
 import styles from './EntityMetadataRow.module.scss';
 
@@ -24,8 +16,6 @@ interface EntityMetadataRowProps {
 	execTimePercent?: number;
 	timestamp?: string;
 	statusCode?: string | number;
-	tokens?: AiTokenCounts;
-	cost?: number | null;
 }
 
 const ICON_SIZE = 14;
@@ -42,11 +32,8 @@ function EntityMetadataRow({
 	execTimePercent,
 	timestamp,
 	statusCode,
-	tokens,
-	cost,
 }: EntityMetadataRowProps): JSX.Element {
 	const entityLabel = entity === 'trace' ? 'Trace' : 'Span';
-	const totalInput = tokens && getTotalInputTokens(tokens);
 	const durationTooltip =
 		entity === 'trace' ? 'Trace Duration' : 'Span Duration';
 	// Single source of duration formatting so both rows label units identically.
@@ -104,24 +91,6 @@ function EntityMetadataRow({
 					<HttpStatusBadge statusCode={statusCode} />
 				</EntityMetadataItem>
 			)}
-
-			{tokens && (
-				<EntityMetadataItem
-					tooltip={<TokenUsageTooltip tokens={tokens} />}
-					icon={<Coins size={ICON_SIZE} />}
-				>
-					Tokens: {formatTokens(totalInput)} → {formatTokens(tokens.output)}
-				</EntityMetadataItem>
-			)}
-
-			{hasValue(cost) && (
-				<EntityMetadataItem
-					tooltip="Total cost"
-					icon={<Landmark size={ICON_SIZE} />}
-				>
-					Cost — {formatCost(cost)}
-				</EntityMetadataItem>
-			)}
 		</div>
 	);
 }
@@ -133,8 +102,6 @@ EntityMetadataRow.defaultProps = {
 	execTimePercent: undefined,
 	timestamp: undefined,
 	statusCode: undefined,
-	tokens: undefined,
-	cost: undefined,
 };
 
 export default EntityMetadataRow;

frontend/src/pages/TraceDetailsV3/EntityMetadata/TokenUsageTooltip.tsx

@@ -1,35 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-
-import TokenBreakdown from '../TokenBreakdown/TokenBreakdown';
-import { AiTokenCounts } from '../utils/aiTraceUtils';
-
-import styles from './EntityMetadataRow.module.scss';
-
-interface TokenUsageTooltipProps {
-	tokens: AiTokenCounts;
-}
-
-function TokenUsageTooltip({ tokens }: TokenUsageTooltipProps): JSX.Element {
-	const { input, output, cacheRead, cacheWrite, reasoning } = tokens;
-
-	return (
-		<div className={styles.tokenTooltip}>
-			<Typography.Text
-				size="small"
-				weight="normal"
-				className={styles.tokenTooltipTitle}
-			>
-				Usage Breakdown
-			</Typography.Text>
-			<TokenBreakdown
-				input={input}
-				output={output}
-				cacheRead={cacheRead}
-				cacheWrite={cacheWrite}
-				reasoning={reasoning}
-			/>
-		</div>
-	);
-}
-
-export default TokenUsageTooltip;

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/SpanSummary.tsx

@@ -1,11 +1,9 @@
-import { useMemo } from 'react';
 import { Link2 } from '@signozhq/icons';
 import dayjs from 'dayjs';
 import KeyValueLabel from 'periscope/components/KeyValueLabel';
 import { SpanV3 } from 'types/api/trace/getTraceV3';
 
 import EntityMetadataRow from '../EntityMetadata/EntityMetadataRow';
-import { getAIUsageDetails, convertToAiTokens } from '../utils/aiTraceUtils';
 import { HIGHLIGHTED_OPTIONS } from './config';
 import {
 	LinkedSpansPanel,
@@ -33,10 +31,6 @@ function SpanSummary({
 }: SpanSummaryProps): JSX.Element {
 	const percentile = useSpanPercentile(selectedSpan);
 	const linkedSpans = useLinkedSpans((selectedSpan as any).references);
-	const aiUsage = useMemo(
-		() => getAIUsageDetails(selectedSpan)?.usage,
-		[selectedSpan],
-	);
 
 	return (
 		<>
@@ -69,8 +63,6 @@ function SpanSummary({
 							: undefined
 					}
 					timestamp={dayjs(selectedSpan.timestamp).format('HH:mm:ss — MMM D, YYYY')}
-					tokens={aiUsage && convertToAiTokens(aiUsage)}
-					cost={aiUsage?.cost}
 				/>
 
 				<div className={styles.spanInfoItem}>

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/__tests__/SpanSummary.test.tsx

@@ -95,26 +95,4 @@ describe('SpanSummary', () => {
 
 		expect(screen.queryByText(/of total exec time/)).not.toBeInTheDocument();
 	});
-
-	it('renders tokens and cost from the gen_ai usage attributes', () => {
-		const span = {
-			...createMockSpan(),
-			attributes: {
-				'gen_ai.usage.input_tokens': 1000,
-				'gen_ai.usage.output_tokens': 9,
-				'signoz.gen_ai.usage.tokens.cost': 0.000009,
-			},
-		};
-		render(<SpanSummary selectedSpan={span} />);
-
-		expect(screen.getByText(/Tokens: 1,000 → 9/)).toBeInTheDocument();
-		expect(screen.getByText(/Cost — \$ 0.000009/)).toBeInTheDocument();
-	});
-
-	it('omits tokens and cost for non-AI spans', () => {
-		render(<SpanSummary selectedSpan={createMockSpan()} />);
-
-		expect(screen.queryByText(/Tokens:/)).not.toBeInTheDocument();
-		expect(screen.queryByText(/Cost —/)).not.toBeInTheDocument();
-	});
 });

frontend/src/pages/TraceDetailsV3/SpanHintBadge/SpanHintBadge.tsx

@@ -1,37 +0,0 @@
-import { Badge } from '@signozhq/ui/badge';
-import HttpStatusBadge from 'components/HttpStatusBadge/HttpStatusBadge';
-import { SpanV3 } from 'types/api/trace/getTraceV3';
-
-import { getAiSpanKind } from '../utils/aiTraceUtils';
-import { AI_SPAN_BADGES } from './constants';
-
-interface SpanHintBadgeProps {
-	span: SpanV3;
-}
-
-function SpanHintBadge({ span }: SpanHintBadgeProps): JSX.Element | null {
-	const aiSpanKind = getAiSpanKind(span);
-
-	if (aiSpanKind) {
-		const { label, color } = AI_SPAN_BADGES[aiSpanKind];
-		return (
-			<span style={{ display: 'inline-flex' }}>
-				<Badge
-					variant="outlined"
-					color={color}
-					testId={`span-hint-badge-${aiSpanKind}`}
-				>
-					{label}
-				</Badge>
-			</span>
-		);
-	}
-
-	if (!span.response_status_code) {
-		return null;
-	}
-
-	return <HttpStatusBadge statusCode={span.response_status_code} />;
-}
-
-export default SpanHintBadge;

frontend/src/pages/TraceDetailsV3/SpanHintBadge/constants.ts

@@ -1,12 +0,0 @@
-import type { BadgeColorType } from '@signozhq/ui/badge';
-
-import { AiSpanKind } from '../utils/aiTraceUtils';
-
-export const AI_SPAN_BADGES: Record<
-	AiSpanKind,
-	{ label: string; color: BadgeColorType }
-> = {
-	[AiSpanKind.Llm]: { label: 'LLM', color: 'success' },
-	[AiSpanKind.Tool]: { label: 'TOOL', color: 'warning' },
-	[AiSpanKind.Agent]: { label: 'AGENT', color: 'highlight-danger' },
-};

frontend/src/pages/TraceDetailsV3/SpanHoverCard/EventTooltipContent.module.scss

@@ -8,12 +8,16 @@
 	display: inline-flex;
 	align-items: center;
 	gap: 4px;
+	background: var(--l2-background);
+	border: 1px solid var(--l2-border);
 	border-radius: 3px;
+	padding: 2px 6px;
 	font-size: 10px;
 	font-weight: 600;
 	text-transform: uppercase;
 	letter-spacing: 0.5px;
 	color: var(--l2-foreground);
+	margin-bottom: 6px;
 }
 
 .name {

frontend/src/pages/TraceDetailsV3/SpanHoverCard/SpanHoverCard.module.scss

@@ -9,17 +9,28 @@
 }
 
 .content {
-	composes: tooltipBody from '../shared.module.scss';
-	min-width: 223px;
-	max-width: 360px;
+	font-size: 12px;
+	color: var(--l1-foreground);
 }
 
-.title {
-	composes: tooltipTitle from '../shared.module.scss';
+.name {
+	font-weight: 600;
+	margin-bottom: 4px;
 }
 
-.header {
-	display: flex;
-	flex-direction: column;
-	padding-bottom: var(--spacing-2);
+.row {
+	line-height: 1.5;
+	color: var(--l2-foreground);
+}
+
+.preview {
+	// container for additional preview rows
+}
+
+.previewKey {
+	color: var(--l2-foreground);
+}
+
+.previewValue {
+	color: var(--l1-foreground);
 }

frontend/src/pages/TraceDetailsV3/SpanHoverCard/SpanHoverCard.tsx

@@ -1,5 +1,4 @@
 import { Tooltip } from '@signozhq/ui/tooltip';
-import { Typography } from '@signozhq/ui/typography';
 import { convertTimeToRelevantUnit } from 'utils/traceUtils';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useTraceStore } from 'pages/TraceDetailsV3/stores/traceStore';
@@ -8,11 +7,6 @@ import { useMemo } from 'react';
 import { SpanV3 } from 'types/api/trace/getTraceV3';
 import { toFixed } from 'utils/toFixed';
 
-import { getAIUsageDetails, SpanAiDetails } from '../utils/aiTraceUtils';
-import SpanUsageBreakdown from './SpanUsageBreakdown';
-import TraceTooltipRow from '../TraceTooltip/TraceTooltipRow';
-import TraceTooltipSection from '../TraceTooltip/TraceTooltipSection';
-
 import styles from './SpanHoverCard.module.scss';
 
 /**
@@ -39,7 +33,6 @@ export interface SpanTooltipContentProps {
 	relativeStartMs: number;
 	durationMs: number;
 	previewRows?: SpanPreviewRow[];
-	ai?: SpanAiDetails;
 }
 
 export function SpanTooltipContent({
@@ -49,60 +42,33 @@ export function SpanTooltipContent({
 	relativeStartMs,
 	durationMs,
 	previewRows,
-	ai,
 }: SpanTooltipContentProps): JSX.Element {
 	const { time: formattedDuration, timeUnitName } =
 		convertTimeToRelevantUnit(durationMs);
 
 	return (
 		<div className={styles.content}>
-			<div className={styles.header}>
-				<Typography.Text
-					className={styles.title}
-					size="small"
-					weight="normal"
-					style={{ color }}
-				>
-					{spanName}
-				</Typography.Text>
-				{ai?.usage && (
-					<Typography.Text size="small" weight="normal">
-						Usage Breakdown
-					</Typography.Text>
-				)}
+			<div className={styles.name} style={{ color }}>
+				{spanName}
+			</div>
+			<div className={styles.row}>status: {hasError ? 'error' : 'ok'}</div>
+			<div className={styles.row}>start: {toFixed(relativeStartMs, 2)} ms</div>
+			<div className={styles.row}>
+				duration: {toFixed(formattedDuration, 2)} {timeUnitName}
 			</div>
-			{ai?.usage && <SpanUsageBreakdown usage={ai.usage} />}
-			<TraceTooltipSection>
-				{ai?.model && <TraceTooltipRow label="model" value={ai.model} />}
-				{ai?.toolName && <TraceTooltipRow label="tool" value={ai.toolName} />}
-				{ai?.agentName && <TraceTooltipRow label="agent" value={ai.agentName} />}
-				<TraceTooltipRow
-					label="status"
-					value={hasError ? 'error' : 'ok'}
-					testId="span-hover-card-status"
-				/>
-				<TraceTooltipRow
-					label="start"
-					value={`${toFixed(relativeStartMs, 2)} ms`}
-					testId="span-hover-card-start"
-				/>
-				<TraceTooltipRow
-					label="duration"
-					value={`${toFixed(formattedDuration, 2)} ${timeUnitName}`}
-					testId="span-hover-card-duration"
-				/>
-			</TraceTooltipSection>
 			{previewRows && previewRows.length > 0 && (
-				<TraceTooltipSection>
+				<div className={styles.preview}>
 					{previewRows.map((row) => (
-						<TraceTooltipRow
+						<div
 							key={row.key}
-							label={row.key}
-							value={row.value}
-							testId={`span-hover-card-preview-${row.key}`}
-						/>
+							className={styles.row}
+							data-testid={`span-hover-card-preview-${row.key}`}
+						>
+							<span className={styles.previewKey}>{row.key}:</span>{' '}
+							<span className={styles.previewValue}>{row.value}</span>
+						</div>
 					))}
-				</TraceTooltipSection>
+				</div>
 			)}
 		</div>
 	);
@@ -164,7 +130,6 @@ export function SpanHoverCard({
 				relativeStartMs: span.timestamp - traceStartTime,
 				durationMs: span.duration_nano / 1e6,
 				previewRows,
-				ai: getAIUsageDetails(span),
 			},
 		};
 	}, [

frontend/src/pages/TraceDetailsV3/SpanHoverCard/SpanUsageBreakdown.tsx

@@ -1,38 +0,0 @@
-import { formatCost, hasValue, SpanAiUsage } from '../utils/aiTraceUtils';
-import TokenBreakdown from '../TokenBreakdown/TokenBreakdown';
-import TraceTooltipRow from '../TraceTooltip/TraceTooltipRow';
-import TraceTooltipSection from '../TraceTooltip/TraceTooltipSection';
-
-interface SpanUsageBreakdownProps {
-	usage: SpanAiUsage;
-}
-
-function SpanUsageBreakdown({ usage }: SpanUsageBreakdownProps): JSX.Element {
-	const {
-		inputTokens,
-		outputTokens,
-		cacheReadTokens,
-		cacheCreationTokens,
-		reasoningTokens,
-		cost,
-	} = usage;
-
-	return (
-		<>
-			<TokenBreakdown
-				input={inputTokens}
-				output={outputTokens}
-				cacheRead={cacheReadTokens}
-				cacheWrite={cacheCreationTokens}
-				reasoning={reasoningTokens}
-			/>
-			{hasValue(cost) && (
-				<TraceTooltipSection>
-					<TraceTooltipRow isHeading label="Cost" value={formatCost(cost)} />
-				</TraceTooltipSection>
-			)}
-		</>
-	);
-}
-
-export default SpanUsageBreakdown;

frontend/src/pages/TraceDetailsV3/TokenBreakdown/TokenBreakdown.tsx

@@ -1,81 +0,0 @@
-import {
-	AiTokenCounts,
-	formatTokens,
-	getTokenLabel,
-	getTotalInputTokens,
-} from '../utils/aiTraceUtils';
-import TraceTooltipRow from '../TraceTooltip/TraceTooltipRow';
-import TraceTooltipSection from '../TraceTooltip/TraceTooltipSection';
-
-type TokenBreakdownProps = AiTokenCounts;
-
-function TokenBreakdown({
-	input,
-	output,
-	cacheRead,
-	cacheWrite,
-	reasoning,
-}: TokenBreakdownProps): JSX.Element {
-	const totalInput = getTotalInputTokens({ input, cacheRead, cacheWrite });
-
-	return (
-		<>
-			<TraceTooltipSection>
-				<TraceTooltipRow
-					label={getTokenLabel('Total Input', totalInput)}
-					value={formatTokens(totalInput)}
-					isHeading
-				/>
-				<TraceTooltipRow
-					label={getTokenLabel('Cache Read', cacheRead)}
-					value={formatTokens(cacheRead)}
-					isNested
-				/>
-				<TraceTooltipRow
-					label={getTokenLabel('Cache Write', cacheWrite)}
-					value={formatTokens(cacheWrite)}
-					isNested
-				/>
-				<TraceTooltipRow
-					label={getTokenLabel('Input', input)}
-					value={formatTokens(input)}
-					isNested
-				/>
-			</TraceTooltipSection>
-
-			<TraceTooltipSection>
-				<TraceTooltipRow
-					label={getTokenLabel('Reasoning', reasoning)}
-					value={formatTokens(reasoning)}
-					isHeading
-				/>
-			</TraceTooltipSection>
-
-			<TraceTooltipSection>
-				<TraceTooltipRow
-					label={getTokenLabel('Output', output)}
-					value={formatTokens(output)}
-					isHeading
-				/>
-			</TraceTooltipSection>
-
-			<TraceTooltipSection>
-				<TraceTooltipRow
-					label="Total Token Usage"
-					value={formatTokens(totalInput + (output ?? 0))}
-					isHeading
-				/>
-			</TraceTooltipSection>
-		</>
-	);
-}
-
-TokenBreakdown.defaultProps = {
-	input: undefined,
-	output: undefined,
-	cacheRead: undefined,
-	cacheWrite: undefined,
-	reasoning: undefined,
-};
-
-export default TokenBreakdown;

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/TraceDetailsHeader.tsx

@@ -186,8 +186,6 @@ function TraceDetailsHeader({
 								DATE_TIME_FORMATS.DD_MMM_YYYY_HH_MM_SS,
 							)}
 							statusCode={traceSummary.rootSpanStatusCode}
-							tokens={traceSummary.ai?.tokens}
-							cost={traceSummary.ai?.totalCost}
 						/>
 					) : (
 						<DetailsLoader />

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/__tests__/TraceDetailsHeader.test.tsx

@@ -1,7 +1,6 @@
 import { fireEvent, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
-import type { SpantypesGettableTraceSummaryDTO } from 'api/generated/services/sigNoz.schemas';
 import ROUTES from 'constants/routes';
 import { render } from 'tests/test-utils';
 
@@ -177,19 +176,9 @@ describe('TraceDetailsHeader – trace metadata row', () => {
 		hasMissingSpans: false,
 		totalSpansCount: 42,
 		totalErrorSpansCount: 0,
-		ai: {
-			tokens: {
-				input: 12040,
-				output: 3110,
-				cacheRead: 0,
-				cacheWrite: 0,
-				reasoning: 0,
-			},
-			totalCost: 0.0421,
-		},
 	};
 
-	const mockSummary = (data?: SpantypesGettableTraceSummaryDTO): void => {
+	const mockSummary = (data?: typeof traceMetadata): void => {
 		jest.mocked(useTraceSummary).mockReturnValue({ data, isLoading: false });
 	};
 
@@ -212,77 +201,6 @@ describe('TraceDetailsHeader – trace metadata row', () => {
 		expect(screen.getByText(duration)).toBeInTheDocument();
 	});
 
-	it('renders AI tokens and cost when the summary has them', () => {
-		mockSummary(traceMetadata);
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.getByText('Tokens: 12,040 → 3,110')).toBeInTheDocument();
-		expect(screen.getByText('Cost — $ 0.0421')).toBeInTheDocument();
-	});
-
-	it('omits AI tokens and cost when the summary has no ai field', () => {
-		mockSummary({ ...traceMetadata, ai: undefined });
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.queryByText(/^Tokens:/)).not.toBeInTheDocument();
-		expect(screen.queryByText(/^Cost —/)).not.toBeInTheDocument();
-	});
-
-	it('shows AI tokens when input and output are both zero', () => {
-		mockSummary({
-			...traceMetadata,
-			ai: {
-				...traceMetadata.ai,
-				tokens: { ...traceMetadata.ai.tokens, input: 0, output: 0 },
-			},
-		} as SpantypesGettableTraceSummaryDTO);
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.getByText('Tokens: 0 → 0')).toBeInTheDocument();
-		expect(screen.getByText('Cost — $ 0.0421')).toBeInTheDocument();
-	});
-
-	it('shows zero for a missing input', () => {
-		mockSummary({
-			...traceMetadata,
-			ai: {
-				...traceMetadata.ai,
-				tokens: { ...traceMetadata.ai.tokens, input: undefined },
-			},
-		} as unknown as SpantypesGettableTraceSummaryDTO);
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.getByText('Tokens: 0 → 3,110')).toBeInTheDocument();
-	});
-
-	it('shows zero AI tokens when input and output are both missing', () => {
-		mockSummary({
-			...traceMetadata,
-			ai: {
-				...traceMetadata.ai,
-				tokens: {
-					...traceMetadata.ai.tokens,
-					input: undefined,
-					output: undefined,
-				},
-			},
-		} as unknown as SpantypesGettableTraceSummaryDTO);
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.getByText('Tokens: 0 → 0')).toBeInTheDocument();
-	});
-
-	it('omits the cost when the summary sends null', () => {
-		mockSummary({
-			...traceMetadata,
-			ai: { ...traceMetadata.ai, totalCost: null },
-		} as unknown as SpantypesGettableTraceSummaryDTO);
-		render(<TraceDetailsHeader {...baseProps} showTraceDetailsHeaderOptions />);
-
-		expect(screen.getByText('Tokens: 12,040 → 3,110')).toBeInTheDocument();
-		expect(screen.queryByText(/^Cost —/)).not.toBeInTheDocument();
-	});
-
 	it('is shown by default and can be hidden / shown again via the Trace options menu', async () => {
 		const user = userEvent.setup({ delay: null });
 		mockSummary(traceMetadata);

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/FlamegraphCanvas.module.scss

@@ -30,9 +30,13 @@
 // lives here. Shares visual treatment with the waterfall hover popover
 // but is positioned `fixed` instead of anchored.
 .tooltip {
-	composes: tooltipSurface from '../shared.module.scss';
 	position: fixed;
 	z-index: 1000;
 	pointer-events: none;
+	background-color: var(--l1-background);
+	padding: 8px 12px;
+	border-radius: 4px;
+	box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+	border: 1px solid var(--l2-border);
 	color: var(--l1-foreground);
 }

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/FlamegraphCanvas.tsx

@@ -8,7 +8,6 @@ import { EventTooltipContent } from '../SpanHoverCard/EventTooltipContent';
 import { SpanTooltipContent } from '../SpanHoverCard/SpanHoverCard';
 import { DEFAULT_ROW_HEIGHT } from './constants';
 import { useCanvasSetup } from './hooks/useCanvasSetup';
-import { useCursorTooltipPosition } from './hooks/useCursorTooltipPosition';
 import { useFlamegraphCrosshair } from './hooks/useFlamegraphCrosshair';
 import { useFlamegraphDrag } from './hooks/useFlamegraphDrag';
 import { useFlamegraphDraw } from './hooks/useFlamegraphDraw';
@@ -201,11 +200,15 @@ function FlamegraphCanvas(props: FlamegraphCanvasProps): JSX.Element {
 		handleHoverMouseLeave,
 	]);
 
-	const tooltipRef = useCursorTooltipPosition<HTMLDivElement>(tooltipContent);
-
 	const tooltipElement = tooltipContent
 		? createPortal(
-				<div ref={tooltipRef} className={styles.tooltip}>
+				<div
+					className={styles.tooltip}
+					style={{
+						left: Math.min(tooltipContent.clientX + 15, window.innerWidth - 220),
+						top: Math.min(tooltipContent.clientY + 15, window.innerHeight - 100),
+					}}
+				>
 					{tooltipContent.event ? (
 						<EventTooltipContent
 							eventName={tooltipContent.event.name}

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useCursorTooltipPosition.ts

@@ -1,36 +0,0 @@
-import { RefObject, useLayoutEffect, useRef } from 'react';
-
-const CURSOR_OFFSET = 15;
-
-interface CursorAnchor {
-	clientX: number;
-	clientY: number;
-}
-
-function resolveAxis(cursor: number, size: number, viewport: number): number {
-	const after = cursor + CURSOR_OFFSET;
-	if (after + size <= viewport) {
-		return after;
-	}
-	return Math.max(0, cursor - CURSOR_OFFSET - size);
-}
-
-/** Places a fixed element beside the cursor, flipping sides when it would overflow the viewport. */
-export function useCursorTooltipPosition<T extends HTMLElement>(
-	anchor: CursorAnchor | null,
-): RefObject<T> {
-	const ref = useRef<T>(null);
-
-	useLayoutEffect(() => {
-		const el = ref.current;
-		if (!el || !anchor) {
-			return;
-		}
-		const left = resolveAxis(anchor.clientX, el.offsetWidth, window.innerWidth);
-		const top = resolveAxis(anchor.clientY, el.offsetHeight, window.innerHeight);
-		el.style.left = `${left}px`;
-		el.style.top = `${top}px`;
-	}, [anchor]);
-
-	return ref;
-}

frontend/src/pages/TraceDetailsV3/TraceTooltip/TraceTooltip.module.scss

@@ -1,47 +0,0 @@
-.section {
-	display: flex;
-	flex-direction: column;
-	gap: var(--spacing-2);
-	padding: var(--spacing-2) 0;
-	border-top: 1px solid;
-	border-image: linear-gradient(
-			90deg,
-			var(--l3-background-transparent),
-			var(--l3-border),
-			var(--l3-background-transparent)
-		)
-		1;
-}
-
-.section:first-child {
-	padding-top: 0;
-	border-top: none;
-}
-
-.section:last-child {
-	padding-bottom: 0;
-}
-
-.row {
-	display: grid;
-	grid-template-columns: auto auto;
-	justify-content: space-between;
-	column-gap: var(--spacing-2);
-	min-width: 0;
-}
-
-.nestedRow {
-	padding-left: var(--spacing-6);
-}
-
-.rowLabel {
-	min-width: 0;
-	overflow-wrap: anywhere;
-}
-
-.rowValue {
-	min-width: 0;
-	overflow-wrap: anywhere;
-	text-align: right;
-	font-variant-numeric: tabular-nums;
-}

frontend/src/pages/TraceDetailsV3/TraceTooltip/TraceTooltipRow.tsx

@@ -1,42 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-
-import styles from './TraceTooltip.module.scss';
-
-interface TraceTooltipRowProps {
-	label: string;
-	value?: string;
-	isNested?: boolean;
-	isHeading?: boolean;
-	testId?: string;
-}
-
-function TraceTooltipRow({
-	label,
-	value,
-	isNested,
-	isHeading,
-	testId,
-}: TraceTooltipRowProps): JSX.Element {
-	return (
-		<div
-			className={cx(styles.row, isNested && styles.nestedRow)}
-			data-testid={testId}
-		>
-			<Typography.Text
-				size="small"
-				color={isHeading ? undefined : 'muted'}
-				className={styles.rowLabel}
-			>
-				{label}
-			</Typography.Text>
-			{value !== undefined && (
-				<Typography.Text size="small" className={styles.rowValue}>
-					{value}
-				</Typography.Text>
-			)}
-		</div>
-	);
-}
-
-export default TraceTooltipRow;

frontend/src/pages/TraceDetailsV3/TraceTooltip/TraceTooltipSection.tsx

@@ -1,15 +0,0 @@
-import { ReactNode } from 'react';
-
-import styles from './TraceTooltip.module.scss';
-
-interface TraceTooltipSectionProps {
-	children: ReactNode;
-}
-
-function TraceTooltipSection({
-	children,
-}: TraceTooltipSectionProps): JSX.Element {
-	return <div className={styles.section}>{children}</div>;
-}
-
-export default TraceTooltipSection;

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Success.module.scss

@@ -203,9 +203,8 @@
 .statusCell {
 	display: flex;
 	align-items: center;
-	justify-content: flex-start;
+	justify-content: center;
 	cursor: pointer;
-	padding-left: var(--spacing-2);
 
 	--badge-border-radius: 2px;
 	--badge-padding: 3px 6px;
@@ -395,11 +394,6 @@
 	}
 }
 
-.aiSpanIcon {
-	flex-shrink: 0;
-	margin: 0 var(--spacing-2);
-}
-
 .treeLabel {
 	color: var(--l1-foreground);
 	font-family: 'Inter';

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Success.tsx

@@ -20,6 +20,7 @@ import {
 } from '@tanstack/react-table';
 import { useVirtualizer, Virtualizer } from '@tanstack/react-virtual';
 import cx from 'classnames';
+import HttpStatusBadge from 'components/HttpStatusBadge/HttpStatusBadge';
 import TimelineV3 from 'components/TimelineV3/TimelineV3';
 import { convertTimeToRelevantUnit } from 'utils/traceUtils';
 import { useCopySpanLink } from 'hooks/trace/useCopySpanLink';
@@ -27,13 +28,7 @@ import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { colorToRgb } from 'lib/uPlotLib/utils/generateColor';
-import {
-	ChevronDown,
-	ChevronRight,
-	Link,
-	ListPlus,
-	Sparkle,
-} from '@signozhq/icons';
+import { ChevronDown, ChevronRight, Link, ListPlus } from '@signozhq/icons';
 import { useTraceStore } from 'pages/TraceDetailsV3/stores/traceStore';
 import { resolveSpanColor } from 'pages/TraceDetailsV3/utils';
 import { useBoundaryPagination } from 'pages/TraceDetailsV3/TraceWaterfall/hooks/useBoundaryPagination';
@@ -44,8 +39,6 @@ import { toFixed } from 'utils/toFixed';
 
 import { EventTooltipContent } from '../../../SpanHoverCard/EventTooltipContent';
 import { SpanHoverCard } from '../../../SpanHoverCard/SpanHoverCard';
-import SpanHintBadge from '../../../SpanHintBadge/SpanHintBadge';
-import { isAiSpan } from '../../../utils/aiTraceUtils';
 import AddSpanToFunnelModal from '../../AddSpanToFunnelModal/AddSpanToFunnelModal';
 import { IInterestedSpan } from '../../types';
 
@@ -325,23 +318,14 @@ const SpanOverview = memo(function SpanOverview({
 			</span>
 
 			{/* Colored service dot */}
-			{isAiSpan(span) ? (
-				<Sparkle
-					size={10}
-					color={effectiveColor}
-					fill={effectiveColor}
-					className={styles.aiSpanIcon}
-				/>
-			) : (
-				<span
-					className={cx(styles.treeIcon, { [styles.hasError]: span.has_error })}
-					style={
-						{
-							'--service-dot-color': effectiveColor,
-						} as React.CSSProperties
-					}
-				/>
-			)}
+			<span
+				className={cx(styles.treeIcon, { [styles.hasError]: span.has_error })}
+				style={
+					{
+						'--service-dot-color': effectiveColor,
+					} as React.CSSProperties
+				}
+			/>
 
 			{/* Span name + service name */}
 			<span className={styles.treeLabel}>
@@ -960,7 +944,9 @@ function Success(props: ISuccessProps): JSX.Element {
 									onMouseLeave={(): void => applyHoverClass(null)}
 									onClick={(): void => handleSpanClick(span)}
 								>
-									<SpanHintBadge span={span} />
+									{span.response_status_code && (
+										<HttpStatusBadge statusCode={span.response_status_code} />
+									)}
 								</div>
 							);
 						})}

frontend/src/pages/TraceDetailsV3/shared.module.scss

@@ -1,20 +0,0 @@
-.tooltipBody {
-	display: flex;
-	flex-direction: column;
-	letter-spacing: var(--paragraph-small-400-letter-spacing);
-	color: var(--l1-foreground-hover);
-}
-
-.tooltipTitle {
-	font-family: 'SF Mono', 'Geist Mono', monospace;
-	word-break: break-all;
-}
-
-.tooltipSurface {
-	background-color: color-mix(in srgb, var(--l3-background) 60%, transparent);
-	border: 1px solid var(--l2-border);
-	border-radius: var(--radius-2);
-	padding: var(--spacing-4);
-	box-shadow: 4px 10px 16px 2px rgba(0, 0, 0, 0.2);
-	backdrop-filter: blur(20px);
-}

frontend/src/pages/TraceDetailsV3/stories/TraceDetailsV3.stories.mocks.tsx

@@ -46,8 +46,6 @@ import {
 	traceDetailFieldValues,
 	traceFlamegraphResponse,
 	traceSummaryResponse,
-	TRACE_SCENARIOS,
-	type TraceScenario,
 	traceWaterfallResponse,
 } from './__story_mockdata__/traceDetails';
 
@@ -105,13 +103,6 @@ const spanLogScopeOf = (body: QueryRangeRequestV5): SpanLogScope => {
 
 export const traceDetailsMocks = defineStoryMocks({
 	controls: {
-		scenario: choiceControl<TraceScenario>('Scenario', {
-			group: TRACE,
-			description:
-				'The spans the trace is built from: a checkout, one span per HTTP status badge, or an agent run with LLM, tool and agent spans and the AI totals in the header.',
-			options: TRACE_SCENARIOS,
-			value: 'checkout',
-		}),
 		spans: countControl('Spans', {
 			group: TRACE,
 			description:
@@ -160,7 +151,6 @@ export const traceDetailsMocks = defineStoryMocks({
 	},
 	handlers: (values, response) => {
 		const trace = {
-			scenario: values.scenario,
 			spans: values.spans,
 			errors: values.errors,
 			traceStart: traceStartOf(),
@@ -298,7 +288,7 @@ export const traceDetailsMocks = defineStoryMocks({
 	},
 	config: (values) => ({
 		route: values.spanPanel
-			? `/trace/${STORY_TRACE_ID}?spanId=${spanIdAt(focusSpanIndex(values.scenario, values.spans))}`
+			? `/trace/${STORY_TRACE_ID}?spanId=${spanIdAt(focusSpanIndex(values.spans))}`
 			: `/trace/${STORY_TRACE_ID}`,
 	}),
 	effect: (values) => {

frontend/src/pages/TraceDetailsV3/stories/TraceDetailsV3.stories.tsx

@@ -13,12 +13,7 @@ import {
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
-import {
-	focusSpanIndex,
-	scenarioSpanCount,
-	spanIdAt,
-	STORY_TRACE_ID,
-} from './__story_mockdata__/traceDetails';
+import { STORY_TRACE_ID } from './__story_mockdata__/traceDetails';
 import {
 	openRowMenu,
 	startDownload,
@@ -101,40 +96,6 @@ export const BottomStripLoading: Story = {
 	args: { bottomStrip: true, dataState: 'loading' },
 };
 
-/**
- * One span per HTTP status badge the waterfall draws: informational, success,
- * redirect, client and server errors, and a span with no status code and so no
- * badge.
- */
-export const StatusCodes: Story = {
-	args: {
-		scenario: 'status-codes',
-		spans: scenarioSpanCount('status-codes'),
-		spanPanel: false,
-	},
-};
-
-const AI_SPANS = scenarioSpanCount('ai');
-
-/**
- * An agent run: LLM, tool and agent badges with sparkle icons in the waterfall,
- * token and cost totals in the header, the span panel on an LLM call with its
- * tokens and cost, and that span's hover card open on its usage breakdown.
- */
-export const AiTrace: Story = {
-	args: { scenario: 'ai', spans: AI_SPANS },
-	play: async ({ canvasElement }): Promise<void> => {
-		const row = await within(canvasElement).findByTestId(
-			`cell-0-${spanIdAt(focusSpanIndex('ai', AI_SPANS))}`,
-			undefined,
-			untilLoaded,
-		);
-
-		await fireEvent.mouseOver(row);
-		await screen.findByText('Usage Breakdown', undefined, untilLoaded);
-	},
-};
-
 /**
  * Turns on Highlight errors, which writes `has_error = true` into the filter and
  * expands the bar to show it.

frontend/src/pages/TraceDetailsV3/stories/__story_mockdata__/traceDetails.ts

@@ -23,10 +23,6 @@ interface SpanTemplate {
 	name: string;
 	kind: string;
 	failing?: boolean;
-	/** The span the panel opens on when nothing fails. */
-	focus?: boolean;
-	/** `response_status_code`; failing spans default to 503, the rest to 200. */
-	statusCode?: string;
 	attributes: Record<string, string | number | boolean>;
 }
 
@@ -127,145 +123,6 @@ const SPAN_TEMPLATES: SpanTemplate[] = [
 	},
 ];
 
-/** One span per badge colour, plus a span with no status code and so no badge. */
-const STATUS_CODE_TEMPLATES: SpanTemplate[] = [
-	['200', 'GET /status/ok'],
-	['101', 'GET /ws/upgrade'],
-	['201', 'POST /status/created'],
-	['204', 'DELETE /status/no-content'],
-	['301', 'GET /status/moved'],
-	['304', 'GET /status/not-modified'],
-	['400', 'POST /status/bad-request'],
-	['401', 'GET /status/unauthorized'],
-	['404', 'GET /status/not-found'],
-	['429', 'GET /status/rate-limited'],
-	['500', 'GET /status/internal-error'],
-	['502', 'GET /status/bad-gateway'],
-	['503', 'GET /status/unavailable'],
-	['504', 'GET /status/timeout'],
-	['', 'internal.compute'],
-].map(
-	([statusCode, name]): SpanTemplate => ({
-		service: 'status-api',
-		name,
-		kind: statusCode ? 'Server' : 'Internal',
-		failing: Number(statusCode) >= 500,
-		statusCode,
-		attributes: statusCode
-			? {
-					'http.method': name.split(' ')[0],
-					'http.status_code': Number(statusCode),
-				}
-			: {},
-	}),
-);
-
-/**
- * An agent run: agent, LLM and tool spans, each badged by kind. The LLM spans
- * cover cache counted inside input (OpenAI), cache counted beside it
- * (Anthropic), reasoning, and an embedding with input only.
- */
-const AI_TEMPLATES: SpanTemplate[] = [
-	{
-		service: 'support-agent',
-		name: 'invoke_agent support-agent',
-		kind: 'Internal',
-		attributes: { 'gen_ai.agent.name': 'support-agent' },
-	},
-	{
-		service: 'support-agent',
-		name: 'chat gpt-4o',
-		kind: 'Client',
-		attributes: {
-			'gen_ai.request.model': 'gpt-4o-2024-08-06',
-			'gen_ai.usage.input_tokens': 1840,
-			'gen_ai.usage.output_tokens': 212,
-			'gen_ai.usage.cache_read.input_tokens': 1024,
-			'gen_ai.usage.cache_creation.input_tokens': 0,
-			'signoz.gen_ai.usage.tokens.cost': 0.00566,
-		},
-	},
-	{
-		service: 'support-agent',
-		name: 'execute_tool search_docs',
-		kind: 'Internal',
-		attributes: { 'gen_ai.tool.name': 'search_docs' },
-	},
-	{
-		service: 'support-agent',
-		name: 'chat claude-sonnet-4',
-		kind: 'Client',
-		focus: true,
-		attributes: {
-			'gen_ai.request.model': 'claude-sonnet-4-20250514',
-			'gen_ai.usage.input_tokens': 86,
-			'gen_ai.usage.output_tokens': 640,
-			'gen_ai.usage.cache_read.input_tokens': 4200,
-			'gen_ai.usage.cache_creation.input_tokens': 1300,
-			'signoz.gen_ai.usage.tokens.cost': 0.01853,
-		},
-	},
-	{
-		service: 'docs-api',
-		name: 'GET /docs/search',
-		kind: 'Server',
-		attributes: {
-			'http.method': 'GET',
-			'http.route': '/docs/search',
-			'http.status_code': 200,
-		},
-	},
-	{
-		service: 'support-agent',
-		name: 'execute_tool fetch_ticket',
-		kind: 'Internal',
-		failing: true,
-		attributes: { 'gen_ai.tool.name': 'fetch_ticket' },
-	},
-	{
-		service: 'support-agent',
-		name: 'invoke_agent triage-agent',
-		kind: 'Internal',
-		attributes: { 'gen_ai.agent.name': 'triage-agent' },
-	},
-	{
-		service: 'support-agent',
-		name: 'embeddings text-embedding-3-small',
-		kind: 'Client',
-		attributes: {
-			'gen_ai.request.model': 'text-embedding-3-small',
-			'gen_ai.usage.input_tokens': 312,
-			'signoz.gen_ai.usage.tokens.cost': 0.00000624,
-		},
-	},
-	{
-		service: 'support-agent',
-		name: 'chat o3-mini',
-		kind: 'Client',
-		attributes: {
-			'gen_ai.request.model': 'o3-mini-2025-01-31',
-			'gen_ai.usage.input_tokens': 920,
-			'gen_ai.usage.output_tokens': 1480,
-			'gen_ai.usage.reasoning.output_tokens': 1152,
-			'signoz.gen_ai.usage.tokens.cost': 0.007524,
-		},
-	},
-];
-
-export const TRACE_SCENARIOS = ['checkout', 'status-codes', 'ai'] as const;
-
-export type TraceScenario = (typeof TRACE_SCENARIOS)[number];
-
-const SCENARIO_TEMPLATES: Record<TraceScenario, SpanTemplate[]> = {
-	checkout: SPAN_TEMPLATES,
-	'status-codes': STATUS_CODE_TEMPLATES,
-	ai: AI_TEMPLATES,
-};
-
-/** Spans it takes for the scenario to show every template once. */
-export const scenarioSpanCount = (scenario: TraceScenario): number =>
-	SCENARIO_TEMPLATES[scenario].length;
-
 const TRACE_SERVICES = [
 	...new Set(SPAN_TEMPLATES.map(({ service }) => service)),
 ];
@@ -289,7 +146,6 @@ interface BuiltSpan {
 }
 
 interface TraceOptions {
-	scenario: TraceScenario;
 	spans: number;
 	errors: boolean;
 	/** Epoch milliseconds the root span starts at. */
@@ -300,33 +156,24 @@ export const spanIdAt = (index: number): string =>
 	`b17e${index.toString(16).padStart(12, '0')}`;
 
 /**
- * The span the story opens the panel on: the scenario's focus span, else the
- * first failing one, so its events and error styling are on screen, and the
- * root when neither is in the trace.
+ * The span the story opens the panel on: the first failing one, so its events
+ * and error styling are on screen, and the root when nothing fails.
  */
-export const focusSpanIndex = (
-	scenario: TraceScenario,
-	spans: number,
-): number => {
-	const templates = SCENARIO_TEMPLATES[scenario];
-	const focus = templates.findIndex((template) => template.focus);
-	const failing = templates.findIndex((template) => template.failing);
-	const index = focus >= 0 ? focus : failing;
+export const focusSpanIndex = (spans: number): number => {
+	const failing = SPAN_TEMPLATES.findIndex(({ failing }) => failing);
 
-	return index >= 0 && index < spans ? index : 0;
+	return failing >= 0 && failing < spans ? failing : 0;
 };
 
 const buildSpans = ({
-	scenario,
 	spans,
 	errors,
 	traceStart,
 }: TraceOptions): BuiltSpan[] => {
 	const built: BuiltSpan[] = [];
-	const templates = SCENARIO_TEMPLATES[scenario];
 
 	for (let index = 0; index < spans; index += 1) {
-		const template = templates[index % templates.length];
+		const template = SPAN_TEMPLATES[index % SPAN_TEMPLATES.length];
 		const parent = index === 0 ? undefined : built[parentIndexOf(index)];
 		// Children fit inside their parent's window, second child after the first,
 		// so no span outlives its parent and no two siblings overlap.
@@ -410,8 +257,7 @@ const waterfallSpan = (span: BuiltSpan): SpantypesWaterfallSpanDTO => ({
 	status_code: span.hasError ? 2 : 1,
 	status_code_string: span.hasError ? 'Error' : 'Ok',
 	status_message: span.hasError ? 'upstream unavailable' : '',
-	response_status_code:
-		span.template.statusCode ?? (span.hasError ? '503' : '200'),
+	response_status_code: span.hasError ? '503' : '200',
 	has_children: span.hasChildren,
 	sub_tree_node_count: span.subTreeNodeCount,
 	level: span.level,
@@ -458,36 +304,6 @@ export const traceWaterfallResponse = (
 	};
 };
 
-const numberAttribute = (span: BuiltSpan, key: string): number =>
-	Number(span.template.attributes[key] ?? 0);
-
-/** The trace's AI totals, summed over its spans the way the backend does. */
-const traceAiSummary = (
-	spans: BuiltSpan[],
-): GetTraceSummary200['data']['ai'] => {
-	const aiSpans = spans.filter(({ template }) =>
-		Object.keys(template.attributes).some((key) => key.includes('gen_ai.')),
-	);
-
-	if (aiSpans.length === 0) {
-		return undefined;
-	}
-
-	const sum = (key: string): number =>
-		aiSpans.reduce((total, span) => total + numberAttribute(span, key), 0);
-
-	return {
-		tokens: {
-			input: sum('gen_ai.usage.input_tokens'),
-			output: sum('gen_ai.usage.output_tokens'),
-			cacheRead: sum('gen_ai.usage.cache_read.input_tokens'),
-			cacheWrite: sum('gen_ai.usage.cache_creation.input_tokens'),
-			reasoning: sum('gen_ai.usage.reasoning.output_tokens'),
-		},
-		totalCost: sum('signoz.gen_ai.usage.tokens.cost'),
-	};
-};
-
 export const traceSummaryResponse = (
 	options: TraceOptions & { missingSpans: boolean },
 ): GetTraceSummary200 => {
@@ -505,7 +321,6 @@ export const traceSummaryResponse = (
 			totalSpansCount: spans.length,
 			totalErrorSpansCount: spans.filter(({ hasError }) => hasError).length,
 			hasMissingSpans: options.missingSpans,
-			ai: traceAiSummary(spans),
 		},
 	};
 };
@@ -657,7 +472,7 @@ export const spanLogRows = (
 ): RawRow[] => {
 	const step = ROOT_DURATION_MS / Math.max(count, 1);
 	const spans = buildSpans(options);
-	const focus = spans[focusSpanIndex(options.scenario, options.spans)];
+	const focus = spans[focusSpanIndex(options.spans)];
 
 	return Array.from({ length: count }, (_, index) => {
 		const at = options.traceStart + SCOPE_OFFSET_MS[scope] + index * step;

frontend/src/pages/TraceDetailsV3/utils.ts

@@ -9,14 +9,9 @@ import {
 	RESERVED_ERROR,
 } from './utils/generateColorPair';
 
-/** Like `||`, but keeps `0`. */
-const valueOrUndefined = <T>(value: T): T | undefined =>
-	value || value === 0 ? value : undefined;
-
 /**
  * Look up an attribute from both `resource` and `attributes` on a span.
  * Resources are checked first (service.name, k8s.* etc. live there).
- * Falsy values count as missing, except `0`.
  *
  * Accepts both `SpanV3` (waterfall) and `FlamegraphSpan` (flamegraph) by typing
  * structurally — the only fields touched are `resource` and `attributes`.
@@ -27,14 +22,11 @@ export function getSpanAttribute(
 	span: {
 		resource?: Record<string, string>;
 		attributes?: Record<string, any>;
-		tagMap?: Record<string, any>;
 	},
 	key: string,
 ): string | undefined {
 	return (
-		valueOrUndefined(span.resource?.[key]) ??
-		valueOrUndefined(span.attributes?.[key]) ??
-		valueOrUndefined(span.tagMap?.[key])
+		span.resource?.[key] || span.attributes?.[key] || (span as any).tagMap?.[key]
 	);
 }
 

frontend/src/pages/TraceDetailsV3/utils/__tests__/aiTraceUtils.test.ts

@@ -1,51 +0,0 @@
-import { SpanV3 } from 'types/api/trace/getTraceV3';
-
-import {
-	AiSpanKind,
-	getAiSpanKind,
-	getTotalInputTokens,
-	isAiSpan,
-} from '../aiTraceUtils';
-
-const spanWith = (attributes: Record<string, string | number>): SpanV3 =>
-	({ attributes, resource: {} }) as unknown as SpanV3;
-
-describe('getAiSpanKind', () => {
-	it.each<[Record<string, string | number>, AiSpanKind]>([
-		[{ 'gen_ai.request.model': 'gpt-4o' }, AiSpanKind.Llm],
-		[{ 'gen_ai.usage.input_tokens': 0 }, AiSpanKind.Llm],
-		[{ 'gen_ai.usage.reasoning.output_tokens': 12 }, AiSpanKind.Llm],
-		[{ 'gen_ai.tool.name': 'search' }, AiSpanKind.Tool],
-		[{ 'gen_ai.agent.name': 'planner' }, AiSpanKind.Agent],
-		[
-			{ 'gen_ai.tool.name': 'search', 'gen_ai.request.model': 'gpt-4o' },
-			AiSpanKind.Tool,
-		],
-		[
-			{ 'gen_ai.agent.name': 'planner', 'gen_ai.usage.input_tokens': 10 },
-			AiSpanKind.Agent,
-		],
-	])('classifies %p as %s', (attributes, kind) => {
-		expect(getAiSpanKind(spanWith(attributes))).toBe(kind);
-	});
-
-	it('returns undefined for non-AI spans and empty values', () => {
-		expect(getAiSpanKind(spanWith({ 'http.method': 'GET' }))).toBeUndefined();
-		expect(getAiSpanKind(spanWith({ 'gen_ai.tool.name': '' }))).toBeUndefined();
-		expect(isAiSpan(spanWith({}))).toBe(false);
-	});
-});
-
-describe('getTotalInputTokens', () => {
-	it.each([
-		// Cache reported inside input (OpenAI): input already includes it.
-		[{ input: 1000, cacheRead: 600, cacheWrite: 100 }, 1000],
-		// Cache reported separately (Anthropic): add it.
-		[{ input: 50, cacheRead: 600, cacheWrite: 100 }, 750],
-		[{ input: 71, cacheRead: 0, cacheWrite: 0 }, 71],
-		[{ input: 10 }, 10],
-		[{ cacheRead: 600 }, 600],
-	])('%p → %p', (tokens, expected) => {
-		expect(getTotalInputTokens(tokens)).toBe(expected);
-	});
-});

frontend/src/pages/TraceDetailsV3/utils/aiTraceUtils.ts

@@ -1,168 +0,0 @@
-import { SpanV3 } from 'types/api/trace/getTraceV3';
-import { getSpanAttribute } from 'pages/TraceDetailsV3/utils';
-
-export const GEN_AI_KEYS = {
-	requestModel: 'gen_ai.request.model',
-	toolName: 'gen_ai.tool.name',
-	agentName: 'gen_ai.agent.name',
-	inputTokens: 'gen_ai.usage.input_tokens',
-	outputTokens: 'gen_ai.usage.output_tokens',
-	cacheReadTokens: 'gen_ai.usage.cache_read.input_tokens',
-	cacheCreationTokens: 'gen_ai.usage.cache_creation.input_tokens',
-	reasoningTokens: 'gen_ai.usage.reasoning.output_tokens',
-	cost: 'signoz.gen_ai.usage.tokens.cost',
-} as const;
-
-export enum AiSpanKind {
-	Llm = 'llm',
-	Tool = 'tool',
-	Agent = 'agent',
-}
-
-const LLM_KEYS = [
-	GEN_AI_KEYS.requestModel,
-	GEN_AI_KEYS.inputTokens,
-	GEN_AI_KEYS.outputTokens,
-	GEN_AI_KEYS.cacheReadTokens,
-	GEN_AI_KEYS.cacheCreationTokens,
-	GEN_AI_KEYS.reasoningTokens,
-];
-
-function hasAttribute(span: SpanV3, key: string): boolean {
-	return getSpanAttribute(span, key) !== undefined;
-}
-
-/** Tool and agent spans may also carry model or usage keys, so they win over LLM. */
-export function getAiSpanKind(span: SpanV3): AiSpanKind | undefined {
-	if (hasAttribute(span, GEN_AI_KEYS.toolName)) {
-		return AiSpanKind.Tool;
-	}
-	if (hasAttribute(span, GEN_AI_KEYS.agentName)) {
-		return AiSpanKind.Agent;
-	}
-	if (LLM_KEYS.some((key) => hasAttribute(span, key))) {
-		return AiSpanKind.Llm;
-	}
-	return undefined;
-}
-
-export function isAiSpan(span: SpanV3): boolean {
-	return getAiSpanKind(span) !== undefined;
-}
-
-/** Token counts; `null` or missing means the backend did not send the value. */
-export interface AiTokenCounts {
-	input?: number;
-	output?: number;
-	cacheRead?: number;
-	cacheWrite?: number;
-	reasoning?: number;
-}
-
-export function hasValue(value: number | null | undefined): value is number {
-	return value !== undefined && value !== null;
-}
-
-/**
- * Input including cache read/write, counted once. Providers that report cache
- * inside `input` (OpenAI) have `input >= cache`; those that report it
- * separately (Anthropic) usually have `input < cache`.
- */
-export function getTotalInputTokens({
-	input,
-	cacheRead,
-	cacheWrite,
-}: AiTokenCounts): number {
-	const inputValue = input ?? 0;
-	const cache = (cacheRead ?? 0) + (cacheWrite ?? 0);
-	return inputValue < cache ? inputValue + cache : inputValue;
-}
-
-/** `Input Token` for a count of 1, `Input Tokens` otherwise. */
-export function getTokenLabel(
-	prefix: string,
-	count: number | null | undefined,
-): string {
-	return `${prefix} ${count === 1 ? 'Token' : 'Tokens'}`;
-}
-
-/** Missing values render as `0`. */
-export function formatTokens(value: number | null | undefined): string {
-	return hasValue(value) ? value.toLocaleString('en-US') : '0';
-}
-
-export function formatCost(value: number): string {
-	return `$ ${value.toLocaleString('en-US', { maximumFractionDigits: 10 })}`;
-}
-
-export interface SpanAiUsage {
-	inputTokens?: number;
-	outputTokens?: number;
-	cacheReadTokens?: number;
-	cacheCreationTokens?: number;
-	reasoningTokens?: number;
-	cost?: number;
-}
-
-export interface SpanAiDetails {
-	model?: string;
-	toolName?: string;
-	agentName?: string;
-	usage?: SpanAiUsage;
-}
-
-function getGenAiAttributeAsString(
-	span: SpanV3,
-	key: string,
-): string | undefined {
-	const value = getSpanAttribute(span, key);
-	return value === undefined ? undefined : String(value);
-}
-
-function getGenAiAttributeAsNumber(
-	span: SpanV3,
-	key: string,
-): number | undefined {
-	const value = getSpanAttribute(span, key);
-	if (value === undefined) {
-		return undefined;
-	}
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-export function getAIUsageDetails(span: SpanV3): SpanAiDetails | undefined {
-	const usage: SpanAiUsage = {
-		inputTokens: getGenAiAttributeAsNumber(span, GEN_AI_KEYS.inputTokens),
-		outputTokens: getGenAiAttributeAsNumber(span, GEN_AI_KEYS.outputTokens),
-		cacheReadTokens: getGenAiAttributeAsNumber(span, GEN_AI_KEYS.cacheReadTokens),
-		cacheCreationTokens: getGenAiAttributeAsNumber(
-			span,
-			GEN_AI_KEYS.cacheCreationTokens,
-		),
-		reasoningTokens: getGenAiAttributeAsNumber(span, GEN_AI_KEYS.reasoningTokens),
-		cost: getGenAiAttributeAsNumber(span, GEN_AI_KEYS.cost),
-	};
-	const hasUsage = Object.values(usage).some((value) => value !== undefined);
-
-	const details: SpanAiDetails = {
-		model: getGenAiAttributeAsString(span, GEN_AI_KEYS.requestModel),
-		toolName: getGenAiAttributeAsString(span, GEN_AI_KEYS.toolName),
-		agentName: getGenAiAttributeAsString(span, GEN_AI_KEYS.agentName),
-		usage: hasUsage ? usage : undefined,
-	};
-
-	return details.model || details.toolName || details.agentName || hasUsage
-		? details
-		: undefined;
-}
-
-export function convertToAiTokens(usage: SpanAiUsage): AiTokenCounts {
-	return {
-		input: usage.inputTokens,
-		output: usage.outputTokens,
-		cacheRead: usage.cacheReadTokens,
-		cacheWrite: usage.cacheCreationTokens,
-		reasoning: usage.reasoningTokens,
-	};
-}

pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/config.go

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

pkg/alertmanager/service.go

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

pkg/apiserver/signozapiserver/ruler.go

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

pkg/apiserver/signozapiserver/ruler_examples.go

@@ -221,16 +221,15 @@ func postableRuleExamples() []handler.OpenAPIExample {
 		},
 		{
 			Name:        "metric_anomaly",
-			Summary:     "Metric anomaly rule (v1 only)",
-			Description: "Anomaly rules are not yet supported under schemaVersion v2alpha1, so this example uses the v1 shape. Wraps a builder query in the `anomaly` function with daily seasonality SigNoz compares each point against the forecast for that time of day. Fires when the anomaly score stays below the threshold for the entire window; `requireMinPoints` guards against noisy intervals.",
+			Summary:     "Metric anomaly rule",
+			Description: "Wraps a builder query in the `anomaly` function with daily seasonality, so SigNoz compares each point against the forecast for that time of day. The threshold is compared against the signed anomaly score, so `below` with a target of -2 fires when an abrupt drop holds for the entire window; `requireMinPoints` guards against noisy intervals.",
 			Value: map[string]any{
-				"alert":       "Anomalous drop in ingested spans",
-				"alertType":   "METRIC_BASED_ALERT",
-				"description": "Detect an abrupt drop in span ingestion using a z-score anomaly function",
-				"ruleType":    "anomaly_rule",
-				"version":     "v5",
-				"evalWindow":  "24h",
-				"frequency":   "3h",
+				"alert":         "Anomalous drop in ingested spans",
+				"alertType":     "METRIC_BASED_ALERT",
+				"description":   "Detect an abrupt drop in span ingestion using a z-score anomaly function",
+				"ruleType":      "anomaly_rule",
+				"version":       "v5",
+				"schemaVersion": "v2alpha1",
 				"condition": map[string]any{
 					"compositeQuery": map[string]any{
 						"queryType": "builder",
@@ -256,17 +255,29 @@ func postableRuleExamples() []handler.OpenAPIExample {
 							},
 						},
 					},
-					"op":                "below",
-					"matchType":         "all_the_times",
-					"target":            2,
 					"algorithm":         "standard",
 					"seasonality":       "daily",
 					"selectedQueryName": "A",
 					"requireMinPoints":  true,
 					"requiredNumPoints": 3,
+					"thresholds": map[string]any{
+						"kind": "basic",
+						"spec": []any{
+							map[string]any{
+								"name":      "warning",
+								"op":        "below",
+								"matchType": "all_the_times",
+								"target":    -2,
+								"channels":  []any{"slack-ingestion"},
+							},
+						},
+					},
 				},
-				"labels":            map[string]any{"severity": "warning"},
-				"preferredChannels": []any{"slack-ingestion"},
+				"evaluation": rolling("24h", "3h"),
+				"notificationSettings": map[string]any{
+					"renotify": renotify("4h", "firing"),
+				},
+				"labels": map[string]any{"severity": "warning"},
 				"annotations": map[string]any{
 					"description": "Ingestion rate for tenant {{$tenant_id}} is anomalously low (z-score {{$value}}).",
 					"summary":     "Span ingestion anomaly",

pkg/modules/rulestatehistory/implrulestatehistory/links.go

@@ -49,19 +49,14 @@ func (m *module) relatedLinkBuilderForRule(ctx context.Context, orgID valuer.UUI
 		return nil
 	}
 
-	builder := &relatedLinkBuilder{alertType: rule.AlertType}
-	if rule.Evaluation != nil {
-		if evaluation, err := rule.Evaluation.GetEvaluation(); err == nil {
-			builder.evaluation = evaluation
-		}
+	if rule.Evaluation == nil {
+		return nil
 	}
-	if builder.evaluation == nil {
-		evalWindow := rule.EvalWindow
-		if evalWindow.IsZero() {
-			evalWindow = valuer.MustParseTextDuration("5m")
-		}
-		builder.evaluation = ruletypes.RollingWindow{EvalWindow: evalWindow}
+	evaluation, err := rule.Evaluation.GetEvaluation()
+	if err != nil {
+		return nil
 	}
+	builder := &relatedLinkBuilder{alertType: rule.AlertType, evaluation: evaluation}
 
 	// links are still built from the labels alone when the rule has no builder
 	// query for the signal (e.g. ClickHouse SQL alerts)

pkg/query-service/app/http_handler.go

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

pkg/query-service/rules/base_rule.go

@@ -33,10 +33,6 @@ type BaseRule struct {
 	ruleCondition *ruletypes.RuleCondition
 
 	Threshold ruletypes.RuleThreshold
-	// evalWindow is the time window used for evaluating the rule
-	// i.e. each time we lookback from the current time, we look at data for the last
-	// evalWindow duration
-	evalWindow valuer.TextDuration
 	// holdDuration is the duration for which the alert waits before firing
 	holdDuration valuer.TextDuration
 
@@ -48,10 +44,7 @@ type BaseRule struct {
 	// these are the same for all alerts created for this rule
 	labels      ruletypes.Labels
 	annotations ruletypes.Labels
-	// preferredChannels is the list of channels to send the alert to
-	// if the rule is triggered
-	preferredChannels []string
-	mtx               sync.Mutex
+	mtx         sync.Mutex
 	// the time it took to evaluate the rule (most recent evaluation)
 	evaluationDuration time.Duration
 	// the timestamp of the last evaluation
@@ -156,20 +149,18 @@ func NewBaseRule(
 	}
 
 	baseRule := &BaseRule{
-		id:                id,
-		orgID:             orgID,
-		externalURL:       externalURL,
-		name:              p.AlertName.StringValue(),
-		typ:               p.AlertType,
-		ruleCondition:     p.RuleCondition,
-		evalWindow:        p.EvalWindow,
-		labels:            ruletypes.FromMap(p.Labels),
-		annotations:       ruletypes.FromMap(p.Annotations),
-		preferredChannels: p.PreferredChannels,
-		health:            ruletypes.HealthUnknown,
-		Active:            map[uint64]*ruletypes.Alert{},
-		Threshold:         threshold,
-		evaluation:        evaluation,
+		id:            id,
+		orgID:         orgID,
+		externalURL:   externalURL,
+		name:          p.AlertName.StringValue(),
+		typ:           p.AlertType,
+		ruleCondition: p.RuleCondition,
+		labels:        ruletypes.FromMap(p.Labels),
+		annotations:   ruletypes.FromMap(p.Annotations),
+		health:        ruletypes.HealthUnknown,
+		Active:        map[uint64]*ruletypes.Alert{},
+		Threshold:     threshold,
+		evaluation:    evaluation,
 	}
 
 	// Store newGroupEvalDelay and groupBy keys from NotificationSettings
@@ -177,10 +168,6 @@ func NewBaseRule(
 		baseRule.newGroupEvalDelay = p.NotificationSettings.NewGroupEvalDelay
 	}
 
-	if baseRule.evalWindow.IsZero() {
-		baseRule.evalWindow = valuer.MustParseTextDuration("5m")
-	}
-
 	for _, opt := range opts {
 		opt(baseRule)
 	}
@@ -231,10 +218,6 @@ func (r *BaseRule) EvalDelay() valuer.TextDuration {
 	return r.evalDelay
 }
 
-func (r *BaseRule) EvalWindow() valuer.TextDuration {
-	return r.evalWindow
-}
-
 func (r *BaseRule) HoldDuration() valuer.TextDuration {
 	return r.holdDuration
 }
@@ -245,7 +228,6 @@ func (r *BaseRule) Name() string                        { return r.name }
 func (r *BaseRule) Condition() *ruletypes.RuleCondition { return r.ruleCondition }
 func (r *BaseRule) Labels() ruletypes.Labels            { return r.labels }
 func (r *BaseRule) Annotations() ruletypes.Labels       { return r.annotations }
-func (r *BaseRule) PreferredChannels() []string         { return r.preferredChannels }
 
 func (r *BaseRule) GeneratorURL() string {
 	params := url.Values{}

pkg/query-service/rules/manager.go

@@ -361,7 +361,7 @@ func (m *Manager) EditRule(ctx context.Context, ruleStr string, id valuer.UUID)
 	parsedRule := ruletypes.PostableRule{}
 	err = json.Unmarshal([]byte(ruleStr), &parsedRule)
 	if err != nil {
-		return err
+		return errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to unmarshal rule")
 	}
 	if err := parsedRule.Validate(); err != nil {
 		return err
@@ -548,7 +548,7 @@ func (m *Manager) deleteTask(taskName string) {
 func (m *Manager) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error) {
 	parsedRule := ruletypes.PostableRule{}
 	if err := json.Unmarshal([]byte(ruleStr), &parsedRule); err != nil {
-		return nil, err
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to unmarshal rule")
 	}
 
 	return m.createRule(ctx, parsedRule, ruleStr)
@@ -1051,7 +1051,7 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
 
 	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
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to unmarshal rule")
 	}
 	if err := storedRule.Validate(); err != nil {
 		return nil, err

pkg/query-service/rules/manager_test_data.go

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

pkg/query-service/rules/prom_rule.go

@@ -359,12 +359,10 @@ func (r *PromRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 
 func (r *PromRule) String() string {
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.name),
-		RuleCondition:     r.ruleCondition,
-		EvalWindow:        r.evalWindow,
-		Labels:            r.labels.Map(),
-		Annotations:       r.annotations.Map(),
-		PreferredChannels: r.preferredChannels,
+		AlertName:     valuer.NewDisplayName(r.name),
+		RuleCondition: r.ruleCondition,
+		Labels:        r.labels.Map(),
+		Annotations:   r.annotations.Map(),
 	}
 
 	byt, err := json.Marshal(ar)

pkg/query-service/rules/prom_rule_test.go

@@ -690,9 +690,6 @@ 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{
@@ -905,11 +902,7 @@ func TestPromRuleUnitCombinations(t *testing.T) {
 
 		promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{Timeout: 2 * time.Minute}, telemetryStore)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = ruletypes.MatchType(c.matchType)
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1198,11 +1191,7 @@ func TestMultipleThresholdPromRule(t *testing.T) {
 
 		promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{Timeout: 2 * time.Minute}, telemetryStore)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1269,8 +1258,6 @@ func TestPromRule_NoData(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1365,10 +1352,7 @@ func TestPromRule_NoData_AbsentFor(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			AlertOnAbsent:   true,
-			Target:          &target,
+			AlertOnAbsent: true,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1491,8 +1475,6 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypePromQL,
 				Queries: []qbtypes.QueryEnvelope{
@@ -1562,9 +1544,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 	for _, c := range cases {
 		rc := postableRule.RuleCondition
 
-		rc.Target = &targetForNoAlert
+		target := &targetForNoAlert
 		if c.alertCondition {
-			rc.Target = &targetForAlert
+			target = &targetForAlert
 		}
 		rc.RequireMinPoints = c.requireMinPoints
 		rc.RequiredNumPoints = c.requiredNumPoints
@@ -1573,9 +1555,9 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			Spec: ruletypes.BasicRuleThresholds{
 				{
 					Name:            postableRule.AlertName.StringValue(),
-					TargetValue:     rc.Target,
-					MatchType:       rc.MatchType,
-					CompareOperator: rc.CompareOperator,
+					TargetValue:     target,
+					MatchType:       ruletypes.AtleastOnce,
+					CompareOperator: ruletypes.ValueIsAbove,
 				},
 			},
 		}

pkg/query-service/rules/rule.go

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

pkg/query-service/rules/threshold_rule.go

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

pkg/query-service/rules/threshold_rule_test.go

@@ -171,10 +171,7 @@ func TestPrepareParamsForLogs(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 	}
 
@@ -183,9 +180,9 @@ func TestPrepareParamsForLogs(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -239,10 +236,7 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 		Version: "v5",
 	}
@@ -252,9 +246,9 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -304,10 +298,7 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 		Version: "v5",
 	}
@@ -317,9 +308,9 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -366,10 +357,7 @@ func TestPrepareParamsForTraces(t *testing.T) {
 					},
 				},
 			},
-			CompareOperator: ruletypes.ValueIsNotEq,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &[]float64{0.0}[0],
-			SelectedQuery:   "A",
+			SelectedQuery: "A",
 		},
 	}
 
@@ -378,9 +366,9 @@ func TestPrepareParamsForTraces(t *testing.T) {
 		Kind: ruletypes.BasicThresholdKind,
 		Spec: ruletypes.BasicRuleThresholds{
 			{
-				TargetValue:     postableRule.RuleCondition.Target,
-				MatchType:       postableRule.RuleCondition.MatchType,
-				CompareOperator: postableRule.RuleCondition.CompareOperator,
+				TargetValue:     &[]float64{0.0}[0],
+				MatchType:       ruletypes.AtleastOnce,
+				CompareOperator: ruletypes.ValueIsNotEq,
 			},
 		},
 	}
@@ -653,11 +641,7 @@ func TestThresholdRuleUnitCombinations(t *testing.T) {
 			ExpectQuery(queryString).
 			WithArgs(nil, nil, nil, nil, nil, nil, nil, nil).
 			WillReturnRows(rows)
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -867,11 +851,7 @@ func TestThresholdRuleTracesLink(t *testing.T) {
 
 		querier := prepareQuerierForTraces(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -975,11 +955,7 @@ func TestThresholdRuleAITracesLink(t *testing.T) {
 
 		querier := prepareQuerierForAITraces(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1083,11 +1059,7 @@ func TestThresholdRuleLogsLink(t *testing.T) {
 
 		querier := prepareQuerierForLogs(t, telemetryStore, keysMap)
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1256,11 +1228,7 @@ func TestMultipleThresholdRule(t *testing.T) {
 		querier, mockMetadataStore := prepareQuerierForMetrics(t, telemetryStore)
 		mockMetadataStore.TypeMap["signoz_calls_total"] = metrictypes.SumType
 
-		postableRule.RuleCondition.CompareOperator = c.compareOperator
-		postableRule.RuleCondition.MatchType = c.matchType
-		postableRule.RuleCondition.Target = &c.target
 		postableRule.RuleCondition.CompositeQuery.Unit = c.yAxisUnit
-		postableRule.RuleCondition.TargetUnit = c.targetUnit
 		postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
 			Kind: ruletypes.BasicThresholdKind,
 			Spec: ruletypes.BasicRuleThresholds{
@@ -1930,8 +1898,6 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
 				Queries: []qbtypes.QueryEnvelope{{
@@ -2050,7 +2016,6 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 		mockMetadataStore.TypeMap["signoz_calls_total"] = metrictypes.SumType
 
 		rc := postableRule.RuleCondition
-		rc.Target = &c.target
 		rc.RequireMinPoints = c.requireMinPoints
 		rc.RequiredNumPoints = c.requiredNumPoints
 		rc.Thresholds = &ruletypes.RuleThresholdData{
@@ -2059,8 +2024,8 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
 				{
 					Name:            postableRule.AlertName.StringValue(),
 					TargetValue:     &c.target,
-					MatchType:       rc.MatchType,
-					CompareOperator: rc.CompareOperator,
+					MatchType:       ruletypes.AtleastOnce,
+					CompareOperator: ruletypes.ValueIsAbove,
 				},
 			},
 		}

pkg/ruler/handler.go

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

pkg/ruler/signozruler/handler.go

@@ -25,24 +25,6 @@ func NewHandler(ruler ruler.Ruler) ruler.Handler {
 	return &handler{ruler: ruler}
 }
 
-func (handler *handler) ListRules(rw http.ResponseWriter, req *http.Request) {
-	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
-	defer cancel()
-
-	rules, err := handler.ruler.ListRuleStates(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	view := make([]*ruletypes.Rule, 0, len(rules.Rules))
-	for _, rule := range rules.Rules {
-		view = append(view, ruletypes.NewRule(rule))
-	}
-
-	render.Success(rw, http.StatusOK, view)
-}
-
 func (handler *handler) ListRulesV3(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()

pkg/signoz/provider.go

@@ -262,6 +262,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddRuleViewFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddFieldTuplesFactory(sqlstore),
 		sqlmigration.NewKeepRelevantLLMPricingRulesFactory(),
+		sqlmigration.NewMigrateRulesV1ToV2Alpha1Factory(sqlstore),
 	)
 }
 

pkg/sqlmigration/136_migrate_rules_v1_to_v2alpha1.go

@@ -0,0 +1,476 @@
+package sqlmigration
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"slices"
+	"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"
+	compareOperatorBelow  = "2"
+	criticalThresholdName = "critical"
+	labelSeverity         = "severity"
+)
+
+// The values the threshold decoder accepts; a stored value outside them fails
+// every later read of the migrated row.
+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"}
+)
+
+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) convertOrg(ctx context.Context, orgID string) error {
+	db := migration.sqlstore.BunDBCtx(ctx)
+
+	rules := make([]*ruleRow, 0)
+	if err := db.NewSelect().Model(&rules).Where("org_id = ?", orgID).Scan(ctx); err != nil {
+		return err
+	}
+
+	routes := make([]*routePolicyRow, 0)
+	if err := db.NewSelect().Model(&routes).Where("org_id = ?", orgID).Scan(ctx); err != nil {
+		return err
+	}
+	routesByName := make(map[string][]*routePolicyRow)
+	for _, route := range routes {
+		routesByName[route.Name] = append(routesByName[route.Name], route)
+	}
+
+	var migrated, skipped, undecodable, unmigratable int
+	for _, stored := range rules {
+		var header struct {
+			SchemaVersion string `json:"schemaVersion"`
+		}
+		if err := json.Unmarshal([]byte(stored.Data), &header); err != nil {
+			undecodable++
+			migration.logger.WarnContext(ctx, "failed to decode stored rule", slog.String("org_id", orgID), slog.String("rule_id", stored.ID), errors.Attr(err))
+			continue
+		}
+		if header.SchemaVersion == schemaVersionV2Alpha1 {
+			skipped++
+			continue
+		}
+
+		rule := new(postableRule)
+		if err := json.Unmarshal([]byte(stored.Data), rule); err != nil {
+			undecodable++
+			migration.logger.WarnContext(ctx, "failed to decode stored rule", slog.String("org_id", orgID), slog.String("rule_id", stored.ID), errors.Attr(err))
+			continue
+		}
+
+		route, err := selectRoute(routesByName[stored.ID], rule.PreferredChannels)
+		if err != nil {
+			unmigratable++
+			migration.logger.WarnContext(ctx, "leaving rule at v1", slog.String("org_id", orgID), slog.String("rule_id", stored.ID), errors.Attr(err))
+			continue
+		}
+		expression := ""
+		if route != nil {
+			expression = route.Expression
+		}
+
+		if err := convertRule(stored.ID, rule, route); err != nil {
+			unmigratable++
+			migration.logger.WarnContext(ctx, "leaving rule at v1", slog.String("org_id", orgID), slog.String("rule_id", stored.ID), errors.Attr(err))
+			continue
+		}
+
+		data, err := marshalUnescaped(rule)
+		if err != nil {
+			return err
+		}
+		stored.Data = string(data)
+		if _, err := db.NewUpdate().Model(stored).Column("data").WherePK().Exec(ctx); err != nil {
+			return err
+		}
+		if route != nil && route.Expression != expression {
+			if _, err := db.NewUpdate().Model(route).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(rules)), slog.Int("migrated", migrated), slog.Int("skipped", skipped), slog.Int("undecodable", undecodable), slog.Int("unmigratable", unmigratable))
+	return nil
+}
+
+// convertRule rewrites rule in place, in the order the v1 decode derived the
+// same values. Version and source are left as stored. A nil route is a rule
+// that never had channels.
+func convertRule(ruleID string, rule *postableRule, route *routePolicyRow) error {
+	if rule.RuleCondition == nil || rule.RuleCondition.CompositeQuery == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition or condition.compositeQuery is null")
+	}
+	if err := rule.validateThreshold(); err != nil {
+		return err
+	}
+	channels := []string{}
+	if route != nil {
+		channels = route.Channels
+	}
+
+	rule.fillDurationDefaults()
+	if err := rule.validateDurations(); err != nil {
+		return err
+	}
+	rule.deriveRuleType()
+	rule.negateAnomalyBelowTarget()
+	rule.repairEmptySeverity(ruleID, route)
+	rule.relocateThreshold(channels)
+	rule.relocateEvaluation()
+	rule.synthesizeNotificationSettings()
+	rule.SchemaVersion = schemaVersionV2Alpha1
+	rule.clearV1Fields()
+
+	return nil
+}
+
+// selectRoute picks 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 selectRoute(routes []*routePolicyRow, preferredChannels []string) (*routePolicyRow, error) {
+	switch {
+	case len(routes) == 1:
+		return routes[0], nil
+	case len(routes) > 1:
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "expected one route_policy row, found %d", len(routes))
+	case len(preferredChannels) > 0:
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "no route_policy row for a rule with %d preferred channels", len(preferredChannels))
+	default:
+		return nil, nil
+	}
+}
+
+type ruleRow struct {
+	bun.BaseModel `bun:"table:rule"`
+
+	ID    string `bun:"id,pk"`
+	OrgID string `bun:"org_id"`
+	Data  string `bun:"data"`
+}
+
+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            json.RawMessage       `json:"alertType,omitempty"`
+	Description          json.RawMessage       `json:"description,omitempty"`
+	RuleType             string                `json:"ruleType"`
+	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"`
+	Algorithm         json.RawMessage `json:"algorithm,omitempty"`
+	Seasonality       json.RawMessage `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 json.RawMessage `json:"panelType,omitempty"`
+	QueryType string          `json:"queryType"`
+	Unit      json.RawMessage `json:"unit,omitempty"`
+}
+
+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"`
+}
+
+// validateThreshold rejects what the v1 write path once let through: a
+// missing target, or an op or matchType the threshold decoder does not
+// accept. Each fails every later read of the migrated row.
+func (rule *postableRule) validateThreshold() error {
+	condition := rule.RuleCondition
+	if condition.Target == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.target is null")
+	}
+	if !slices.Contains(supportedCompareOperators, condition.CompareOperator) {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.op: unsupported value %q", condition.CompareOperator)
+	}
+	if !slices.Contains(supportedMatchTypes, condition.MatchType) {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.matchType: unsupported value %q", condition.MatchType)
+	}
+	return nil
+}
+
+func (rule *postableRule) fillDurationDefaults() {
+	if rule.EvalWindow.IsZero() {
+		rule.EvalWindow = mustParseTextDuration("5m")
+	}
+	if rule.Frequency.IsZero() {
+		rule.Frequency = mustParseTextDuration("1m")
+	}
+}
+
+// validateDurations rejects what the v1 write path never checked: a negative
+// evalWindow or frequency, which no read of a rolling window accepts.
+func (rule *postableRule) validateDurations() error {
+	if !rule.EvalWindow.IsPositive() || !rule.Frequency.IsPositive() {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "evalWindow %s or frequency %s is negative", rule.EvalWindow, rule.Frequency)
+	}
+	return nil
+}
+
+func (rule *postableRule) deriveRuleType() {
+	switch rule.RuleCondition.CompositeQuery.QueryType {
+	case queryTypeBuilder:
+		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.
+func (rule *postableRule) repairEmptySeverity(ruleID string, route *routePolicyRow) {
+	if severity, ok := rule.Labels[labelSeverity]; !ok || severity != "" {
+		return
+	}
+	rule.Labels[labelSeverity] = criticalThresholdName
+	if route != nil {
+		route.Expression = fmt.Sprintf(`threshold.name == "%s" && ruleId == "%s"`, criticalThresholdName, ruleID)
+	}
+}
+
+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)
+	}
+}
+
+func (migration *migrateRulesV1ToV2Alpha1) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/types/alertmanagertypes/config.go

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

pkg/types/rulestatehistorytypes/query.go

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

pkg/types/ruletypes/alert_state.go

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

pkg/types/ruletypes/alerting.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -77,6 +78,15 @@ func (PanelType) Enum() []any {
 	}
 }
 
+func (p PanelType) Validate() error {
+	switch p {
+	case PanelTypeValue, PanelTypeTable, PanelTypeGraph:
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.panelType: unsupported value %q; must be one of value, table, graph", p.StringValue())
+	}
+}
+
 // Note: this is used to represent the state of the alert query
 // i.e the active tab which should be used to represent the selection
 
@@ -99,6 +109,15 @@ func (QueryType) Enum() []any {
 	}
 }
 
+func (q QueryType) Validate() error {
+	switch q {
+	case QueryTypeBuilder, QueryTypeClickHouseSQL, QueryTypePromQL:
+		return nil
+	default:
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.queryType: unsupported value %q; must be one of builder, clickhouse_sql, promql", q.StringValue())
+	}
+}
+
 type AlertCompositeQuery struct {
 	Queries []qbtypes.QueryEnvelope `json:"queries" required:"true"`
 
@@ -111,18 +130,14 @@ type AlertCompositeQuery struct {
 
 type RuleCondition struct {
 	CompositeQuery    *AlertCompositeQuery `json:"compositeQuery" required:"true"`
-	CompareOperator   CompareOperator      `json:"op,omitzero"`
-	Target            *float64             `json:"target,omitempty" format:"double"`
 	AlertOnAbsent     bool                 `json:"alertOnAbsent,omitempty"`
 	AbsentFor         uint64               `json:"absentFor,omitempty"`
-	MatchType         MatchType            `json:"matchType,omitzero"`
-	TargetUnit        string               `json:"targetUnit,omitempty"`
 	Algorithm         string               `json:"algorithm,omitempty"`
 	Seasonality       Seasonality          `json:"seasonality,omitzero"`
 	SelectedQuery     string               `json:"selectedQueryName,omitempty"`
 	RequireMinPoints  bool                 `json:"requireMinPoints,omitempty"`
 	RequiredNumPoints int                  `json:"requiredNumPoints,omitempty"`
-	Thresholds        *RuleThresholdData   `json:"thresholds,omitempty"`
+	Thresholds        *RuleThresholdData   `json:"thresholds" required:"true"`
 }
 
 func (rc *RuleCondition) SelectedQueryName() string {

pkg/types/ruletypes/api_params.go

@@ -9,6 +9,7 @@ import (
 	"unicode/utf8"
 
 	"github.com/prometheus/alertmanager/config"
+	"github.com/swaggest/jsonschema-go"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -48,7 +49,6 @@ func (t AlertType) BuilderQueryType() qbtypes.QueryType {
 }
 
 const (
-	DefaultSchemaVersion  = "v1"
 	SchemaVersionV2Alpha1 = "v2alpha1"
 )
 
@@ -60,12 +60,10 @@ const (
 
 // PostableRule is used to create alerting rule from HTTP api.
 type PostableRule struct {
-	AlertName   valuer.DisplayName  `json:"alert" required:"true"`
-	AlertType   AlertType           `json:"alertType" required:"true"`
-	Description string              `json:"description,omitempty"`
-	RuleType    RuleType            `json:"ruleType" required:"true"`
-	EvalWindow  valuer.TextDuration `json:"evalWindow,omitzero"`
-	Frequency   valuer.TextDuration `json:"frequency,omitzero"`
+	AlertName   valuer.DisplayName `json:"alert" required:"true"`
+	AlertType   AlertType          `json:"alertType" required:"true"`
+	Description string             `json:"description,omitempty"`
+	RuleType    RuleType           `json:"ruleType" required:"true"`
 
 	RuleCondition *RuleCondition    `json:"condition" required:"true"`
 	Labels        map[string]string `json:"labels,omitempty"`
@@ -76,14 +74,12 @@ type PostableRule struct {
 	// Source captures the source url where rule has been created
 	Source string `json:"source,omitempty"`
 
-	PreferredChannels []string `json:"preferredChannels,omitempty"`
-
 	Version string `json:"version"`
 
-	Evaluation    *EvaluationEnvelope `json:"evaluation,omitempty"`
-	SchemaVersion string              `json:"schemaVersion,omitempty"`
+	Evaluation    *EvaluationEnvelope `json:"evaluation" required:"true"`
+	SchemaVersion string              `json:"schemaVersion" required:"true" enum:"v2alpha1"`
 
-	NotificationSettings *NotificationSettings `json:"notificationSettings,omitempty"`
+	NotificationSettings *NotificationSettings `json:"notificationSettings" required:"true"`
 }
 
 type NotificationSettings struct {
@@ -229,27 +225,11 @@ 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:
@@ -259,71 +239,6 @@ func (r *PostableRule) processRuleDefaults() {
 		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)
 	}
 }
 
@@ -337,6 +252,19 @@ func (r *PostableRule) UnmarshalJSON(bytes []byte) error {
 	return r.validate()
 }
 
+var _ jsonschema.Preparer = PostableRule{}
+
+// PrepareJSONSchema marks version and source deprecated: nothing reads them,
+// they stay only so existing clients keep a stable schema.
+func (PostableRule) PrepareJSONSchema(schema *jsonschema.Schema) error {
+	for _, name := range []string{"version", "source"} {
+		if property, ok := schema.Properties[name]; ok && property.TypeObject != nil {
+			property.TypeObject.WithDeprecated(true)
+		}
+	}
+	return nil
+}
+
 func isValidLabelName(ln string) bool {
 	if len(ln) == 0 {
 		return false
@@ -364,10 +292,6 @@ func (r *PostableRule) validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.Version != "v5" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
-	}
-
 	for k, v := range r.Labels {
 		if !isValidLabelName(k) {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid label name: %s", k))
@@ -411,18 +335,14 @@ func (r *PostableRule) Validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.Version != "v5" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
-	}
-
-	if r.AlertType != "" {
-		switch r.AlertType {
-		case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces:
-		default:
-			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"alertType: unsupported value %q; must be one of %q, %q, %q, %q, %q",
-				r.AlertType, AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces))
-		}
+	switch r.AlertType {
+	case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces:
+	case "":
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "alertType: field is required"))
+	default:
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
+			"alertType: unsupported value %q; must be one of %q, %q, %q, %q, %q",
+			r.AlertType, AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces))
 	}
 
 	if !r.RuleType.IsZero() {
@@ -440,6 +360,12 @@ func (r *PostableRule) Validate() error {
 	if r.RuleCondition.CompositeQuery == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery: field is required"))
 	} else {
+		if err := r.RuleCondition.CompositeQuery.QueryType.Validate(); err != nil {
+			errs = append(errs, err)
+		}
+		if err := r.RuleCondition.CompositeQuery.PanelType.Validate(); err != nil {
+			errs = append(errs, err)
+		}
 		if len(r.RuleCondition.CompositeQuery.Queries) == 0 {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.compositeQuery.queries: must have at least one query"))
 		} else {
@@ -502,65 +428,18 @@ func (r *PostableRule) Validate() error {
 
 func (r *PostableRule) validateSchemaVersion() []error {
 	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		return r.validateV1()
 	case SchemaVersionV2Alpha1:
 		return r.validateV2Alpha1()
 	default:
 		return []error{errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"schemaVersion: unsupported value %q; must be one of %q, %q",
-			r.SchemaVersion, DefaultSchemaVersion, SchemaVersionV2Alpha1)}
+			"schemaVersion: unsupported value %q; must be %q",
+			r.SchemaVersion, SchemaVersionV2Alpha1)}
 	}
 }
 
-func (r *PostableRule) validateV1() []error {
-	var errs []error
-
-	if r.RuleCondition.Target == nil {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.target: field is required for schemaVersion %q", DefaultSchemaVersion))
-	}
-	if r.RuleCondition.CompareOperator.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.op: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.CompareOperator.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-	if r.RuleCondition.MatchType.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.matchType: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.MatchType.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-
-	return errs
-}
-
 func (r *PostableRule) validateV2Alpha1() []error {
 	var errs []error
 
-	// TODO(srikanthccv): reject v1-only fields?
-	// if r.RuleCondition.Target != nil {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.target: field is not used in schemaVersion %q; set target in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.CompareOperator.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.op: field is not used in schemaVersion %q; set op in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.MatchType.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.matchType: field is not used in schemaVersion %q; set matchType in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if len(r.PreferredChannels) > 0 {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"preferredChannels: field is not used in schemaVersion %q; set channels in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-
 	// Require v2alpha1-specific fields
 	if r.RuleCondition.Thresholds == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
@@ -644,31 +523,6 @@ type GettableRule struct {
 	UpdatedBy *string   `json:"updateBy" nullable:"true"`
 }
 
-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
@@ -697,28 +551,3 @@ func NewRule(g *GettableRule) *Rule {
 	}
 	return r
 }
-
-func (r *Rule) MarshalJSON() ([]byte, error) {
-	type Alias Rule
-
-	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	}
-}

pkg/types/ruletypes/api_params_test.go

@@ -3,7 +3,6 @@ package ruletypes
 import (
 	"encoding/json"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -29,8 +28,7 @@ func TestParseIntoRule(t *testing.T) {
 				"alertType": "METRIC_BASED_ALERT",
 				"description": "Test description",
 				"ruleType": "threshold_rule",
-				"evalWindow": "5m",
-				"frequency": "1m",
+				"schemaVersion": "v2alpha1",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -45,11 +43,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"target": 10.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 10.0, "matchType": "1", "op": "1"}]},
+					"selectedQueryName": "A"
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -63,46 +61,6 @@ func TestParseIntoRule(t *testing.T) {
 				if rule.RuleCondition.Thresholds.Kind.IsZero() {
 					t.Error("Expected thresholds to be populated")
 				}
-				if rule.RuleCondition.Target == nil {
-					t.Error("Expected target to be populated")
-				}
-			},
-		},
-		{
-			name:     "rule with default values applied",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "DefaultsRule",
-				"ruleType": "threshold_rule",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "test_metric", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 5.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.EvalWindow.Duration() != 5*time.Minute {
-					t.Errorf("Expected default eval window '5m', got '%v'", rule.EvalWindow)
-				}
-				if rule.Frequency.Duration() != time.Minute {
-					t.Errorf("Expected default frequency '1m', got '%v'", rule.Frequency)
-				}
 			},
 		},
 		{
@@ -110,6 +68,7 @@ func TestParseIntoRule(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "PromQLRule",
+				"schemaVersion": "v2alpha1",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -123,11 +82,11 @@ func TestParseIntoRule(t *testing.T) {
 							}
 						}]
 					},
-					"target": 10.0,
-					"matchType": "1",
-					"op": "1",
-					"selectedQuery": "A"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 10.0, "matchType": "1", "op": "1"}]},
+					"selectedQueryName": "A"
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:        RuleDataKindJson,
 			expectError: false,
@@ -138,9 +97,6 @@ func TestParseIntoRule(t *testing.T) {
 				if rule.RuleCondition.Thresholds.Kind.IsZero() {
 					t.Error("Expected thresholds to be populated")
 				}
-				if rule.RuleCondition.Target == nil {
-					t.Error("Expected target to be populated")
-				}
 			},
 		},
 	}
@@ -177,233 +133,6 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 		expectValidateError bool // Validate() error (write path only)
 		validate            func(*testing.T, *PostableRule)
 	}{
-		{
-			name:     "schema v1 - threshold name from severity label",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "SeverityLabelTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "cpu_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}],
-						"unit": "percent"
-					},
-					"target": 85.0,
-					"targetUnit": "%",
-					"matchType": "1",
-					"op": "1"
-				},
-				"labels": {
-					"severity": "warning",
-					"team": "platform"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated for v1")
-				}
-
-				threshold := rule.RuleCondition.Thresholds
-				if threshold.Kind != BasicThresholdKind {
-					t.Errorf("Expected BasicThresholdKind, got %s", threshold.Kind)
-				}
-
-				specs, ok := threshold.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", threshold.Spec)
-				}
-
-				if len(specs) != 1 {
-					t.Fatalf("Expected 1 threshold spec, got %d", len(specs))
-				}
-
-				spec := specs[0]
-				if spec.Name != "warning" {
-					t.Errorf("Expected threshold name 'warning' from severity label, got '%s'", spec.Name)
-				}
-
-				if spec.TargetUnit != "%" {
-					t.Errorf("Expected TargetUnit '%%', got '%s'", spec.TargetUnit)
-				}
-				if *spec.TargetValue != 85.0 {
-					t.Errorf("Expected TargetValue 85.0, got %v", *spec.TargetValue)
-				}
-				if spec.MatchType != rule.RuleCondition.MatchType {
-					t.Error("Expected MatchType to be copied from RuleCondition")
-				}
-				if spec.CompareOperator != rule.RuleCondition.CompareOperator {
-					t.Error("Expected CompareOp to be copied from RuleCondition")
-				}
-
-				// Verify evaluation envelope is populated
-				if rule.Evaluation == nil {
-					t.Fatal("Expected Evaluation to be populated for v1")
-				}
-				if rule.Evaluation.Kind != RollingEvaluation {
-					t.Errorf("Expected RollingEvaluation, got %s", rule.Evaluation.Kind)
-				}
-
-				// Verify evaluation window matches rule settings
-				if window, ok := rule.Evaluation.Spec.(RollingWindow); ok {
-					if !window.EvalWindow.Equal(rule.EvalWindow) {
-						t.Errorf("Expected Evaluation EvalWindow %v, got %v", rule.EvalWindow, window.EvalWindow)
-					}
-					if !window.Frequency.Equal(rule.Frequency) {
-						t.Errorf("Expected Evaluation Frequency %v, got %v", rule.Frequency, window.Frequency)
-					}
-				} else {
-					t.Errorf("Expected RollingWindow spec, got %T", rule.Evaluation.Spec)
-				}
-			},
-		},
-		{
-			name:     "schema v1 - uses critical threshold when no labels",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "NoLabelsTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "memory_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}]
-					},
-					"target": 90.0,
-					"matchType": "1",
-					"op": "1"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated")
-				}
-
-				specs, ok := rule.RuleCondition.Thresholds.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", rule.RuleCondition.Thresholds.Spec)
-				}
-				spec := specs[0]
-				// Should default to CriticalThresholdName when no severity label
-				if spec.Name != CriticalThresholdName {
-					t.Errorf("Expected threshold name '%s', got '%s'", CriticalThresholdName, spec.Name)
-				}
-			},
-		},
-		{
-			name:     "schema v1 - overwrites existing thresholds and evaluation",
-			initRule: PostableRule{},
-			content: []byte(`{
-				"alert": "OverwriteTest",
-				"schemaVersion": "v1",
-				"version": "v5",
-				"condition": {
-					"compositeQuery": {
-						"queryType": "builder",
-						"queries": [{
-							"type": "builder_query",
-							"spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{"metricName": "cpu_usage", "spaceAggregation": "p50"}],
-								"stepInterval": "5m"
-							}
-						}],
-						"unit": "percent"
-					},
-					"target": 80.0,
-					"targetUnit": "%",
-					"matchType": "1",
-					"op": "1",
-					"thresholds": {
-						"kind": "basic",
-						"spec": [{
-							"name": "existing_threshold",
-							"target": 50.0,
-							"targetUnit": "MB",
-							"ruleUnit": "bytes",
-							"matchType": "1",
-							"op": "1"
-						}]
-					}
-				},
-				"evaluation": {
-					"kind": "rolling",
-					"spec": {
-						"evalWindow": "10m",
-						"frequency": "2m"
-					}
-				},
-				"frequency":"7m",
-				"evalWindow":"11m",
-				"labels": {
-					"severity": "critical"
-				}
-			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.RuleCondition.Thresholds == nil {
-					t.Fatal("Expected Thresholds to be populated")
-				}
-
-				specs, ok := rule.RuleCondition.Thresholds.Spec.(BasicRuleThresholds)
-				if !ok {
-					t.Fatalf("Expected BasicRuleThresholds, got %T", rule.RuleCondition.Thresholds.Spec)
-				}
-
-				if len(specs) != 1 {
-					t.Fatalf("Expected 1 threshold spec, got %d", len(specs))
-				}
-
-				spec := specs[0]
-				if spec.Name != "critical" {
-					t.Errorf("Expected threshold name 'critical' (overwritten), got '%s'", spec.Name)
-				}
-
-				if *spec.TargetValue != 80.0 {
-					t.Errorf("Expected TargetValue 80.0 (overwritten), got %v", *spec.TargetValue)
-				}
-				if spec.TargetUnit != "%" {
-					t.Errorf("Expected TargetUnit '%%' (overwritten), got '%s'", spec.TargetUnit)
-				}
-
-				if rule.Evaluation == nil {
-					t.Fatal("Expected Evaluation to be populated")
-				}
-				if window, ok := rule.Evaluation.Spec.(RollingWindow); ok {
-					if !window.EvalWindow.Equal(rule.EvalWindow) {
-						t.Errorf("Expected Evaluation EvalWindow to be overwritten to %v, got %v", rule.EvalWindow, window.EvalWindow)
-					}
-					if !window.Frequency.Equal(rule.Frequency) {
-						t.Errorf("Expected Evaluation Frequency to be overwritten to %v, got %v", rule.Frequency, window.Frequency)
-					}
-				} else {
-					t.Errorf("Expected RollingWindow spec, got %T", rule.Evaluation.Spec)
-				}
-			},
-		},
 		{
 			name:     "schema v2alpha1 - uses explicit thresholds and evaluation",
 			initRule: PostableRule{},
@@ -645,19 +374,19 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"target": 100.0,
-					"matchType": "1",
-					"op": "1"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 100.0, "matchType": "1", "op": "1"}]}
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
 			kind:                RuleDataKindJson,
 			expectValidateError: true,
 		},
 		{
-			name:     "default schema version - defaults to v1 behavior",
+			name:     "missing schema version - rejected on write",
 			initRule: PostableRule{},
 			content: []byte(`{
-				"alert": "DefaultSchemaTest",
+				"alert": "MissingSchemaTest",
 				"version": "v5",
 				"condition": {
 					"compositeQuery": {
@@ -672,24 +401,13 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 							}
 						}]
 					},
-					"target": 75.0,
-					"matchType": "1",
-					"op": "1"
-				}
+					"thresholds": {"kind": "basic", "spec": [{"name": "critical", "target": 75.0, "matchType": "1", "op": "1"}]}
+				},
+				"evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m", "frequency": "1m"}},
+				"notificationSettings": {"renotify": {"enabled": true, "interval": "4h", "alertStates": ["firing"]}}
 			}`),
-			kind:        RuleDataKindJson,
-			expectError: false,
-			validate: func(t *testing.T, rule *PostableRule) {
-				if rule.SchemaVersion != DefaultSchemaVersion {
-					t.Errorf("Expected default schemaVersion '%s', got '%s'", DefaultSchemaVersion, rule.SchemaVersion)
-				}
-				if rule.RuleCondition.Thresholds == nil {
-					t.Error("Expected Thresholds to be populated for default schema version")
-				}
-				if rule.Evaluation == nil {
-					t.Error("Expected Evaluation to be populated for default schema version")
-				}
-			},
+			kind:                RuleDataKindJson,
+			expectValidateError: true,
 		},
 	}
 
@@ -737,11 +455,7 @@ func TestParseIntoRuleThresholdGeneration(t *testing.T) {
 					}
 				}]
 			},
-			"target": 100.0,
-			"matchType": "1",
-			"op": "1",
-			"selectedQuery": "A",
-			"targetUnit": "ms",
+			"selectedQueryName": "A",
 			"thresholds": {
 				"kind": "basic",
 				"spec": [
@@ -907,428 +621,6 @@ 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",

pkg/types/ruletypes/roundtrip_test.go

@@ -147,7 +147,7 @@ func TestV2MinimalReadShape(t *testing.T) {
 
 	body := readBody(t, stored)
 
-	for _, field := range []string{"labels", "annotations", "description", "preferredChannels", "evalWindow", "frequency"} {
+	for _, field := range []string{"labels", "annotations", "description"} {
 		assert.NotContains(t, body, field)
 	}
 

tests/e2e/tests/trace-details/flamegraph.spec.ts

@@ -56,18 +56,12 @@ test.describe('Trace details — flamegraph', () => {
 	}) => {
 		await hoverFlamegraphSpan(page, trace.landmarks.errors[0]);
 
-		// The status row only renders in the hover card (not in waterfall rows),
+		// "status: error" only renders in the hover card (not in waterfall rows),
 		// so it proves both that the card opened and that we hovered the right
 		// (error) span — the bar was targeted by id via the span→rect map.
-		await expect(page.getByTestId('span-hover-card-status')).toHaveText(
-			/status\s*error/,
-		);
-		await expect(page.getByTestId('span-hover-card-start')).toHaveText(
-			/start\s*[\d.]+ ms/,
-		);
-		await expect(page.getByTestId('span-hover-card-duration')).toHaveText(
-			/duration\s*[\d.]+/,
-		);
+		await expect(page.getByText('status: error')).toBeVisible();
+		await expect(page.getByText(/start: [\d.]+ ms/)).toBeVisible();
+		await expect(page.getByText(/duration: [\d.]+/)).toBeVisible();
 	});
 
 	test('TC-02 clicking a bar selects the span, opens the drawer, and syncs the waterfall row', async ({

tests/fixtures/alerts.py

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

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

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

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

@@ -0,0 +1,156 @@
+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 unmarshal rule",
+            "errors": [],
+            "suggestions": [],
+        },
+    }
+
+
+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": [],
+        },
+    }