Merge branch 'main' into nv/alerts-migration

#### Description

- Langfuse SDK spans reached the thread with empty formatted messages:
the SDK writes them to `langfuse.observation.input/output`, which the
mapper never moved onto `gen_ai.*.messages`.
- `gen_ai.llm` v5 moves `langfuse.observation.input/output` onto
`gen_ai.input/output.messages` and copies `langfuse.observation.type`
onto `gen_ai.operation.name`, above every existing source. New spans
only.
- Formatter handles the shapes these spans carry: a superjson `{json}`
envelope, a single message object (incl. role-less `{tool_calls}` from
the LangChain handler), a bare list of Responses items (LiteLLM
`langfuse_otel` tool turns), and falls back to the raw output when the
OpenInference bucket is empty. Mixed-format warning dropped when one
side is generic or OpenInference.

  #### Additional Information

- Verified with unit tests, the shipped definition through the
in-process collector pipeline.
- Why Langfuse keeps its own keys instead of emitting semconv, checked
in the Langfuse repos:
- Docs ([OpenTelemetry
integration](https://langfuse.com/integrations/native/opentelemetry)):
`langfuse.*` attributes "always take precedence over the generic
OpenTelemetry conventions" and are "recommended for all users that are
manually instrumenting"; semconv is "still evolving", so OTel traces are
mapped into the Langfuse model.
- [Discussion #2509](https://github.com/orgs/langfuse/discussions/2509),
Sep 2024, maintainer: Langfuse features "not yet covered by the
conventions" and the risk of "breaking backwards compatibility once
conventions are in place" are the reasons for an own namespace.
- Ingestion (`OtelIngestionProcessor.ts`, `extractInputAndOutput`): own
keys first, then vendor keys, then semconv `gen_ai.*.messages`, then
events. Semconv is one vendor format among many.
- SDK sources: input and output are any JSON on any observation type
(span, agent, tool, generation, …), looser than `gen_ai.input.messages`.
- Still unmapped: `usage_details`, `cost_details`, `model.parameters`
are JSON objects; the mapper cannot extract fields, so pure Langfuse
spans have no tokens or cost.


Closes https://github.com/SigNoz/nerve-pod/issues/579

docs/api/openapi.yml

@@ -11381,20 +11381,10 @@ components:
           description: Whether the rule is paused. A disabled rule is neither evaluated
             nor notifies. Defaults to false.
           type: boolean
-        evalWindow:
-          description: The lookback window as a Go duration such as 5m. Only read
-            when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec
-            instead.
-          type: string
         evaluation:
           allOf:
           - $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
           description: The evaluation window, as a kind and spec.
-        frequency:
-          description: How often the rule is evaluated, as a Go duration such as 1m.
-            Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set
-            it in evaluation.spec instead.
-          type: string
         labels:
           additionalProperties:
             type: string
@@ -11406,13 +11396,6 @@ components:
           allOf:
           - $ref: '#/components/schemas/RuletypesNotificationSettings'
           description: Grouping, re-notification and routing behaviour.
-        preferredChannels:
-          description: The displayName of each notification channel to notify, for
-            schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries
-            its own channels.
-          items:
-            type: string
-          type: array
         ruleType:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleType'
@@ -11522,20 +11505,10 @@ components:
           description: Whether the rule is paused. A disabled rule is neither evaluated
             nor notifies. Defaults to false.
           type: boolean
-        evalWindow:
-          description: The lookback window as a Go duration such as 5m. Only read
-            when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec
-            instead.
-          type: string
         evaluation:
           allOf:
           - $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
           description: The evaluation window, as a kind and spec.
-        frequency:
-          description: How often the rule is evaluated, as a Go duration such as 1m.
-            Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set
-            it in evaluation.spec instead.
-          type: string
         id:
           description: The unique identifier of the rule.
           type: string
@@ -11550,13 +11523,6 @@ components:
           allOf:
           - $ref: '#/components/schemas/RuletypesNotificationSettings'
           description: Grouping, re-notification and routing behaviour.
-        preferredChannels:
-          description: The displayName of each notification channel to notify, for
-            schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries
-            its own channels.
-          items:
-            type: string
-          type: array
         ruleType:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleType'
@@ -11618,20 +11584,6 @@ components:
           allOf:
           - $ref: '#/components/schemas/RuletypesAlertCompositeQuery'
           description: The queries whose result is compared against the thresholds.
-        matchType:
-          allOf:
-          - $ref: '#/components/schemas/RuletypesMatchType'
-          description: 'schemaVersion v1 only: which points in the window must satisfy
-            op. Accepted as at_least_once, all_the_times, on_average, in_total or
-            last, their aliases avg and sum, or the legacy codes as strings, ''1''
-            to ''5''. Required for v1; v2alpha1 sets matchType on each threshold.'
-        op:
-          allOf:
-          - $ref: '#/components/schemas/RuletypesCompareOperator'
-          description: 'schemaVersion v1 only: how the value is compared with target.
-            Accepted as above, below, equal, not_equal, above_or_equal, below_or_equal
-            or outside_bounds, their symbols, or the legacy codes as strings, ''1''
-            to ''7''. Required for v1; v2alpha1 sets op on each threshold.'
         requireMinPoints:
           description: Whether a series is skipped until it has at least requiredNumPoints
             points in the window. Defaults to false.
@@ -11649,17 +11601,6 @@ components:
           description: The name of the query whose result is evaluated, such as A
             or F1. Must match a query in compositeQuery.
           type: string
-        target:
-          description: 'schemaVersion v1 only: the value compared against, in targetUnit.
-            Required for v1; v2alpha1 sets target on each threshold.'
-          format: double
-          nullable: true
-          type: number
-        targetUnit:
-          description: 'schemaVersion v1 only: the unit of target, such as percent
-            or ms. Converted to compositeQuery.unit before comparison when the two
-            differ.'
-          type: string
         thresholds:
           allOf:
           - $ref: '#/components/schemas/RuletypesRuleThresholdData'
@@ -25120,56 +25061,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

docs/contributing/go/spanmapper.md

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

ee/query-service/rules/anomaly.go

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

ee/query-service/rules/anomaly_test.go

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

frontend/package.json

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

frontend/pnpm-lock.yaml

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

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

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

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

@@ -18,11 +18,9 @@ import {
 import ROUTES from 'constants/routes';
 import { navigate } from 'lib/router/navigation';
 import { QueryParams } from 'constants/query';
-import { PANEL_TYPES } from 'constants/queryBuilder';
 import { DataSource } from 'types/common/queryBuilder';
 
 import {
-	buildExplorerNavigationUrl,
 	findSavedViewInLists,
 	openSavedView,
 	openSavedViewByKey,
@@ -232,23 +230,6 @@ describe('findSavedViewInLists', () => {
 	});
 });
 
-describe('buildExplorerNavigationUrl', () => {
-	it('encodes composite query and view selectors', () => {
-		const url = buildExplorerNavigationUrl(
-			ROUTES.LOGS_EXPLORER,
-			{ queryType: 'builder' } as never,
-			{
-				[QueryParams.panelTypes]: PANEL_TYPES.LIST,
-				[QueryParams.viewKey]: 'view-1',
-			},
-		);
-
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-		expect(url).toContain(`${QueryParams.compositeQuery}=`);
-		expect(url).toContain(`${QueryParams.viewKey}=`);
-	});
-});
-
 describe('openSavedView', () => {
 	beforeEach(() => {
 		mockedNavigate.mockClear();

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

@@ -12,7 +12,7 @@ import { toSavedViewSource } from 'container/SavedViews/utils/toSavedViewSource'
 import { SOURCEPAGE_VS_ROUTES } from 'container/SavedViews/constants';
 import { navigate } from 'lib/router/navigation';
 import { DataSource } from 'types/common/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { buildExplorerNavigationUrl } from 'utils/buildExplorerNavigationUrl';
 
 type SavedViewSourceHint = SavedViewSourcePage;
 
@@ -72,26 +72,6 @@ export function explorerRouteForSourcePage(
 	return SOURCEPAGE_VS_ROUTES[sourcePage] ?? null;
 }
 
-/**
- * Builds an explorer URL the same way `redirectWithQueryBuilderData` does —
- * without inheriting stale query params from the current page's `urlQuery`.
- */
-export function buildExplorerNavigationUrl(
-	route: string,
-	query: Query,
-	searchParams: Record<string, unknown>,
-): string {
-	const params = new URLSearchParams();
-	params.set(
-		QueryParams.compositeQuery,
-		encodeURIComponent(JSON.stringify(query)),
-	);
-	Object.entries(searchParams).forEach(([key, value]) => {
-		params.set(key, JSON.stringify(value));
-	});
-	return `${route}?${params.toString()}`;
-}
-
 export function openSavedView(view: SavedviewtypesSavedViewDTO): void {
 	const route = view.source ? explorerRouteForSourcePage(view.source) : null;
 	if (!route) {

frontend/src/container/Home/Home.tsx

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

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

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

frontend/src/container/SavedViews/SavedViewHoverCard.tsx

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

frontend/src/container/SavedViews/SavedViewHoverCardDetails.tsx

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

frontend/src/container/SavedViews/SavedViewHoverCardSkeleton.tsx

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

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

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

frontend/src/container/SavedViews/SavedViewsList.tsx

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

frontend/src/container/SavedViews/SavedViewsListRow.tsx

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

frontend/src/container/SavedViews/SavedViewsPanel.tsx

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

frontend/src/container/SavedViews/SavedViewsRowLink.tsx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

frontend/src/container/SavedViews/types.ts

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

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

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

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

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

frontend/src/hooks/__tests__/useTimeSearchParams.test.ts

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

frontend/src/hooks/useResourceAttribute/utils.ts

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

frontend/src/hooks/useTimeSearchParams.ts

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

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

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

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

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

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

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

frontend/src/utils/__tests__/buildExplorerNavigationUrl.test.ts

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

frontend/src/utils/__tests__/timeUrlParams.test.ts

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

frontend/src/utils/buildExplorerNavigationUrl.ts

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

pkg/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/modules/rulestatehistory/implrulestatehistory/links.go

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

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

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

pkg/query-service/app/http_handler.go

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

pkg/query-service/rules/base_rule.go

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

pkg/query-service/rules/manager.go

@@ -1048,6 +1048,8 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
 		m.logger.ErrorContext(ctx, "failed to unmarshal rule from db", slog.String("rule.id", id.StringValue()), errors.Attr(err))
 		return nil, err
 	}
+	// a rule stored before selectedQueryName was required resolves it the way evaluation does
+	storedRule.RuleCondition.SelectedQuery = storedRule.RuleCondition.SelectedQueryName()
 
 	if err := 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))

pkg/query-service/rules/manager_test_data.go

@@ -49,11 +49,10 @@ func ThresholdRuleAtLeastOnceValueAbove(target float64, recovery *float64) rulet
 		Annotations: map[string]string{
 			"value": "{{$value}}",
 		},
-		Version: "v5",
+		Version:       "v5",
+		SchemaVersion: ruletypes.SchemaVersionV2Alpha1,
 		RuleCondition: &ruletypes.RuleCondition{
-			MatchType:       ruletypes.AtleastOnce,
-			CompareOperator: ruletypes.ValueIsAbove,
-			Target:          &target,
+			SelectedQuery: "A",
 			CompositeQuery: &ruletypes.AlertCompositeQuery{
 				QueryType: ruletypes.QueryTypeBuilder,
 				Queries: []qbtypes.QueryEnvelope{
@@ -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

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

pkg/query-service/rules/prom_rule_test.go

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

pkg/query-service/rules/rule.go

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

pkg/query-service/rules/threshold_rule.go

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

pkg/query-service/rules/threshold_rule_test.go

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

pkg/ruler/handler.go

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

pkg/ruler/signozruler/handler.go

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

pkg/signoz/provider.go

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

pkg/sqlmigration/141_migrate_rules_v1_to_v2alpha1.go

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

pkg/types/aiobservabilitytypes/message_format.go

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

pkg/types/aiobservabilitytypes/message_format_openai_chat.go

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

pkg/types/aiobservabilitytypes/message_format_openai_chat_test.go

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

pkg/types/aiobservabilitytypes/message_format_openai_responses.go

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

pkg/types/aiobservabilitytypes/message_format_openai_responses_test.go

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

pkg/types/aiobservabilitytypes/message_format_openinference.go

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

pkg/types/aiobservabilitytypes/message_format_openinference_test.go

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

pkg/types/aiobservabilitytypes/message_format_test.go

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

pkg/types/alertmanagertypes/config.go

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

pkg/types/ruletypes/alerting.go

@@ -109,18 +109,14 @@ type AlertCompositeQuery struct {
 
 type RuleCondition struct {
 	CompositeQuery    *AlertCompositeQuery `json:"compositeQuery" required:"true" description:"The queries whose result is compared against the thresholds."`
-	CompareOperator   CompareOperator      `json:"op,omitzero" description:"schemaVersion v1 only: how the value is compared with target. Accepted as above, below, equal, not_equal, above_or_equal, below_or_equal or outside_bounds, their symbols, or the legacy codes as strings, '1' to '7'. Required for v1; v2alpha1 sets op on each threshold."`
-	Target            *float64             `json:"target,omitempty" format:"double" description:"schemaVersion v1 only: the value compared against, in targetUnit. Required for v1; v2alpha1 sets target on each threshold."`
 	AlertOnAbsent     bool                 `json:"alertOnAbsent,omitempty" description:"Whether to fire a nodata alert when the query returns no data. Defaults to false."`
 	AbsentFor         uint64               `json:"absentFor,omitempty" description:"How many minutes without data pass before the nodata alert fires. Ignored unless alertOnAbsent is true."`
-	MatchType         MatchType            `json:"matchType,omitzero" description:"schemaVersion v1 only: which points in the window must satisfy op. Accepted as at_least_once, all_the_times, on_average, in_total or last, their aliases avg and sum, or the legacy codes as strings, '1' to '5'. Required for v1; v2alpha1 sets matchType on each threshold."`
-	TargetUnit        string               `json:"targetUnit,omitempty" description:"schemaVersion v1 only: the unit of target, such as percent or ms. Converted to compositeQuery.unit before comparison when the two differ."`
 	Algorithm         string               `json:"algorithm,omitempty" description:"anomaly_rule only: the anomaly detection algorithm. The supported value is standard."`
 	Seasonality       Seasonality          `json:"seasonality,omitzero" description:"anomaly_rule only: the seasonal period the history is compared against, hourly, daily or weekly."`
-	SelectedQuery     string               `json:"selectedQueryName,omitempty" required:"true" description:"The name of the query whose result is evaluated, such as A or F1. Must match a query in compositeQuery."`
+	SelectedQuery     string               `json:"selectedQueryName" required:"true" description:"The name of the query whose result is evaluated, such as A or F1. Must match a query in compositeQuery."`
 	RequireMinPoints  bool                 `json:"requireMinPoints,omitempty" description:"Whether a series is skipped until it has at least requiredNumPoints points in the window. Defaults to false."`
 	RequiredNumPoints int                  `json:"requiredNumPoints,omitempty" description:"The minimum number of points a series needs before it is evaluated. Must be greater than 0 when requireMinPoints is true."`
-	Thresholds        *RuleThresholdData   `json:"thresholds,omitempty" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
+	Thresholds        *RuleThresholdData   `json:"thresholds" required:"true" description:"The thresholds to evaluate, as a kind and spec."`
 }
 
 func (rc *RuleCondition) SelectedQueryName() string {

pkg/types/ruletypes/api_params.go

@@ -49,7 +49,6 @@ func (t AlertType) BuilderQueryType() qbtypes.QueryType {
 }
 
 const (
-	DefaultSchemaVersion  = "v1"
 	SchemaVersionV2Alpha1 = "v2alpha1"
 )
 
@@ -61,12 +60,10 @@ const (
 
 // PostableRule is used to create alerting rule from HTTP api.
 type PostableRule struct {
-	AlertName   valuer.DisplayName  `json:"alert" required:"true" description:"The display name of the alert rule."`
-	AlertType   AlertType           `json:"alertType" required:"true" description:"The signal the rule evaluates: METRIC_BASED_ALERT, TRACES_BASED_ALERT, LOGS_BASED_ALERT, EXCEPTIONS_BASED_ALERT or AI_TRACES_BASED_ALERT."`
-	Description string              `json:"description,omitempty" description:"A human readable description of what the rule monitors."`
-	RuleType    RuleType            `json:"ruleType" required:"true" description:"The evaluation strategy: threshold_rule compares against thresholds, promql_rule evaluates a PromQL expression, anomaly_rule scores deviation from seasonal history. Defaults to threshold_rule for builder and clickhouse_sql queries and is forced to promql_rule for promql queries."`
-	EvalWindow  valuer.TextDuration `json:"evalWindow,omitzero" description:"The lookback window as a Go duration such as 5m. Only read when schemaVersion is v1, defaulting to 5m; v2alpha1 rules set it in evaluation.spec instead."`
-	Frequency   valuer.TextDuration `json:"frequency,omitzero" description:"How often the rule is evaluated, as a Go duration such as 1m. Only read when schemaVersion is v1, defaulting to 1m; v2alpha1 rules set it in evaluation.spec instead."`
+	AlertName   valuer.DisplayName `json:"alert" required:"true" description:"The display name of the alert rule."`
+	AlertType   AlertType          `json:"alertType" required:"true" description:"The signal the rule evaluates: METRIC_BASED_ALERT, TRACES_BASED_ALERT, LOGS_BASED_ALERT, EXCEPTIONS_BASED_ALERT or AI_TRACES_BASED_ALERT."`
+	Description string             `json:"description,omitempty" description:"A human readable description of what the rule monitors."`
+	RuleType    RuleType           `json:"ruleType" required:"true" description:"The evaluation strategy: threshold_rule compares against thresholds, promql_rule evaluates a PromQL expression, anomaly_rule scores deviation from seasonal history. Defaults to threshold_rule for builder and clickhouse_sql queries and is forced to promql_rule for promql queries."`
 
 	RuleCondition *RuleCondition    `json:"condition" required:"true" description:"The query to evaluate and the thresholds applied to its result."`
 	Labels        map[string]string `json:"labels,omitempty" description:"Labels attached to every alert the rule fires. Keys match [a-zA-Z_.][a-zA-Z0-9_.]*; values may use Go templates such as {{$labels.service_name}}. severity is the conventional routing label."`
@@ -76,14 +73,12 @@ type PostableRule struct {
 
 	Source string `json:"source,omitempty" description:"The URL of the page the rule was created from. Informational; it is not used for evaluation."`
 
-	PreferredChannels []string `json:"preferredChannels,omitempty" description:"The displayName of each notification channel to notify, for schemaVersion v1 rules. Ignored for v2alpha1, where each threshold carries its own channels."`
-
 	Version string `json:"version" description:"The query payload version. Nothing reads it."`
 
-	Evaluation    *EvaluationEnvelope `json:"evaluation,omitempty" required:"true" description:"The evaluation window, as a kind and spec."`
-	SchemaVersion string              `json:"schemaVersion,omitempty" required:"true" enum:"v2alpha1" description:"The rule payload schema."`
+	Evaluation    *EvaluationEnvelope `json:"evaluation" required:"true" description:"The evaluation window, as a kind and spec."`
+	SchemaVersion string              `json:"schemaVersion" required:"true" enum:"v2alpha1" description:"The rule payload schema."`
 
-	NotificationSettings *NotificationSettings `json:"notificationSettings,omitempty" required:"true" description:"Grouping, re-notification and routing behaviour."`
+	NotificationSettings *NotificationSettings `json:"notificationSettings" required:"true" description:"Grouping, re-notification and routing behaviour."`
 }
 
 type NotificationSettings struct {
@@ -228,27 +223,6 @@ 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:
@@ -258,71 +232,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)
 	}
 }
 
@@ -376,10 +285,6 @@ func (r *PostableRule) validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "condition: field is required")
 	}
 
-	if r.Version != "v5" {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "version: only v5 is supported, got %q", r.Version))
-	}
-
 	for k, v := range r.Labels {
 		if !isValidLabelName(k) {
 			errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid label name: %s", k))
@@ -423,10 +328,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))
-	}
-
 	if r.AlertType != "" {
 		switch r.AlertType {
 		case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions, AlertTypeAITraces:
@@ -462,7 +363,9 @@ func (r *PostableRule) Validate() error {
 		}
 	}
 
-	if r.RuleCondition.SelectedQuery != "" && r.RuleCondition.CompositeQuery != nil && len(r.RuleCondition.CompositeQuery.Queries) > 0 {
+	if r.RuleCondition.SelectedQuery == "" {
+		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "condition.selectedQueryName: field is required"))
+	} else if r.RuleCondition.CompositeQuery != nil && len(r.RuleCondition.CompositeQuery.Queries) > 0 {
 		found := false
 		for _, query := range r.RuleCondition.CompositeQuery.Queries {
 			if query.GetQueryName() == r.RuleCondition.SelectedQuery {
@@ -514,69 +417,26 @@ func (r *PostableRule) Validate() error {
 
 func (r *PostableRule) validateSchemaVersion() []error {
 	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		return r.validateV1()
 	case SchemaVersionV2Alpha1:
 		return r.validateV2Alpha1()
 	default:
 		return []error{errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"schemaVersion: unsupported value %q; must be one of %q, %q",
-			r.SchemaVersion, DefaultSchemaVersion, SchemaVersionV2Alpha1)}
+			"schemaVersion: unsupported value %q; must be %q",
+			r.SchemaVersion, SchemaVersionV2Alpha1)}
 	}
 }
 
-func (r *PostableRule) validateV1() []error {
-	var errs []error
-
-	if r.RuleCondition.Target == nil {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.target: field is required for schemaVersion %q", DefaultSchemaVersion))
-	}
-	if r.RuleCondition.CompareOperator.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.op: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.CompareOperator.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-	if r.RuleCondition.MatchType.IsZero() {
-		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"condition.matchType: field is required for schemaVersion %q", DefaultSchemaVersion))
-	} else if err := r.RuleCondition.MatchType.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-
-	return errs
-}
-
 func (r *PostableRule) validateV2Alpha1() []error {
 	var errs []error
 
-	// TODO(srikanthccv): reject v1-only fields?
-	// if r.RuleCondition.Target != nil {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.target: field is not used in schemaVersion %q; set target in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.CompareOperator.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.op: field is not used in schemaVersion %q; set op in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if !r.RuleCondition.MatchType.IsZero() {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"condition.matchType: field is not used in schemaVersion %q; set matchType in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-	// if len(r.PreferredChannels) > 0 {
-	// 	errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
-	// 		"preferredChannels: field is not used in schemaVersion %q; set channels in condition.thresholds entries instead",
-	// 		SchemaVersionV2Alpha1))
-	// }
-
 	// Require v2alpha1-specific fields
 	if r.RuleCondition.Thresholds == nil {
 		errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput,
 			"condition.thresholds: field is required for schemaVersion %q", SchemaVersionV2Alpha1))
+	} else if threshold, err := r.RuleCondition.Thresholds.GetRuleThreshold(); err == nil {
+		if err := threshold.Validate(); err != nil {
+			errs = append(errs, err)
+		}
 	}
 
 	if r.Evaluation == nil {
@@ -656,31 +516,6 @@ type GettableRule struct {
 	UpdatedBy *string   `json:"updateBy" nullable:"true" description:"The identifier of the user who last updated the rule."`
 }
 
-func (g *GettableRule) MarshalJSON() ([]byte, error) {
-	type Alias GettableRule
-
-	switch g.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *g
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	}
-}
-
 // Rule is the v2 API read model for an alerting rule. It aligns audit fields
 // with the canonical types.TimeAuditable / types.UserAuditable shape used by
 // PlannedMaintenance and other entities. v1 handlers keep serializing
@@ -709,28 +544,3 @@ func NewRule(g *GettableRule) *Rule {
 	}
 	return r
 }
-
-func (r *Rule) MarshalJSON() ([]byte, error) {
-	type Alias Rule
-
-	switch r.SchemaVersion {
-	case DefaultSchemaVersion:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		if aux.RuleCondition != nil {
-			aux.RuleCondition.Thresholds = nil
-		}
-		aux.Evaluation = nil
-		aux.SchemaVersion = ""
-		aux.NotificationSettings = nil
-		return json.Marshal(aux)
-	case SchemaVersionV2Alpha1:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	default:
-		copyStruct := *r
-		aux := Alias(copyStruct)
-		return json.Marshal(aux)
-	}
-}

pkg/types/ruletypes/api_params_test.go

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

pkg/types/ruletypes/evaluation.go

@@ -328,6 +328,9 @@ func (e *EvaluationEnvelope) UnmarshalJSON(data []byte) error {
 }
 
 func (e *EvaluationEnvelope) GetEvaluation() (Evaluation, error) {
+	if e == nil {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "evaluation is nil")
+	}
 	if e.Kind.IsZero() {
 		e.Kind = RollingEvaluation
 	}

pkg/types/ruletypes/roundtrip_test.go

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

pkg/types/ruletypes/threshold.go

@@ -85,9 +85,6 @@ func (r *RuleThresholdData) UnmarshalJSON(data []byte) error {
 		if err := json.Unmarshal(raw["spec"], &basicThresholds); err != nil {
 			return errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to unmarshal rule threshold spec: %v", err)
 		}
-		if err := basicThresholds.Validate(); err != nil {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid rule threshold spec: %v", err)
-		}
 		r.Spec = basicThresholds
 
 	default:
@@ -130,6 +127,9 @@ type RuleThreshold interface {
 	// using the given EvalData and returns the matching series
 	Eval(series *qbtypes.TimeSeries, unit string, evalData EvalData) (Vector, error)
 	GetRuleReceivers() []RuleReceivers
+	// Validate runs on the write path and before a task is built; a stored
+	// rule may hold a threshold that fails it and still decode.
+	Validate() error
 }
 
 type BasicRuleThreshold struct {

tests/fixtures/alerts.py

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

tests/integration/tests/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_threshold_validation.py

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