test(storybook): assert the in-flight create key button is disabled

docs/api/openapi.yml

@@ -1763,15 +1763,12 @@ components:
           additionalProperties: {}
           nullable: true
           type: object
-        syncState:
-          $ref: '#/components/schemas/CloudintegrationtypesSyncState'
         timestampMillis:
           format: int64
           type: integer
       required:
       - timestampMillis
       - data
-      - syncState
       type: object
     CloudintegrationtypesAzureAccountConfig:
       properties:
@@ -2016,8 +2013,6 @@ components:
           format: date-time
           nullable: true
           type: string
-        syncState:
-          $ref: '#/components/schemas/CloudintegrationtypesSyncState'
       required:
       - account_id
       - cloud_account_id
@@ -2027,7 +2022,6 @@ components:
       - providerAccountId
       - integrationConfig
       - removedAt
-      - syncState
       type: object
     CloudintegrationtypesGettableServicesMetadata:
       properties:
@@ -2127,9 +2121,6 @@ components:
           type: object
         providerAccountId:
           type: string
-        syncedVersion:
-          nullable: true
-          type: integer
       required:
       - data
       type: object
@@ -2142,18 +2133,6 @@ components:
         gcp:
           $ref: '#/components/schemas/CloudintegrationtypesGCPIntegrationConfig'
       type: object
-    CloudintegrationtypesRegionState:
-      enum:
-      - enabled
-      - disabled
-      type: string
-    CloudintegrationtypesRegionSyncState:
-      properties:
-        state:
-          $ref: '#/components/schemas/CloudintegrationtypesRegionState'
-      required:
-      - state
-      type: object
     CloudintegrationtypesService:
       properties:
         assets:
@@ -2295,23 +2274,6 @@ components:
         metrics:
           type: boolean
       type: object
-    CloudintegrationtypesSyncState:
-      nullable: true
-      properties:
-        inSync:
-          type: boolean
-        regions:
-          additionalProperties:
-            $ref: '#/components/schemas/CloudintegrationtypesRegionSyncState'
-          type: object
-        version:
-          format: int64
-          type: integer
-      required:
-      - version
-      - inSync
-      - regions
-      type: object
     CloudintegrationtypesUpdatableAccount:
       properties:
         config:

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -183,52 +183,32 @@ func (module *module) AgentCheckIn(ctx context.Context, orgID valuer.UUID, provi
 		return nil, errors.New(errors.TypeAlreadyExists, cloudintegrationtypes.ErrCodeCloudIntegrationAlreadyConnected, errMessage)
 	}
 
-	storableAccount, err := module.store.GetAccountByID(ctx, orgID, req.CloudIntegrationID, provider)
+	account, err := module.store.GetAccountByID(ctx, orgID, req.CloudIntegrationID, provider)
 	if err != nil {
 		return nil, err
 	}
 
-	account, err := cloudintegrationtypes.NewAccountFromStorable(storableAccount)
-	if err != nil {
-		return nil, err
-	}
-
-	syncState := account.NextSyncState(req.SyncedVersion)
-
 	// If account has been removed (disconnected), return a minimal response with empty integration config.
+	// The agent uses this response to clean up resources
 	if account.RemovedAt != nil {
-		// Heartbeat stays frozen after removal, only the sync state is updated.
-		if account.AgentReport != nil && syncState != nil {
-			account.UpdateSyncState(syncState)
-
-			storableAccount, err = cloudintegrationtypes.NewStorableCloudIntegration(account)
-			if err != nil {
-				return nil, err
-			}
-
-			err = module.store.UpdateAgentReport(ctx, storableAccount)
-			if err != nil {
-				return nil, err
-			}
-		}
-
 		return cloudintegrationtypes.NewAgentCheckInResponse(
 			req.ProviderAccountID,
 			account.ID.StringValue(),
 			new(cloudintegrationtypes.ProviderIntegrationConfig),
 			account.RemovedAt,
-			syncState,
 		), nil
 	}
 
-	account.UpdateAgentReport(&req.ProviderAccountID, cloudintegrationtypes.NewAgentReport(req.Data, syncState))
+	// update account with cloud provider account id and agent report (heartbeat)
+	account.Update(&req.ProviderAccountID, cloudintegrationtypes.NewAgentReport(req.Data))
 
-	storableAccount, err = cloudintegrationtypes.NewStorableCloudIntegration(account)
+	err = module.store.UpdateAccount(ctx, account)
 	if err != nil {
 		return nil, err
 	}
 
-	err = module.store.UpdateAgentReport(ctx, storableAccount)
+	// Get account as domain object for config access (enabled regions, etc.)
+	domainAccount, err := cloudintegrationtypes.NewAccountFromStorable(account)
 	if err != nil {
 		return nil, err
 	}
@@ -243,7 +223,8 @@ func (module *module) AgentCheckIn(ctx context.Context, orgID valuer.UUID, provi
 		return nil, err
 	}
 
-	integrationConfig, err := cloudProvider.BuildIntegrationConfig(ctx, account, storedServices)
+	// Delegate integration config building entirely to the provider module
+	integrationConfig, err := cloudProvider.BuildIntegrationConfig(ctx, domainAccount, storedServices)
 	if err != nil {
 		return nil, err
 	}
@@ -253,7 +234,6 @@ func (module *module) AgentCheckIn(ctx context.Context, orgID valuer.UUID, provi
 		account.ID.StringValue(),
 		integrationConfig,
 		account.RemovedAt,
-		syncState,
 	), nil
 }
 

frontend/.storybook/test-runner.ts

@@ -23,6 +23,10 @@ const IGNORED_MESSAGES = [
 	// (YouTube embeds, the docs pane) so they hit the real network instead of
 	// an unanswered msw request; the block is the point, not a bug.
 	/violates the following Content Security Policy directive/,
+	// The filter editor's ANTLR parser reports every syntax error through
+	// `console.error` (`line 1:14 missing ...`), so each partial expression
+	// typed into it logs one; the editor shows the same errors on screen.
+	/^line \d+:\d+ /,
 ];
 
 interface CapturedMessage {

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

@@ -3366,37 +3366,6 @@ export interface CloudintegrationtypesAWSServiceConfigDTO {
 	metrics?: CloudintegrationtypesAWSServiceMetricsConfigDTO;
 }
 
-export enum CloudintegrationtypesRegionStateDTO {
-	enabled = 'enabled',
-	disabled = 'disabled',
-}
-export interface CloudintegrationtypesRegionSyncStateDTO {
-	state: CloudintegrationtypesRegionStateDTO;
-}
-
-export type CloudintegrationtypesSyncStateDTORegions = {
-	[key: string]: CloudintegrationtypesRegionSyncStateDTO;
-};
-
-/**
- * @nullable
- */
-export type CloudintegrationtypesSyncStateDTO = {
-	/**
-	 * @type boolean
-	 */
-	inSync: boolean;
-	/**
-	 * @type object
-	 */
-	regions: CloudintegrationtypesSyncStateDTORegions;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	version: number;
-} | null;
-
 export type CloudintegrationtypesAgentReportDTODataAnyOf = {
 	[key: string]: unknown;
 };
@@ -3415,7 +3384,6 @@ export type CloudintegrationtypesAgentReportDTO = {
 	 * @type object,null
 	 */
 	data: CloudintegrationtypesAgentReportDTOData;
-	syncState: CloudintegrationtypesSyncStateDTO | null;
 	/**
 	 * @type integer
 	 * @format int64
@@ -3844,7 +3812,6 @@ export interface CloudintegrationtypesGettableAgentCheckInDTO {
 	 * @format date-time
 	 */
 	removedAt: string | null;
-	syncState: CloudintegrationtypesSyncStateDTO | null;
 }
 
 export interface CloudintegrationtypesServiceMetadataDTO {
@@ -3915,10 +3882,6 @@ export interface CloudintegrationtypesPostableAgentCheckInDTO {
 	 * @type string
 	 */
 	providerAccountId?: string;
-	/**
-	 * @type integer,null
-	 */
-	syncedVersion?: number | null;
 }
 
 export interface CloudintegrationtypesStorableIntegrationDashboardDTO {

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/stories/__story_mockdata__/querySearch.play.ts

@@ -0,0 +1,241 @@
+import { EditorView } from '@codemirror/view';
+import { userEvent, waitFor, within } from 'storybook/test';
+
+/** Suggestions wait on a 300ms debounce and a fetch, past the 1s default. */
+const untilLoaded = { timeout: 15_000 };
+
+/**
+ * The editor is controlled: each change round-trips through React state before
+ * the next one is applied on top of it. People type slower than this.
+ */
+const KEYSTROKE_MS = 50;
+
+/** Throws until `found` holds something, which is what `waitFor` retries on. */
+const present = <TValue>(
+	found: TValue | null | undefined,
+	what: string,
+): TValue => {
+	if (found === null || found === undefined) {
+		throw new Error(`${what} not found`);
+	}
+
+	return found;
+};
+
+const pause = (ms: number): Promise<void> =>
+	new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+
+const suggestionList = (canvasElement: HTMLElement): HTMLElement | null =>
+	canvasElement.querySelector<HTMLElement>('.cm-tooltip-autocomplete');
+
+const suggestionRow = (
+	canvasElement: HTMLElement,
+	text: string,
+): HTMLElement | undefined => {
+	const list = suggestionList(canvasElement);
+
+	return list
+		? within(list)
+				.queryAllByRole('option')
+				.find((option) => option.textContent?.includes(text))
+		: undefined;
+};
+
+/** Ctrl+Space, the editor's own shortcut for asking for suggestions. */
+const requestSuggestions = (editor: HTMLElement): void => {
+	editor.dispatchEvent(
+		new KeyboardEvent('keydown', {
+			key: ' ',
+			code: 'Space',
+			ctrlKey: true,
+			bubbles: true,
+		}),
+	);
+};
+
+const currentView = (
+	canvasElement: HTMLElement,
+): { editor: HTMLElement; view: EditorView } => {
+	// An explorer renders one editor per query; the first is the one on screen.
+	const editor = present(
+		canvasElement.querySelector<HTMLElement>(
+			'.code-mirror-where-clause .cm-content',
+		),
+		'filter editor',
+	);
+
+	return {
+		editor,
+		view: present(EditorView.findFromDOM(editor), 'editor view'),
+	};
+};
+
+/**
+ * The explorers wrap the filter in `OverlayScrollbar`, which initialises when
+ * the browser is idle. Initialising moves the content, the editor with it, and
+ * focuses the editor again through the DOM, which puts the caret back at the
+ * start and swaps the suggestions for the key list. Throws until every wrapper
+ * around the filter has initialised.
+ */
+const assertScrollbarsReady = (editor: HTMLElement): void => {
+	for (
+		let wrapper = editor.closest('.overlay-scrollbar');
+		wrapper;
+		wrapper = wrapper.parentElement?.closest('.overlay-scrollbar') ?? null
+	) {
+		if (!wrapper.hasAttribute('data-overlayscrollbars')) {
+			throw new Error('scrollbars around the filter still initialising');
+		}
+	}
+};
+
+/**
+ * Waits until `text` shows in the suggestion list, asking for suggestions
+ * whenever the list is shut. Focus and typing only open it once the keys have
+ * loaded, and moving the caret never does.
+ */
+const waitForSuggestion = (
+	canvasElement: HTMLElement,
+	text: string,
+): Promise<HTMLElement> =>
+	waitFor(
+		() => {
+			const { editor } = currentView(canvasElement);
+
+			if (!suggestionList(canvasElement)) {
+				requestSuggestions(editor);
+			}
+
+			return present(suggestionRow(canvasElement, text), `suggestion "${text}"`);
+		},
+		{ ...untilLoaded, interval: 250 },
+	);
+
+/**
+ * Focuses the filter once the scrollbars around it have initialised, and waits
+ * for its suggestion list.
+ */
+const focusFilter = async (canvasElement: HTMLElement): Promise<EditorView> => {
+	await waitFor(
+		() => {
+			const { editor, view } = currentView(canvasElement);
+
+			assertScrollbarsReady(editor);
+
+			if (!view.hasFocus) {
+				view.focus();
+			}
+
+			if (!suggestionList(canvasElement)) {
+				requestSuggestions(editor);
+			}
+
+			return present(suggestionList(canvasElement), 'suggestion list');
+		},
+		{ ...untilLoaded, interval: 250 },
+	);
+
+	return currentView(canvasElement).view;
+};
+
+/** Waits for a row of the suggestion list. */
+export const findSuggestion = (
+	canvasElement: HTMLElement,
+	text: string,
+): Promise<HTMLElement> => waitForSuggestion(canvasElement, text);
+
+/** Focuses the empty filter: every key, with any recent filters above them. */
+export const openKeySuggestions = async (
+	canvasElement: HTMLElement,
+	row: string,
+): Promise<void> => {
+	await focusFilter(canvasElement);
+	await waitForSuggestion(canvasElement, row);
+};
+
+/**
+ * Focuses the filter and types onto the end of it one character at a time,
+ * each as the transaction a keystroke makes, leaving the caret at the end so
+ * the suggestion list follows what was typed. Quotes and brackets are not
+ * closed for it: type both.
+ *
+ * `userEvent.type` cannot be used: CodeMirror redraws the line as tokens are
+ * highlighted, which strands the caret `userEvent` tracks.
+ */
+export const typeFilter = async (
+	canvasElement: HTMLElement,
+	text: string,
+): Promise<void> => {
+	const view = await focusFilter(canvasElement);
+
+	for (const character of text) {
+		const at = view.state.doc.length;
+
+		view.dispatch({
+			changes: { from: at, insert: character },
+			selection: { anchor: at + character.length },
+			userEvent: 'input.type',
+		});
+		await pause(KEYSTROKE_MS);
+	}
+};
+
+/**
+ * Types an expression, then steps the caret back inside it, before a closing
+ * bracket or parenthesis, where the suggestions are about what goes in there.
+ */
+export const typeFilterWithCaretBack = async (
+	canvasElement: HTMLElement,
+	text: string,
+	stepsBack: number,
+	row: string,
+): Promise<void> => {
+	await typeFilter(canvasElement, text);
+
+	const { view } = currentView(canvasElement);
+
+	view.dispatch({
+		selection: { anchor: view.state.doc.length - stepsBack },
+		userEvent: 'select',
+	});
+	await waitForSuggestion(canvasElement, row);
+};
+
+/**
+ * Moves focus off the filter, which is when the expression is validated and
+ * the error marker can show.
+ */
+export const blurFilter = async (canvasElement: HTMLElement): Promise<void> => {
+	await userEvent.keyboard('{Escape}');
+	await userEvent.click(canvasElement.ownerDocument.body);
+};
+
+/** Types an expression, leaves the filter and opens its validation errors. */
+export const showFilterErrors = async (
+	canvasElement: HTMLElement,
+	text: string,
+): Promise<void> => {
+	await typeFilter(canvasElement, text);
+	await blurFilter(canvasElement);
+
+	const marker = await waitFor(
+		() =>
+			present(
+				canvasElement.querySelector<HTMLElement>('.query-status-container button'),
+				'error marker',
+			),
+		untilLoaded,
+	);
+
+	await userEvent.hover(marker);
+	await waitFor(
+		() =>
+			present(
+				canvasElement.ownerDocument.querySelector('.query-validation-error'),
+				'validation error',
+			),
+		untilLoaded,
+	);
+};

frontend/src/container/Integrations/CloudIntegration/AmazonWebServices/__tests__/mockData.ts

@@ -24,7 +24,6 @@ const accountsResponse: ListAccounts200 = {
 				agentReport: {
 					timestampMillis: 1747114366214,
 					data: null,
-					syncState: null,
 				},
 				providerAccountId: PROVIDER_ACCOUNT_ID,
 				removedAt: null,

frontend/src/modules/Servicemap/stories/ServiceMap.stories.mocks.tsx

@@ -8,6 +8,7 @@ import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { encode } from 'js-base64';
 import type { Tags } from 'hooks/useResourceAttribute/types';
+import { fireEvent, userEvent, waitFor, within } from 'storybook/test';
 
 import {
 	choiceControl,
@@ -31,6 +32,9 @@ import {
 	type ServiceHealth,
 } from './__story_mockdata__/serviceMap';
 
+/** The keys are only fetched once the select opens, past the 1s default. */
+const untilLoaded = { timeout: 15_000 };
+
 const GRAPH = 'Service map · graph';
 const FILTERS = 'Service map · filters';
 
@@ -129,3 +133,80 @@ export const serviceMapMocks = defineStoryMocks({
 	],
 	config: (values) => ({ route: serviceMapRoute(values.filters) }),
 });
+
+/** Opens the select under a test id; it closes again after every pick. */
+export const openSelect = async (
+	canvasElement: HTMLElement,
+	testId: string,
+): Promise<void> => {
+	const select = await within(canvasElement).findByTestId(
+		testId,
+		undefined,
+		untilLoaded,
+	);
+
+	await userEvent.click(within(select).getByRole('combobox'));
+};
+
+export const OPEN_DROPDOWN =
+	'.ant-select-dropdown:not(.ant-select-dropdown-hidden)';
+
+/** antd keeps a hidden copy of each label for screen readers; the title skips it. */
+const visibleOption = (title: string): HTMLElement | null =>
+	document.querySelector<HTMLElement>(
+		`${OPEN_DROPDOWN} .ant-select-item-option[title="${title}"]`,
+	);
+
+/**
+ * Picks the option titled `title` in the open dropdown. `userEvent.click`
+ * moves focus off the select on the way, which closes it before the option
+ * takes the click.
+ */
+export const pickOption = async (title: string): Promise<void> => {
+	const option = await waitFor(() => {
+		const match = visibleOption(title);
+
+		if (!match) {
+			throw new Error(`option "${title}" not found`);
+		}
+
+		return match;
+	}, untilLoaded);
+
+	await fireEvent.click(option);
+};
+
+/**
+ * Opens the attribute filter on its next step. Each single-choice pick closes
+ * the dropdown and swaps the select for the next step's, and a click that lands
+ * before the swap opens nothing, so it opens again until `title` shows.
+ */
+export const openAttributeFilterOn = (
+	canvasElement: HTMLElement,
+	title: string,
+): Promise<void> =>
+	waitFor(
+		async () => {
+			if (visibleOption(title)) {
+				return;
+			}
+
+			if (!document.querySelector(OPEN_DROPDOWN)) {
+				await openSelect(canvasElement, 'resource-attributes-filter');
+			}
+
+			throw new Error(`option "${title}" not shown`);
+		},
+		{ ...untilLoaded, interval: 500 },
+	);
+
+/** Stages `k8s.cluster.name IN` and leaves the filter open on its values. */
+export const stageClusterIn = async (
+	canvasElement: HTMLElement,
+): Promise<void> => {
+	await openAttributeFilterOn(canvasElement, 'k8s.cluster.name');
+	await pickOption('k8s.cluster.name');
+	await openAttributeFilterOn(canvasElement, 'IN');
+	await pickOption('IN');
+	await openAttributeFilterOn(canvasElement, 'staging-eu');
+};

frontend/src/modules/Servicemap/stories/ServiceMap.stories.tsx

@@ -1,10 +1,17 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
-import { screen, userEvent, within } from 'storybook/test';
+import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
-import { serviceMapMocks } from './ServiceMap.stories.mocks';
+import {
+	OPEN_DROPDOWN,
+	openAttributeFilterOn,
+	openSelect,
+	pickOption,
+	serviceMapMocks,
+	stageClusterIn,
+} from './ServiceMap.stories.mocks';
 
 import ServiceMapContainer from '../index';
 
@@ -97,3 +104,49 @@ export const FilterAttributes: Story = {
 		await screen.findByText('k8s.cluster.name', undefined, untilLoaded);
 	},
 };
+
+/** A key staged as a chip, the filter open again on how to match it. */
+export const FilterOperators: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openAttributeFilterOn(canvasElement, 'k8s.cluster.name');
+		await pickOption('k8s.cluster.name');
+		await openAttributeFilterOn(canvasElement, 'Not IN');
+	},
+};
+
+/** A key and `IN` staged, the filter open on the values the key holds. */
+export const FilterValues: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await stageClusterIn(canvasElement);
+	},
+};
+
+/** Two values ticked before the filter is left, which is what applies it. */
+export const FilterValuesSelected: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await stageClusterIn(canvasElement);
+		await pickOption('prod-us-east');
+		await pickOption('prod-eu-west');
+		await waitFor(
+			() =>
+				expect(
+					document.querySelectorAll('.ant-select-item-option-selected'),
+				).toHaveLength(2),
+			untilLoaded,
+		);
+	},
+};
+
+/** The environment selector open on the environments the calls came from. */
+export const EnvironmentOptions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openSelect(canvasElement, 'resource-environment-filter');
+		await waitFor(
+			() =>
+				expect(
+					document.querySelector(`${OPEN_DROPDOWN} .ant-select-item-option`),
+				).not.toBeNull(),
+			untilLoaded,
+		);
+	},
+};

frontend/src/pages/AlertList/PlannedDowntime/stories/PlannedDowntime.stories.tsx

@@ -103,6 +103,18 @@ export const DeleteDowntimeConfirm: Story = {
 	},
 };
 
+/** The new-downtime form set to repeat weekly, which adds the days and duration. */
+export const NewDowntimeRecurring: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await NewDowntime.play?.({ canvasElement } as never);
+		await userEvent.click(
+			await screen.findByRole('combobox', { name: 'Repeats every' }),
+		);
+		await userEvent.click(await screen.findByText('Weekly'));
+		await screen.findByText('Duration');
+	},
+};
+
 /** A client-side search with no matching downtime schedule. */
 export const SearchNoResults: Story = {
 	play: async ({ canvasElement }): Promise<void> => {

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

@@ -6,9 +6,19 @@
 import { rest } from 'msw';
 import set from 'api/browser/localstorage/set';
 import { LOCALSTORAGE } from 'constants/localStorage';
+import { screen, userEvent, waitFor, within } from 'storybook/test';
 
-import { countControl, toggleControl } from '@/storybook/controls/controls';
+import {
+	choiceControl,
+	countControl,
+	toggleControl,
+} from '@/storybook/controls/controls';
 import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
+import {
+	RESPONSE_STATES,
+	type ResponseState,
+	respondWith,
+} from '@/storybook/runtime/responseState';
 import { fieldValuesResponse } from '@/storybook/msw/__story_mockdata__/fields';
 
 import {
@@ -23,6 +33,9 @@ import {
 	type ListErrorsBody,
 } from './__story_mockdata__/exceptions';
 
+/** The page fetches before it renders a row, which outlasts the 1s default. */
+const untilLoaded = { timeout: 15_000 };
+
 const LIST = 'Exceptions · list';
 const FILTERS = 'Exceptions · filters';
 
@@ -42,6 +55,13 @@ export const exceptionsMocks = defineStoryMocks({
 			value: 6,
 			max: EXCEPTION_QUICK_FILTER_CAP,
 		}),
+		filterKeys: choiceControl<ResponseState>('Filter keys', {
+			group: FILTERS,
+			description:
+				'How `/autocomplete/attribute_keys` answers when the resource filter opens, apart from the page-wide Data control.',
+			options: RESPONSE_STATES,
+			value: 'loaded',
+		}),
 		filterPanel: toggleControl('Quick filters panel', {
 			group: FILTERS,
 			description:
@@ -92,7 +112,7 @@ export const exceptionsMocks = defineStoryMocks({
 
 		rest.get(
 			'http://localhost/api/v3/autocomplete/attribute_keys',
-			response.json((req) =>
+			respondWith(values.filterKeys, (req) =>
 				exceptionAttributeKeysResponse(req.url.searchParams.get('searchText')),
 			),
 		),
@@ -111,3 +131,61 @@ export const exceptionsMocks = defineStoryMocks({
 		set(LOCALSTORAGE.SHOW_EXCEPTIONS_QUICK_FILTERS, String(values.filterPanel));
 	},
 });
+
+export const openResourceFilter = async (
+	canvasElement: HTMLElement,
+): Promise<HTMLElement> => {
+	const filter = await within(canvasElement).findByTestId(
+		'qb-search-select',
+		undefined,
+		untilLoaded,
+	);
+
+	await userEvent.click(within(filter).getByRole('combobox'));
+
+	return filter;
+};
+
+/**
+ * Clicks the visible row whose label is `text`. The dropdown renders in the
+ * body, a key row carries its type beside the label, and antd keeps a hidden
+ * copy of each label for screen readers that takes no clicks.
+ *
+ * The key list renders twice after the filter opens, since a second key
+ * request empties it until it answers. The click happens in the same task as
+ * the lookup: `fireEvent` from `storybook/test` dispatches a tick later, which
+ * can land on a row already removed and never reach React.
+ */
+export const pickSuggestion = async (text: string): Promise<void> => {
+	await waitFor(() => {
+		const match = Array.from(
+			document.querySelectorAll<HTMLElement>(
+				'.query-builder-search.ant-select-dropdown:not(.ant-select-dropdown-hidden) .ant-select-item-option',
+			),
+		).find((option) =>
+			Array.from(option.querySelectorAll('*')).some(
+				(node) => node.children.length === 0 && node.textContent === text,
+			),
+		);
+
+		if (!match) {
+			throw new Error(`suggestion "${text}" not found`);
+		}
+
+		// `userEvent.click` moves focus off the search input on the way, which closes
+		// the dropdown before the row takes the click.
+		match.click();
+	}, untilLoaded);
+};
+
+export const commitFilter = async (
+	key: string,
+	operator: string,
+	value: string,
+): Promise<void> => {
+	await pickSuggestion(key);
+	await screen.findByText('Operator for', { exact: false }, untilLoaded);
+	await pickSuggestion(operator);
+	await screen.findByText('Value(s) for', { exact: false }, untilLoaded);
+	await pickSuggestion(value);
+};

frontend/src/pages/AllErrors/stories/AllErrors.stories.tsx

@@ -5,7 +5,12 @@ import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
-import { exceptionsMocks } from './AllErrors.stories.mocks';
+import {
+	commitFilter,
+	exceptionsMocks,
+	openResourceFilter,
+	pickSuggestion,
+} from './AllErrors.stories.mocks';
 import AllErrors from '../index';
 
 type AllErrorsArgs = PageStoryArgs<typeof exceptionsMocks>;
@@ -125,3 +130,108 @@ export const QuickFiltersSettingsWithBanner: Story = {
 	args: { banner: 'trial-expiry' },
 	play: dirtyQuickFiltersSettings,
 };
+
+/** The resource filter opened: every key the exceptions can be narrowed by. */
+export const FilterKeySuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await screen.findByText('Suggested Filters', undefined, untilLoaded);
+	},
+};
+
+/** The key list grown past its first rows with the Show all shortcut. */
+export const FilterAllKeys: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await screen.findByText('Show all filter items', undefined, untilLoaded);
+		await userEvent.keyboard('{Control>}/{/Control}');
+		await screen.findByText('cloud.region', undefined, untilLoaded);
+	},
+};
+
+/** A partial key: the typed text as a free search, then the keys that match. */
+export const FilterPartialKey: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const filter = await openResourceFilter(canvasElement);
+
+		await userEvent.type(within(filter).getByRole('combobox'), 'serv');
+		await screen.findByText('service.namespace', undefined, untilLoaded);
+	},
+};
+
+/** A key picked: the operators the exceptions page allows for it. */
+export const FilterOperatorSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await pickSuggestion('service.name');
+		await screen.findByText('Operator for', { exact: false }, untilLoaded);
+	},
+};
+
+/** A key and an operator picked: the values the key holds. */
+export const FilterValueSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await pickSuggestion('service.name');
+		await pickSuggestion('=');
+		await screen.findByText('Value(s) for', { exact: false }, untilLoaded);
+	},
+};
+
+/** Two conditions committed as chips, with the dropdown closed again. */
+export const FilterChips: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await commitFilter('service.name', '=', 'checkout');
+		await commitFilter('deployment.environment', '!=', 'staging');
+		await userEvent.click(canvasElement.ownerDocument.body);
+		await within(canvasElement).findByText(
+			'deployment.environment != staging',
+			undefined,
+			untilLoaded,
+		);
+	},
+};
+
+/**
+ * A committed chip clicked to change it: its text goes back into the input,
+ * with the dropdown shut until the input is typed into.
+ */
+export const FilterEditChip: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await commitFilter('service.name', '=', 'checkout');
+		await userEvent.click(
+			await within(canvasElement).findByText(
+				'service.name = checkout',
+				undefined,
+				untilLoaded,
+			),
+		);
+		// The select remounts whenever its chips change, so it is looked up again.
+		await waitFor(
+			() =>
+				expect(
+					within(within(canvasElement).getByTestId('qb-search-select')).getByRole(
+						'combobox',
+					),
+				).toHaveValue('service.name = checkout'),
+			untilLoaded,
+		);
+	},
+};
+
+/** The key list while its request is still in flight. */
+export const FilterKeysLoading: Story = {
+	args: { filterKeys: 'loading' },
+	play: async ({ canvasElement }): Promise<void> => {
+		await openResourceFilter(canvasElement);
+		await waitFor(
+			() =>
+				expect(
+					document.querySelector('.query-builder-search .ant-spin'),
+				).not.toBeNull(),
+			untilLoaded,
+		);
+	},
+};

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

@@ -15,7 +15,10 @@ import {
 	toggleControl,
 } from '@/storybook/controls/controls';
 import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
-import { fieldValuesResponse } from '@/storybook/msw/__story_mockdata__/fields';
+import {
+	fieldKeysResponse,
+	fieldValuesResponse,
+} from '@/storybook/msw/__story_mockdata__/fields';
 import { queryRangeV5ScalarResponse } from '@/storybook/msw/__story_mockdata__/queryRange';
 
 import {
@@ -31,6 +34,7 @@ import {
 import {
 	emptyPanelResponse,
 	NAMESPACE_VALUES,
+	VARIABLE_ATTRIBUTES,
 	panelResponse,
 	serviceVariableValues,
 } from './__story_mockdata__/panelData';
@@ -238,6 +242,12 @@ export const dashboardMocks = defineStoryMocks({
 				response.json(() => fieldValuesResponse(NAMESPACE_VALUES)),
 			),
 
+			// The dynamic variable editor lists the attributes a variable can read.
+			rest.get(
+				'http://localhost/api/v1/fields/keys',
+				response.json(() => fieldKeysResponse(VARIABLE_ATTRIBUTES)),
+			),
+
 			// The header reads the public link on every load, so it answers even while
 			// the panels are held in the loading or failed state.
 			rest.get('http://localhost/api/v1/dashboards/:id/public', (_req, res, ctx) =>

frontend/src/pages/DashboardPage/stories/DashboardPage.stories.tsx

@@ -2,7 +2,7 @@ import type { ComponentType } from 'react';
 import type { Meta, StoryObj } from '@storybook/react-vite';
 import { Route } from 'react-router-dom';
 import ROUTES from 'constants/routes';
-import { screen, userEvent, within } from 'storybook/test';
+import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
@@ -285,6 +285,67 @@ export const SectionActionsMenu: Story = {
 	},
 };
 
+/** The panel menu's move-to-section submenu, open on the sections it can go to. */
+export const PanelMoveToSectionSubmenu: Story = {
+	play: async (context) => {
+		await PanelActionsMenu.play?.(context);
+		await userEvent.hover(await screen.findByText('Move to section'));
+		// The submenu lists the sections the panel is not already in.
+		await waitFor(() => expect(screen.getAllByRole('menu')).toHaveLength(2), {
+			timeout: 10000,
+		});
+	},
+};
+
+/** Dashboard settings on the Publish tab, where the public link is managed. */
+export const SettingsPublicDashboard: Story = {
+	play: async ({ canvasElement }) => {
+		await userEvent.click(
+			await within(canvasElement).findByRole(
+				'button',
+				{ name: 'Configure' },
+				{ timeout: 10000 },
+			),
+		);
+		await userEvent.click(await screen.findByRole('tab', { name: 'Publish' }));
+		await screen.findByText('Default time range');
+	},
+};
+
+/** The Publish tab with its default time range select open. */
+export const SettingsPublicDashboardSelectOpen: Story = {
+	play: async (context) => {
+		await SettingsPublicDashboard.play?.(context);
+		await userEvent.click(
+			within(screen.getByRole('tabpanel')).getByRole('combobox'),
+		);
+		await screen.findByRole('listbox');
+	},
+};
+
+/** The Variables tab of dashboard settings with a new variable's form open. */
+export const SettingsVariablesNew: Story = {
+	play: async ({ canvasElement }) => {
+		await userEvent.click(
+			await within(canvasElement).findByRole(
+				'button',
+				{ name: 'Configure' },
+				{ timeout: 10000 },
+			),
+		);
+		await userEvent.click(await screen.findByRole('tab', { name: 'Variables' }));
+		const add = await within(await screen.findByRole('tabpanel')).findByRole(
+			'button',
+			{ name: 'Add variable' },
+		);
+
+		// The button stays disabled until its permission check resolves.
+		await waitFor(() => expect(add).toBeEnabled(), { timeout: 10000 });
+		await userEvent.click(add);
+		await screen.findByText('Variable Type');
+	},
+};
+
 /**
  * A dashboard id nobody has, which is what a deleted or mistyped link opens on.
  *

frontend/src/pages/DashboardPage/stories/__story_mockdata__/panelData.ts

@@ -168,6 +168,15 @@ export const serviceVariableValues = (count: number): string[] =>
 	);
 
 /** Values the dynamic `namespace` variable resolves from the fields endpoint. */
+/** Attributes the dynamic variable editor offers a variable to read. */
+export const VARIABLE_ATTRIBUTES = [
+	'k8s.namespace.name',
+	'k8s.cluster.name',
+	'service.name',
+	'deployment.environment',
+	'host.name',
+];
+
 export const NAMESPACE_VALUES = [
 	'checkout-prod',
 	'payments-prod',

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

@@ -6,6 +6,7 @@
 import { rest } from 'msw';
 import type { GetDashboardV2200 } from 'api/generated/services/sigNoz.schemas';
 import ROUTES from 'constants/routes';
+import { screen, userEvent, waitFor, within } from 'storybook/test';
 
 import {
 	choiceControl,
@@ -342,3 +343,30 @@ export const dashboardsListMocks = defineStoryMocks({
 		});
 	},
 });
+
+/** Opens the actions menu of the row at `index`. */
+export const openRowActions = async (
+	canvasElement: HTMLElement,
+	index: number,
+): Promise<void> => {
+	// The icon-only trigger carries no accessible name.
+	const triggers = await within(canvasElement).findAllByTestId(
+		'dashboard-action-icon',
+		{},
+		{ timeout: 10000 },
+	);
+
+	await userEvent.click(triggers[index]);
+	await screen.findByText('Rename');
+};
+
+/** Picks a row action, retrying while its permission check still disables it. */
+export const pickRowAction = async (label: string | RegExp): Promise<void> => {
+	await waitFor(
+		async () => {
+			await userEvent.click(screen.getByText(label));
+			await screen.findByRole('dialog', {}, { timeout: 500 });
+		},
+		{ timeout: 10000 },
+	);
+};

frontend/src/pages/DashboardsListPage/stories/DashboardsListPage.stories.tsx

@@ -6,7 +6,9 @@ import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
 import {
 	dashboardsListMocks,
+	openRowActions,
 	overflowingRows,
+	pickRowAction,
 } from './DashboardsListPage.stories.mocks';
 import { BuiltinViewId } from '../types';
 
@@ -114,6 +116,45 @@ export const Tooltips: Story = {
 	parameters: { msw: { handlers: [overflowingRows] } },
 };
 
+/** The first row's actions menu, open over the list. */
+export const RowActionsMenu: Story = {
+	play: async ({ canvasElement }) => {
+		await openRowActions(canvasElement, 0);
+	},
+};
+
+/** The rename dialog, opened from the menu of the second row (the first is locked). */
+export const RenameDashboardDialog: Story = {
+	play: async ({ canvasElement }) => {
+		await openRowActions(canvasElement, 1);
+		await pickRowAction('Rename');
+		await screen.findByRole('dialog', { name: 'Rename dashboard' });
+	},
+};
+
+/** The tags dialog, opened from the menu of the second row (the first is locked). */
+export const EditTagsDialog: Story = {
+	play: async ({ canvasElement }) => {
+		await openRowActions(canvasElement, 1);
+		await pickRowAction(/^(Edit|Add) Tags$/);
+		await screen.findByRole('dialog', { name: /^(Edit|Add) tags$/ });
+	},
+};
+
+/** The popover that names the current filters as a new saved view. */
+export const SaveViewPopover: Story = {
+	play: async ({ canvasElement }) => {
+		await userEvent.click(
+			await within(canvasElement).findByRole(
+				'button',
+				{ name: 'Save current filters as a view' },
+				{ timeout: 10000 },
+			),
+		);
+		await screen.findByText('Save as view');
+	},
+};
+
 /**
  * The query the backend refused: the parse error it returned replaces the
  * generic failure copy, and there is nothing to retry.

frontend/src/pages/InfrastructureMonitoring/stories/Pods.stories.tsx

@@ -1,4 +1,9 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
+import {
+	findSuggestion,
+	openKeySuggestions,
+	typeFilter,
+} from 'components/QueryBuilderV2/QueryV2/QuerySearch/stories/__story_mockdata__/querySearch.play';
 import { screen, userEvent, within } from 'storybook/test';
 import { VIEWS } from 'container/InfraMonitoringK8sV2/constants';
 
@@ -41,6 +46,21 @@ export const PodDetailsEvents: StoryObj<PodsArgs> = {
 	args: { drawer: true, drawerTab: VIEWS.EVENTS },
 };
 
+/** The selected pod's details drawer, switched to its logs tab. */
+export const DetailsDrawerLogsTab: StoryObj<PodsArgs> = {
+	args: { drawer: true },
+	play: async () => {
+		const drawer = within(
+			await screen.findByRole('dialog', {}, { timeout: 10000 }),
+		);
+
+		await userEvent.click(
+			await drawer.findByText('Logs', {}, { timeout: 10000 }),
+		);
+		await drawer.findAllByText(/handled request in/, {}, { timeout: 10000 });
+	},
+};
+
 /**
  * Every tooltip the pod list carries, held open: Collapse Filters beside the
  * quick filters, Options above the table, the Pod Name, Status, Age and Restarts
@@ -86,3 +106,27 @@ export const TooltipsInOptionsPanel: StoryObj<PodsArgs> = {
 		await screen.findByText('Columns');
 	},
 };
+
+/**
+ * The pod list re-renders the filter when the viewport grows, and each render
+ * reconfigures the editor, which closes its suggestions. Shot at the height
+ * the page opened at.
+ */
+const heldViewport = { sbshot: { viewport: { height: 1200 } } };
+
+/** The pod filter focused: the Kubernetes keys pods can be narrowed by. */
+export const FilterKeySuggestions: StoryObj<PodsArgs> = {
+	parameters: heldViewport,
+	play: async ({ canvasElement }): Promise<void> => {
+		await openKeySuggestions(canvasElement, 'k8s.node.name');
+	},
+};
+
+/** The pod filter on a namespace: the namespaces the pods run in. */
+export const FilterValueSuggestions: StoryObj<PodsArgs> = {
+	parameters: heldViewport,
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'k8s.namespace.name = ');
+		await findSuggestion(canvasElement, 'kube-system');
+	},
+};

frontend/src/pages/IntegrationsDetailsPage/CloudIntegration/stories/__story_mockdata__/cloudIntegration.ts

@@ -295,11 +295,7 @@ const account = (
 	provider,
 	providerAccountId: ACCOUNTS[provider][index],
 	config: accountConfig(provider),
-	agentReport: {
-		timestampMillis: Date.now() - 45 * 1000,
-		data: null,
-		syncState: null,
-	},
+	agentReport: { timestampMillis: Date.now() - 45 * 1000, data: null },
 	createdAt: new Date(Date.now() - 21 * 24 * 60 * 60 * 1000).toISOString(),
 	updatedAt: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
 	removedAt: null,

frontend/src/pages/LLMObservability/AttributeMapping/stories/AttributeMapping.stories.tsx

@@ -69,3 +69,12 @@ export const GroupActionsMenu: Story = {
 		await screen.findByRole('menu');
 	},
 };
+
+/** The first mapping group's edit drawer, opened from its menu. */
+export const GroupFormDrawer: Story = {
+	play: async (context): Promise<void> => {
+		await GroupActionsMenu.play?.(context);
+		await userEvent.click(await screen.findByText('Edit'));
+		await screen.findByText('Edit group');
+	},
+};

frontend/src/pages/LLMObservability/ModelPricing/stories/ModelPricing.stories.tsx

@@ -54,3 +54,24 @@ export const ModelCostActionsMenu: Story = {
 		await screen.findByRole('menu');
 	},
 };
+
+/** The first pricing rule's drawer, opened from its row menu. */
+export const ModelCostDrawer: Story = {
+	play: async (context): Promise<void> => {
+		await ModelCostActionsMenu.play?.(context);
+		await userEvent.click(await screen.findByText('Edit'));
+		await screen.findByText('Edit model cost');
+	},
+};
+
+/** The drawer with its cache mode select open. */
+export const ModelCostDrawerCacheModeOpen: Story = {
+	play: async (context): Promise<void> => {
+		await ModelCostDrawer.play?.(context);
+
+		await userEvent.click(
+			await screen.findByRole('combobox', { name: 'Cache mode' }),
+		);
+		await screen.findByRole('listbox');
+	},
+};

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

@@ -25,6 +25,11 @@ import {
 	toggleControl,
 } from '@/storybook/controls/controls';
 import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
+import {
+	RESPONSE_STATES,
+	type ResponseState,
+	respondWith,
+} from '@/storybook/runtime/responseState';
 
 import {
 	logsSavedViewsResponse,
@@ -44,6 +49,8 @@ import {
 	logRowsResponse,
 	QUICK_FILTER_MAX,
 	logsQuickFiltersResponse,
+	RECENT_FILTER_MAX,
+	recentFiltersStorage,
 	RELATIVE_TIME,
 	timeRangeState,
 } from './__story_mockdata__/logs';
@@ -158,6 +165,20 @@ export const logsMocks = defineStoryMocks({
 			value: QUICK_FILTER_MAX,
 			max: QUICK_FILTER_MAX,
 		}),
+		filterValues: choiceControl<ResponseState>('Filter values', {
+			group: FILTERS,
+			description:
+				'How `/fields/values` answers once a key and an operator are typed in the filter, apart from the page-wide Data control.',
+			options: RESPONSE_STATES,
+			value: 'loaded',
+		}),
+		recentFilters: countControl('Recent filters', {
+			group: FILTERS,
+			description:
+				'Filters run before in this browser, which the filter offers above its key suggestions.',
+			value: 0,
+			max: RECENT_FILTER_MAX,
+		}),
 		savedViews: countControl('Saved views', {
 			group: FILTERS,
 			description: 'The views the view picker above the query builder lists.',
@@ -217,7 +238,7 @@ export const logsMocks = defineStoryMocks({
 
 			rest.get(
 				'http://localhost/api/v1/fields/values',
-				response.json((req) =>
+				respondWith(values.filterValues, (req) =>
 					logFieldValuesResponse(
 						req.url.searchParams.get('name') ?? '',
 						req.url.searchParams.get('searchText') ?? '',
@@ -264,8 +285,16 @@ export const logsMocks = defineStoryMocks({
 				}
 			: {},
 	}),
-	effect: ({ frequencyChart, filtersPanel, format, maxLines, fontSize }) => {
+	effect: ({
+		frequencyChart,
+		filtersPanel,
+		format,
+		maxLines,
+		fontSize,
+		recentFilters,
+	}) => {
 		setLocalStorage(LOCALSTORAGE.SHOW_FREQUENCY_CHART, String(frequencyChart));
+		setLocalStorage(...recentFiltersStorage(recentFilters));
 		setLocalStorage(LOCALSTORAGE.SHOW_LOGS_QUICK_FILTERS, String(filtersPanel));
 
 		// The preferences loader reads localStorage ahead of the URL, so this is

frontend/src/pages/LogsModulePage/stories/LogsModulePage.stories.tsx

@@ -1,4 +1,12 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
+import {
+	blurFilter,
+	openKeySuggestions,
+	showFilterErrors,
+	typeFilter,
+	typeFilterWithCaretBack,
+	findSuggestion,
+} from 'components/QueryBuilderV2/QueryV2/QuerySearch/stories/__story_mockdata__/querySearch.play';
 import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
@@ -209,3 +217,138 @@ export const Tooltips: Story = {
 		);
 	},
 };
+
+/** The filter focused before anything is typed: every key the logs carry. */
+export const FilterKeySuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openKeySuggestions(canvasElement, 'severity_text');
+	},
+};
+
+/** A partial key, with the keys that still match and the typed part marked. */
+export const FilterPartialKey: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'serv');
+		await findSuggestion(canvasElement, 'service.name');
+	},
+};
+
+/** A string key followed by a space: the operators a string compares with. */
+export const FilterOperatorSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name ');
+		await findSuggestion(canvasElement, 'CONTAINS');
+	},
+};
+
+/** A number key puts the range comparisons first. */
+export const FilterNumberOperatorSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'http.status_code ');
+		await findSuggestion(canvasElement, 'BETWEEN');
+	},
+};
+
+/** `NOT` after a key narrows the list to the operators it can negate. */
+export const FilterNegatedOperatorSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name NOT ');
+		await findSuggestion(canvasElement, 'IN');
+	},
+};
+
+/** A key and an operator: the values the key holds, fetched for it. */
+export const FilterValueSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name = ');
+		await findSuggestion(canvasElement, 'checkout');
+	},
+};
+
+/** Values still being fetched for the key. */
+export const FilterValuesLoading: Story = {
+	args: { filterValues: 'loading' },
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name = ');
+		await findSuggestion(canvasElement, 'Loading suggestions');
+	},
+};
+
+/** A key the backend holds no values for, such as the free-text body. */
+export const FilterNoValueSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'body = ');
+		await findSuggestion(canvasElement, 'No suggestions available');
+	},
+};
+
+/** The values request failed. */
+export const FilterValuesError: Story = {
+	args: { filterValues: 'error' },
+	// The values request deliberately fails.
+	parameters: { allowConsoleErrors: true },
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name = ');
+		await findSuggestion(canvasElement, 'Error loading suggestions');
+	},
+};
+
+/** Inside an `IN` list, after the first value: the rest of the values. */
+export const FilterInList: Story = {
+	// The editor logs a TypeError while the list is open, which it survives.
+	parameters: { allowConsoleErrors: true },
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilterWithCaretBack(
+			canvasElement,
+			"service.name IN ['auth', ]",
+			1,
+			'checkout',
+		);
+	},
+};
+
+/** A complete condition: the conjunctions that start the next one. */
+export const FilterConjunctionSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, "service.name = 'checkout' ");
+		await findSuggestion(canvasElement, 'OR');
+	},
+};
+
+/** Inside an opened group: keys, another group and `NOT`. */
+export const FilterNestedGroup: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilterWithCaretBack(canvasElement, '()', 1, 'NOT');
+	},
+};
+
+/** A long valid expression mixing operators, left for the next run. */
+export const FilterComplete: Story = {
+	// The editor logs a TypeError while the `IN` list is typed, which it survives.
+	parameters: { allowConsoleErrors: true },
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(
+			canvasElement,
+			"service.name IN ['checkout', 'payments'] AND severity_text = 'ERROR' AND http.status_code >= 500 AND body CONTAINS 'timeout'",
+		);
+		await blurFilter(canvasElement);
+	},
+};
+
+/** An incomplete expression after focus left: the marker and its errors. */
+export const FilterSyntaxError: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await showFilterErrors(canvasElement, 'service.name = ');
+	},
+};
+
+/** Filters run before, offered above the key suggestions. */
+export const FilterRecentSearches: Story = {
+	args: { recentFilters: 3 },
+	play: async ({ canvasElement }): Promise<void> => {
+		await openKeySuggestions(
+			canvasElement,
+			"k8s.namespace.name = 'observability'",
+		);
+	},
+};

frontend/src/pages/LogsModulePage/stories/__story_mockdata__/logs.ts

@@ -15,6 +15,9 @@ import {
 } from 'api/generated/services/sigNoz.schemas';
 import { defaultLogsSelectedColumns } from 'container/OptionsMenu/constants';
 import type { OptionsQuery } from 'container/OptionsMenu/types';
+import { STORAGE_VERSION } from 'lib/recentQueries/constants';
+import type { RecentQueriesStoreShape } from 'lib/recentQueries/types';
+import { makeId, storageKeyFor } from 'lib/recentQueries/utils';
 import type { Time } from 'container/TopNav/DateTimeSelectionV2/types';
 import { quickFiltersListResponse } from 'mocks-server/__mockdata__/customQuickFilters';
 import type { AppState } from 'store/reducers';
@@ -470,3 +473,34 @@ const DASHBOARD_NAMES = [
 
 export const dashboardsResponse = (): ListDashboardsForUserV2200 =>
 	dashboardsForUserResponse(DASHBOARD_NAMES);
+
+const RECENT_FILTERS = [
+	"service.name = 'checkout' AND severity_text = 'ERROR'",
+	"k8s.namespace.name = 'observability'",
+	"body CONTAINS 'timeout'",
+	'http.status_code >= 500',
+	"deployment.environment IN ['production', 'staging']",
+];
+
+/** The filter lists this many recent entries at most. */
+export const RECENT_FILTER_MAX = RECENT_FILTERS.length;
+
+/**
+ * The explorer's recent filters as the store keeps them in localStorage,
+ * newest first, five minutes apart. Dated off `new Date()`, which the story
+ * clock freezes, so the "5 minutes ago" labels hold still.
+ */
+export const recentFiltersStorage = (count: number): [string, string] => {
+	const store: RecentQueriesStoreShape = {
+		version: STORAGE_VERSION,
+		entries: RECENT_FILTERS.slice(0, count).map((expression, index) => ({
+			id: makeId('logs', '', expression),
+			signal: 'logs',
+			source: '',
+			filter: { expression },
+			lastUsedAt: new Date().getTime() - (index + 1) * 5 * 60_000,
+		})),
+	};
+
+	return [storageKeyFor('logs', ''), JSON.stringify(store)];
+};

frontend/src/pages/MetricsExplorer/stories/MetricsExplorerPage.stories.tsx

@@ -1,4 +1,9 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
+import {
+	findSuggestion,
+	openKeySuggestions,
+	typeFilter,
+} from 'components/QueryBuilderV2/QueryV2/QuerySearch/stories/__story_mockdata__/querySearch.play';
 import { screen, userEvent } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
@@ -114,3 +119,18 @@ export const MetricDetailsDashboardsMenu: Story = {
 		await screen.findByRole('menu');
 	},
 };
+
+/** The summary's metric search focused: the attributes metrics can be found by. */
+export const FilterKeySuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openKeySuggestions(canvasElement, 'k8s.cluster.name');
+	},
+};
+
+/** The metric search on an attribute and an operator: the values it holds. */
+export const FilterValueSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name = ');
+		await findSuggestion(canvasElement, 'checkout');
+	},
+};

frontend/src/pages/Settings/Ingestion/stories/Ingestion.stories.mocks.tsx

@@ -15,10 +15,14 @@ import {
 	toggleControl,
 } from '@/storybook/controls/controls';
 import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
+import type { MockResolver } from '@/storybook/msw/types';
 
 import {
+	CREATE_OUTCOMES,
+	type CreateOutcome,
 	EXPIRIES,
 	type Expiry,
+	ingestionKeyCreateError,
 	ingestionKeysResponse,
 	KEYS_PER_PAGE,
 	legacyIngestionResponse,
@@ -29,6 +33,11 @@ import {
 const KEYS = 'Ingestion · keys';
 const LIMITS = 'Ingestion · limits';
 
+const rejectCreate: MockResolver = (_req, res, ctx) =>
+	res(ctx.status(409), ctx.json(ingestionKeyCreateError()));
+
+const holdCreate: MockResolver = (_req, res, ctx) => res(ctx.delay('infinite'));
+
 export const ingestionMocks = defineStoryMocks({
 	controls: {
 		gateway: toggleControl('Gateway', {
@@ -50,6 +59,13 @@ export const ingestionMocks = defineStoryMocks({
 			options: EXPIRIES,
 			value: 'none',
 		}),
+		create: choiceControl<CreateOutcome>('Creating a key', {
+			group: KEYS,
+			description:
+				'What the create behind the new key form answers. `hangs` holds the submit button in its loading state.',
+			options: CREATE_OUTCOMES,
+			value: 'succeeds',
+		}),
 		limits: multiChoiceControl<LimitSignal>('Signals with a limit', {
 			group: LIMITS,
 			description:
@@ -85,10 +101,14 @@ export const ingestionMocks = defineStoryMocks({
 
 		rest.post(
 			'http://localhost/api/v2/gateway/ingestion_keys',
-			response.json(() => ({
-				status: 'success',
-				data: { id: 'ingestion-key-new', value: 'sk_new' },
-			})),
+			{
+				succeeds: response.json(() => ({
+					status: 'success',
+					data: { id: 'ingestion-key-new', value: 'sk_new' },
+				})),
+				fails: rejectCreate,
+				hangs: holdCreate,
+			}[values.create],
 		),
 
 		rest.patch(

frontend/src/pages/Settings/Ingestion/stories/Ingestion.stories.tsx

@@ -1,5 +1,6 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
-import { screen, userEvent, within } from 'storybook/test';
+import dayjs from 'dayjs';
+import { expect, screen, userEvent, waitFor, within } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
@@ -76,16 +77,149 @@ export const KeyLimits: Story = {
 	},
 };
 
+async function openCreateKey(
+	canvasElement: HTMLElement,
+): Promise<ReturnType<typeof within>> {
+	await userEvent.click(
+		await within(canvasElement).findByText(
+			'New Ingestion key',
+			undefined,
+			untilLoaded,
+		),
+	);
+	return within(
+		await screen.findByRole(
+			'dialog',
+			{ name: 'Create new ingestion key' },
+			untilLoaded,
+		),
+	);
+}
+
+async function addTag(
+	dialog: ReturnType<typeof within>,
+	tag: string,
+): Promise<void> {
+	await userEvent.click(await dialog.findByRole('button', { name: /New Tag/ }));
+	await userEvent.keyboard(`${tag}{Enter}`);
+}
+
+async function submitCreateKey(
+	dialog: ReturnType<typeof within>,
+): Promise<void> {
+	await userEvent.type(dialog.getByLabelText('Name'), 'otel-collectors');
+	await userEvent.click(dialog.getByLabelText('Expiration'));
+	await userEvent.click(
+		await screen.findByTitle(dayjs().add(1, 'day').format('YYYY-MM-DD')),
+	);
+	await userEvent.click(
+		dialog.getByRole('button', { name: 'Create new Ingestion key' }),
+	);
+}
+
 /** The form a new key is named and dated in. */
 export const CreateKey: Story = {
 	play: async ({ canvasElement }): Promise<void> => {
-		await userEvent.click(
-			await within(canvasElement).findByText(
-				'New Ingestion key',
-				undefined,
-				untilLoaded,
-			),
-		);
-		await screen.findByText('Create new ingestion key', undefined, untilLoaded);
+		await openCreateKey(canvasElement);
+	},
+};
+
+/** A tag typed on the new key and not confirmed yet. */
+export const CreateKeyAddingTag: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await userEvent.click(dialog.getByRole('button', { name: /New Tag/ }));
+		await userEvent.keyboard('team-payments');
+	},
+};
+
+/** The new key with its tags confirmed, each one removable. */
+export const CreateKeyTagsAdded: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		for (const tag of ['team-payments', 'env:production']) {
+			await addTag(dialog, tag);
+			await dialog.findByText(tag);
+		}
+	},
+};
+
+/**
+ * A tag typed again while the key already has it: Enter keeps the input open
+ * and adds nothing, with no message saying why.
+ */
+export const CreateKeyDuplicateTag: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await addTag(dialog, 'team-payments');
+		await addTag(dialog, 'team-payments');
+		await dialog.findByDisplayValue('team-payments');
+	},
+};
+
+/** A tag longer than its pill, cut short with an ellipsis. */
+export const CreateKeyLongTag: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		const tag =
+			'team-payments-platform-observability-production-us-east-1-canary-collectors';
+		await addTag(dialog, tag);
+		await dialog.findByText(tag);
+	},
+};
+
+/** A name with a space and no expiration, submitted: each field names its rule. */
+export const CreateKeyInvalid: Story = {
+	// The page logs the rejected validation through `console.error`.
+	parameters: { allowConsoleErrors: true },
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await userEvent.type(dialog.getByLabelText('Name'), 'otel collectors');
+		await userEvent.click(
+			dialog.getByRole('button', { name: 'Create new Ingestion key' }),
+		);
+		await dialog.findByText(/should only contain letters/);
+	},
+};
+
+/** The expiration calendar, where today and every day before it are disabled. */
+export const CreateKeyExpirationOpen: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await userEvent.click(dialog.getByLabelText('Expiration'));
+		await screen.findByTitle(dayjs().format('YYYY-MM-DD'));
+	},
+};
+
+/** The new key sent, with the create still in flight. */
+export const CreateKeySubmitting: Story = {
+	args: { create: 'hangs' },
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await submitCreateKey(dialog);
+		await waitFor(() =>
+			expect(
+				dialog.getByRole('button', { name: 'Create new Ingestion key' }),
+			).toBeDisabled(),
+		);
+	},
+};
+
+/**
+ * A create the gateway rejects: the notification names the conflict and the
+ * form keeps what was typed.
+ */
+export const CreateKeyFailed: Story = {
+	args: { create: 'fails' },
+	// The deliberate 409 is the state under test.
+	parameters: { allowConsoleErrors: true },
+	play: async ({ canvasElement }): Promise<void> => {
+		const dialog = await openCreateKey(canvasElement);
+		await submitCreateKey(dialog);
+		await screen.findByText(
+			'An ingestion key with this name already exists.',
+			undefined,
+			untilLoaded,
+		);
 	},
 };

frontend/src/pages/Settings/Ingestion/stories/__story_mockdata__/ingestion.ts

@@ -7,6 +7,7 @@ import type {
 	GatewaytypesIngestionKeyDTO,
 	GatewaytypesLimitDTO,
 	GetIngestionKeys200,
+	RenderErrorResponseDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type { IngestionInfo } from 'types/api/settings/ingestion';
 
@@ -21,6 +22,10 @@ export const EXPIRIES = ['none', 'soon', 'expired'] as const;
 
 export type Expiry = (typeof EXPIRIES)[number];
 
+export const CREATE_OUTCOMES = ['succeeds', 'fails', 'hangs'] as const;
+
+export type CreateOutcome = (typeof CREATE_OUTCOMES)[number];
+
 const KEY_NAMES = [
 	'production-us-east',
 	'production-eu-west',
@@ -117,6 +122,18 @@ export const ingestionKeysResponse = (
 	},
 });
 
+export const ingestionKeyCreateError = (): RenderErrorResponseDTO => ({
+	status: 'error',
+	error: {
+		code: 'already_exists',
+		type: 'already_exists',
+		message: 'An ingestion key with this name already exists.',
+		url: '',
+		errors: [],
+		suggestions: [],
+	},
+});
+
 /**
  * The pre-gateway endpoint, which answers with one record and no limits: the tab
  * falls back to it when the gateway feature is off.

frontend/src/pages/Settings/Roles/RoleEditor/stories/RoleEditor.stories.mocks.tsx

@@ -5,6 +5,7 @@
 
 import ROUTES from 'constants/routes';
 import { rest } from 'msw';
+import { userEvent, within } from 'storybook/test';
 import { RoleType } from 'types/roles';
 
 import { choiceControl } from '@/storybook/controls/controls';
@@ -84,3 +85,18 @@ export const roleEditorMocks = defineStoryMocks({
 	],
 	config: (values) => ({ route: routeFor(values.mode, values.editor) }),
 });
+
+/** Opens the Logs card and returns it. */
+export const openLogsCard = async (
+	canvasElement: HTMLElement,
+): Promise<HTMLElement> => {
+	const header = await within(canvasElement).findByRole(
+		'button',
+		{ name: /^Logs:/ },
+		{ timeout: 15_000 },
+	);
+
+	await userEvent.click(header);
+
+	return header.parentElement as HTMLElement;
+};

frontend/src/pages/Settings/Roles/RoleEditor/stories/RoleEditor.stories.tsx

@@ -1,10 +1,10 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
-import { userEvent, within } from 'storybook/test';
+import { screen, userEvent, within } from 'storybook/test';
 
 import { storyMocks } from '@/storybook/controls/defineStoryMocks';
 import type { PageStoryArgs } from '@/storybook/runtime/resolveStory';
 
-import { roleEditorMocks } from './RoleEditor.stories.mocks';
+import { openLogsCard, roleEditorMocks } from './RoleEditor.stories.mocks';
 
 import SettingsPage from '../../../Settings';
 
@@ -75,3 +75,27 @@ export const Tooltips: Story = {
 export const TooltipsInJsonEditor: Story = {
 	args: { tooltipsOpen: true, mode: 'edit', editor: 'json' },
 };
+
+/** The Logs card's first verb granted over everything instead of nothing. */
+export const PermissionEditorScope: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const card = await openLogsCard(canvasElement);
+		const [all] = await within(card).findAllByText('All');
+
+		await userEvent.click(all);
+	},
+};
+
+/** The selector wizard, opened from a Logs verb scoped to named objects. */
+export const TelemetrySelectorWizard: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		const card = await openLogsCard(canvasElement);
+		const [onlySelected] = await within(card).findAllByText('Only selected');
+
+		await userEvent.click(onlySelected);
+		await userEvent.click(
+			await within(card).findByRole('button', { name: 'Wizard' }),
+		);
+		await screen.findByRole('dialog', { name: 'Selector Wizard' });
+	},
+};

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

@@ -172,3 +172,31 @@ export const TraceOptionsMenu: Story = {
 		await screen.findByText('Preview fields');
 	},
 };
+
+/** The span panel moved from the right edge to the bottom through its dock toggle. */
+export const DockModeSwitched: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		// The dock options are icon-only and carry no accessible name.
+		const option = await within(canvasElement).findByTestId(
+			'dock-mode-docked',
+			undefined,
+			untilLoaded,
+		);
+
+		await userEvent.click(option.querySelector('button') ?? option);
+	},
+};
+
+/** The span's percentile badge expanded into the distribution it was ranked in. */
+export const SpanPercentileOpen: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await userEvent.click(
+			await within(canvasElement).findByRole(
+				'button',
+				{ name: /^p\d+/ },
+				untilLoaded,
+			),
+		);
+		await screen.findByText(/This span duration is/);
+	},
+};

frontend/src/pages/TracesModulePage/stories/TracesModulePage.stories.tsx

@@ -1,4 +1,10 @@
 import type { Meta, StoryObj } from '@storybook/react-vite';
+import {
+	findSuggestion,
+	openKeySuggestions,
+	showFilterErrors,
+	typeFilter,
+} from 'components/QueryBuilderV2/QueryV2/QuerySearch/stories/__story_mockdata__/querySearch.play';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
 import { expect, screen, userEvent, waitFor } from 'storybook/test';
 
@@ -142,3 +148,41 @@ export const QuickFiltersSettingsWithBanner: Story = {
 	args: { banner: 'trial-expiry' },
 	play: dirtyQuickFiltersSettings,
 };
+
+/** The filter focused before anything is typed: span and resource keys together. */
+export const FilterKeySuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await openKeySuggestions(canvasElement, 'status_code_string');
+	},
+};
+
+/** A context prefix: only the keys that live on the resource. */
+export const FilterResourceKeys: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'resource.');
+		await findSuggestion(canvasElement, 'resource.service.name');
+	},
+};
+
+/** A key and an operator: the services the spans came from. */
+export const FilterValueSuggestions: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'service.name = ');
+		await findSuggestion(canvasElement, 'checkout');
+	},
+};
+
+/** A boolean key offers its two values. */
+export const FilterBooleanValues: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await typeFilter(canvasElement, 'has_error = ');
+		await findSuggestion(canvasElement, 'false');
+	},
+};
+
+/** A dangling conjunction after focus left: the marker and its errors. */
+export const FilterSyntaxError: Story = {
+	play: async ({ canvasElement }): Promise<void> => {
+		await showFilterErrors(canvasElement, 'has_error = true AND');
+	},
+};

pkg/modules/cloudintegration/implcloudintegration/store.go

@@ -134,24 +134,6 @@ func (store *store) UpdateAccount(ctx context.Context, account *cloudintegration
 		BunDBCtx(ctx).
 		NewUpdate().
 		Model(account).
-		Column("config").
-		Column("updated_at").
-		WherePK().
-		Where("org_id = ?", account.OrgID).
-		Where("provider = ?", account.Provider).
-		Exec(ctx)
-
-	return err
-}
-
-func (store *store) UpdateAgentReport(ctx context.Context, account *cloudintegrationtypes.StorableCloudIntegration) error {
-	_, err := store.
-		store.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model(account).
-		Column("account_id").
-		Column("last_agent_report").
 		WherePK().
 		Where("org_id = ?", account.OrgID).
 		Where("provider = ?", account.Provider).

pkg/sqlmigration/049_add_route_policy.go

@@ -13,6 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"github.com/uptrace/bun/migrate"
@@ -49,11 +50,6 @@ type rule struct {
 	OrgID   string `bun:"org_id,type:text"`
 }
 
-type routePolicyRuleData struct {
-	PreferredChannels []string          `json:"preferredChannels"`
-	Labels            map[string]string `json:"labels"`
-}
-
 type addRoutePolicies struct {
 	sqlstore  sqlstore.SQLStore
 	sqlschema sqlschema.SQLSchema
@@ -191,20 +187,20 @@ func (migration *addRoutePolicies) migrateRulesToRoutePolicies(ctx context.Conte
 func (migration *addRoutePolicies) convertRulesToRoutes(rules []*rule, channelsByOrg map[string][]string) ([]*expressionRoute, error) {
 	var routes []*expressionRoute
 	for _, r := range rules {
-		var ruleData routePolicyRuleData
-		if err := json.Unmarshal([]byte(r.Data), &ruleData); err != nil {
+		var gettableRule ruletypes.GettableRule
+		if err := json.Unmarshal([]byte(r.Data), &gettableRule); err != nil {
 			return nil, errors.NewInternalf(errors.CodeInternal, "failed to unmarshal rule data for rule ID %s: %v", r.ID, err)
 		}
 
-		if len(ruleData.PreferredChannels) == 0 {
+		if len(gettableRule.PreferredChannels) == 0 {
 			channels, exists := channelsByOrg[r.OrgID]
 			if !exists || len(channels) == 0 {
 				continue
 			}
-			ruleData.PreferredChannels = channels
+			gettableRule.PreferredChannels = channels
 		}
 		severity := "critical"
-		if v, ok := ruleData.Labels["severity"]; ok {
+		if v, ok := gettableRule.Labels["severity"]; ok {
 			severity = v
 		}
 		expression := fmt.Sprintf(`%s == "%s" && %s == "%s"`, "threshold.name", severity, "ruleId", r.ID.String())
@@ -222,7 +218,7 @@ func (migration *addRoutePolicies) convertRulesToRoutes(rules []*rule, channelsB
 			},
 			Expression:     expression,
 			ExpressionKind: "rule",
-			Channels:       ruleData.PreferredChannels,
+			Channels:       gettableRule.PreferredChannels,
 			Name:           r.ID.StringValue(),
 			Enabled:        true,
 			OrgID:          r.OrgID,

pkg/tokenizer/opaquetokenizer/provider.go

@@ -364,26 +364,12 @@ func (provider *provider) gc(ctx context.Context, org *types.Organization) error
 }
 
 func (provider *provider) flushLastObservedAt(ctx context.Context, org *types.Organization) error {
-	tokens, err := provider.tokenStore.ListByOrgID(ctx, org.ID)
+	accessTokenToLastObservedAt, err := provider.listLastObservedAtDesc(ctx, org.ID)
 	if err != nil {
 		return err
 	}
 
-	observedTokens := make([]*authtypes.StorableToken, 0, len(tokens))
-	for _, token := range tokens {
-		cachedLastObservedAt, ok := provider.lastObservedAtCache.Get(lastObservedAtCacheKey(token.AccessToken, token.UserID))
-		if !ok {
-			continue
-		}
-
-		if err := token.UpdateLastObservedAt(cachedLastObservedAt); err != nil {
-			continue
-		}
-
-		observedTokens = append(observedTokens, token)
-	}
-
-	if err := provider.tokenStore.UpdateLastObservedAt(ctx, observedTokens); err != nil {
+	if err := provider.tokenStore.UpdateLastObservedAtByAccessToken(ctx, accessTokenToLastObservedAt); err != nil {
 		return err
 	}
 

pkg/tokenizer/tokenizerstore/sqltokenizerstore/store.go

@@ -232,16 +232,15 @@ func (store *store) ListByUserID(ctx context.Context, userID valuer.UUID) ([]*au
 	return tokens, nil
 }
 
-func (store *store) UpdateLastObservedAt(ctx context.Context, tokens []*authtypes.StorableToken) error {
-	if len(tokens) == 0 {
+func (store *store) UpdateLastObservedAtByAccessToken(ctx context.Context, accessTokenToLastObservedAt []map[string]any) error {
+	if len(accessTokenToLastObservedAt) == 0 {
 		return nil
 	}
 
 	values := store.
 		sqlstore.
 		BunDBCtx(ctx).
-		NewValues(&tokens).
-		Column("id", "last_observed_at", "updated_at")
+		NewValues(&accessTokenToLastObservedAt)
 
 	_, err := store.
 		sqlstore.
@@ -251,8 +250,8 @@ func (store *store) UpdateLastObservedAt(ctx context.Context, tokens []*authtype
 		Model((*authtypes.StorableToken)(nil)).
 		TableExpr("update_cte").
 		Set("last_observed_at = update_cte.last_observed_at").
-		Set("updated_at = update_cte.updated_at").
-		Where("auth_token.id = update_cte.id").
+		Where("auth_token.access_token = update_cte.access_token").
+		Where("auth_token.user_id = update_cte.user_id").
 		Exec(ctx)
 	if err != nil {
 		return err

pkg/types/alertmanagertypes/channel_email.go

@@ -1,62 +0,0 @@
-package alertmanagertypes
-
-import (
-	"maps"
-	"net/textproto"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
-)
-
-// ChannelEmailConfig carries no SMTP transport fields: the smarthost,
-// credentials and TLS settings come from the deployment's global config, so a
-// channel can only choose recipients and body.
-type ChannelEmailConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	To           string                       `json:"to" required:"true"`
-	HTML         valuer.UnsetOrNonEmptyString `json:"html"`
-	Headers      map[string]string            `json:"headers,omitempty"`
-}
-
-func (c ChannelEmailConfig) Validate() error {
-	if c.To == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.to is required for an email channel")
-	}
-
-	// A read reports header names as textproto canonicalizes them, turning
-	// "subject" into "Subject", so a name that is not already in that form is
-	// rejected rather than answered with one the caller never sent.
-	for _, header := range slices.Sorted(maps.Keys(c.Headers)) {
-		if canonical := textproto.CanonicalMIMEHeaderKey(header); canonical != header {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.headers name %q must be written as %q", header, canonical)
-		}
-	}
-
-	return nil
-}
-
-func (c ChannelEmailConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	return &Receiver{Receiver: &config.Receiver{
-		Name: displayName,
-		EmailConfigs: []*config.EmailConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultEmailConfig.VSendResolved)},
-			To:             c.To,
-			HTML:           c.HTML.StringValue(),
-			Headers:        c.Headers,
-		}},
-	}}, nil
-}
-
-func newChannelEmailConfigFromReceiver(_ string, receiver *Receiver) (ChannelSpec, error) {
-	email := receiver.EmailConfigs[0]
-	sendResolved := email.VSendResolved
-
-	return &ChannelEmailConfig{
-		SendResolved: &sendResolved,
-		To:           email.To,
-		HTML:         valuer.UnsetIfEmpty(email.HTML),
-		Headers:      email.Headers,
-	}, nil
-}

pkg/types/alertmanagertypes/channel_msteams.go

@@ -1,55 +0,0 @@
-package alertmanagertypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
-)
-
-type ChannelMSTeamsConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	WebhookURL   string                       `json:"webhookUrl" required:"true" format:"password"`
-	Title        valuer.UnsetOrNonEmptyString `json:"title"`
-	Text         valuer.UnsetOrNonEmptyString `json:"text"`
-}
-
-func (c ChannelMSTeamsConfig) Validate() error {
-	if c.WebhookURL == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.webhookUrl is required for an msteams channel")
-	}
-
-	return nil
-}
-
-func (c ChannelMSTeamsConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	webhookURL, err := parseSecretURL(c.WebhookURL)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Receiver{Receiver: &config.Receiver{
-		Name: displayName,
-		MSTeamsV2Configs: []*config.MSTeamsV2Config{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultMSTeamsV2Config.VSendResolved)},
-			WebhookURL:     webhookURL,
-			Title:          c.Title.StringValue(),
-			Text:           c.Text.StringValue(),
-		}},
-	}}, nil
-}
-
-func newChannelMSTeamsConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	msteams := receiver.MSTeamsV2Configs[0]
-	sendResolved := msteams.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, msteams.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelMSTeamsConfig{
-		SendResolved: &sendResolved,
-		WebhookURL:   formatSecretURL(msteams.WebhookURL),
-		Title:        valuer.UnsetIfEmpty(msteams.Title),
-		Text:         valuer.UnsetIfEmpty(msteams.Text),
-	}, nil
-}

pkg/types/alertmanagertypes/channel_opsgenie.go

@@ -1,71 +0,0 @@
-package alertmanagertypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
-)
-
-type ChannelOpsgenieConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	APIKey       string                       `json:"apiKey" required:"true" format:"password"`
-	APIURL       string                       `json:"apiUrl"`
-	Message      valuer.UnsetOrNonEmptyString `json:"message"`
-	Description  valuer.UnsetOrNonEmptyString `json:"description"`
-	Source       valuer.UnsetOrNonEmptyString `json:"source"`
-	Details      map[string]string            `json:"details,omitempty"`
-	Priority     string                       `json:"priority"`
-}
-
-func (c ChannelOpsgenieConfig) Validate() error {
-	if c.APIKey == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiKey is required for an opsgenie channel")
-	}
-
-	return nil
-}
-
-func (c ChannelOpsgenieConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	var apiURL *config.URL
-	if c.APIURL != "" {
-		parsed, err := parseUpstreamURL(c.APIURL)
-		if err != nil {
-			return nil, err
-		}
-		apiURL = parsed
-	}
-
-	return &Receiver{Receiver: &config.Receiver{
-		Name: displayName,
-		OpsGenieConfigs: []*config.OpsGenieConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultOpsGenieConfig.VSendResolved)},
-			APIKey:         config.Secret(c.APIKey),
-			APIURL:         apiURL,
-			Message:        c.Message.StringValue(),
-			Description:    c.Description.StringValue(),
-			Source:         c.Source.StringValue(),
-			Priority:       c.Priority,
-			Details:        c.Details,
-		}},
-	}}, nil
-}
-
-func newChannelOpsgenieConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	opsgenie := receiver.OpsGenieConfigs[0]
-	sendResolved := opsgenie.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, opsgenie.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelOpsgenieConfig{
-		SendResolved: &sendResolved,
-		APIKey:       string(opsgenie.APIKey),
-		APIURL:       formatUpstreamURL(opsgenie.APIURL),
-		Message:      valuer.UnsetIfEmpty(opsgenie.Message),
-		Description:  valuer.UnsetIfEmpty(opsgenie.Description),
-		Source:       valuer.UnsetIfEmpty(opsgenie.Source),
-		Priority:     opsgenie.Priority,
-		Details:      opsgenie.Details,
-	}, nil
-}

pkg/types/alertmanagertypes/channel_pagerduty.go

@@ -1,92 +0,0 @@
-package alertmanagertypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
-)
-
-type ChannelPagerdutyConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	RoutingKey   string                       `json:"routingKey" required:"true" format:"password"`
-	URL          string                       `json:"url"`
-	Source       valuer.UnsetOrNonEmptyString `json:"source"`
-	Client       valuer.UnsetOrNonEmptyString `json:"client"`
-	ClientURL    valuer.UnsetOrNonEmptyString `json:"clientUrl"`
-	Description  valuer.UnsetOrNonEmptyString `json:"description"`
-	Severity     string                       `json:"severity"`
-	Component    string                       `json:"component"`
-	Group        string                       `json:"group"`
-	Class        string                       `json:"class"`
-	Details      map[string]string            `json:"details,omitempty"`
-}
-
-func (c ChannelPagerdutyConfig) Validate() error {
-	if c.RoutingKey == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.routingKey is required for a pagerduty channel")
-	}
-
-	return nil
-}
-
-func (c ChannelPagerdutyConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	var eventsURL *config.URL
-	if c.URL != "" {
-		parsed, err := parseUpstreamURL(c.URL)
-		if err != nil {
-			return nil, err
-		}
-		eventsURL = parsed
-	}
-
-	return &Receiver{Receiver: &config.Receiver{
-		Name: displayName,
-		PagerdutyConfigs: []*config.PagerdutyConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultPagerdutyConfig.VSendResolved)},
-			RoutingKey:     config.Secret(c.RoutingKey),
-			URL:            eventsURL,
-			Source:         c.Source.StringValue(),
-			Client:         c.Client.StringValue(),
-			ClientURL:      c.ClientURL.StringValue(),
-			Description:    c.Description.StringValue(),
-			Severity:       c.Severity,
-			Component:      c.Component,
-			Group:          c.Group,
-			Class:          c.Class,
-			Details:        newUpstreamDetails(c.Details),
-		}},
-	}}, nil
-}
-
-func newChannelPagerdutyConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	pagerduty := receiver.PagerdutyConfigs[0]
-	sendResolved := pagerduty.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, pagerduty.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	var details map[string]string
-	if len(pagerduty.Details) > 0 {
-		extracted, err := extractStringDetails(name, pagerduty.Details)
-		if err != nil {
-			return nil, err
-		}
-		details = extracted
-	}
-
-	return &ChannelPagerdutyConfig{
-		SendResolved: &sendResolved,
-		RoutingKey:   string(pagerduty.RoutingKey),
-		URL:          formatUpstreamURL(pagerduty.URL),
-		Source:       valuer.UnsetIfEmpty(pagerduty.Source),
-		Client:       valuer.UnsetIfEmpty(pagerduty.Client),
-		ClientURL:    valuer.UnsetIfEmpty(pagerduty.ClientURL),
-		Description:  valuer.UnsetIfEmpty(pagerduty.Description),
-		Severity:     pagerduty.Severity,
-		Component:    pagerduty.Component,
-		Group:        pagerduty.Group,
-		Class:        pagerduty.Class,
-		Details:      details,
-	}, nil
-}

pkg/types/alertmanagertypes/channel_slack.go

@@ -1,182 +0,0 @@
-package alertmanagertypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
-)
-
-type ChannelSlackConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	APIURL       string                       `json:"apiUrl" required:"true" format:"password"`
-	Channel      string                       `json:"channel"`
-	Title        valuer.UnsetOrNonEmptyString `json:"title"`
-	Text         valuer.UnsetOrNonEmptyString `json:"text"`
-	Color        valuer.UnsetOrNonEmptyString `json:"color"`
-	TitleLink    valuer.UnsetOrNonEmptyString `json:"titleLink"`
-	Pretext      valuer.UnsetOrNonEmptyString `json:"pretext"`
-	Fallback     valuer.UnsetOrNonEmptyString `json:"fallback"`
-	Footer       valuer.UnsetOrNonEmptyString `json:"footer"`
-	Fields       []ChannelSlackField          `json:"fields,omitempty"`
-	Actions      []ChannelSlackAction         `json:"actions,omitempty"`
-}
-
-type ChannelSlackField struct {
-	Title string `json:"title" required:"true"`
-	Value string `json:"value" required:"true"`
-	Short *bool  `json:"short,omitempty"`
-}
-
-// ChannelSlackAction is a link button when URL is set, otherwise a message
-// button that needs Name. Upstream clears whichever side is not in use.
-type ChannelSlackAction struct {
-	Type    string                    `json:"type" required:"true"`
-	Text    string                    `json:"text" required:"true"`
-	URL     string                    `json:"url"`
-	Style   string                    `json:"style"`
-	Name    string                    `json:"name"`
-	Value   string                    `json:"value"`
-	Confirm *ChannelSlackConfirmation `json:"confirm,omitempty"`
-}
-
-type ChannelSlackConfirmation struct {
-	Text        string `json:"text" required:"true"`
-	Title       string `json:"title"`
-	OkText      string `json:"okText"`
-	DismissText string `json:"dismissText"`
-}
-
-func (c ChannelSlackConfig) Validate() error {
-	if c.APIURL == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiUrl is required for a slack channel")
-	}
-
-	for i, field := range c.Fields {
-		if field.Title == "" || field.Value == "" {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.fields[%d] requires title and value", i)
-		}
-	}
-
-	for i, action := range c.Actions {
-		if action.Type == "" || action.Text == "" {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d] requires type and text", i)
-		}
-		if action.URL == "" && action.Name == "" {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d] requires url or name", i)
-		}
-		if action.Confirm != nil && action.Confirm.Text == "" {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d].confirm requires text", i)
-		}
-	}
-
-	return nil
-}
-
-func (c ChannelSlackConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	apiURL, err := parseSecretURL(c.APIURL)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Receiver{Receiver: &config.Receiver{
-		Name: displayName,
-		SlackConfigs: []*config.SlackConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultSlackConfig.VSendResolved)},
-			APIURL:         apiURL,
-			Channel:        c.Channel,
-			Title:          c.Title.StringValue(),
-			Text:           c.Text.StringValue(),
-			Color:          c.Color.StringValue(),
-			TitleLink:      c.TitleLink.StringValue(),
-			Pretext:        c.Pretext.StringValue(),
-			Fallback:       c.Fallback.StringValue(),
-			Footer:         c.Footer.StringValue(),
-			Fields:         newUpstreamSlackFields(c.Fields),
-			Actions:        newUpstreamSlackActions(c.Actions),
-		}},
-	}}, nil
-}
-
-func newChannelSlackConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	slack := receiver.SlackConfigs[0]
-	sendResolved := slack.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, slack.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelSlackConfig{
-		SendResolved: &sendResolved,
-		APIURL:       formatSecretURL(slack.APIURL),
-		Channel:      slack.Channel,
-		Title:        valuer.UnsetIfEmpty(slack.Title),
-		Text:         valuer.UnsetIfEmpty(slack.Text),
-		Color:        valuer.UnsetIfEmpty(slack.Color),
-		TitleLink:    valuer.UnsetIfEmpty(slack.TitleLink),
-		Pretext:      valuer.UnsetIfEmpty(slack.Pretext),
-		Fallback:     valuer.UnsetIfEmpty(slack.Fallback),
-		Footer:       valuer.UnsetIfEmpty(slack.Footer),
-		Fields:       newChannelSlackFields(slack.Fields),
-		Actions:      newChannelSlackActions(slack.Actions),
-	}, nil
-}
-
-func newUpstreamSlackFields(fields []ChannelSlackField) []*config.SlackField {
-	if len(fields) == 0 {
-		return nil
-	}
-
-	upstream := make([]*config.SlackField, 0, len(fields))
-	for _, field := range fields {
-		upstream = append(upstream, &config.SlackField{Title: field.Title, Value: field.Value, Short: field.Short})
-	}
-
-	return upstream
-}
-
-func newChannelSlackFields(upstream []*config.SlackField) []ChannelSlackField {
-	if len(upstream) == 0 {
-		return nil
-	}
-
-	fields := make([]ChannelSlackField, 0, len(upstream))
-	for _, field := range upstream {
-		fields = append(fields, ChannelSlackField{Title: field.Title, Value: field.Value, Short: field.Short})
-	}
-
-	return fields
-}
-
-func newUpstreamSlackActions(actions []ChannelSlackAction) []*config.SlackAction {
-	if len(actions) == 0 {
-		return nil
-	}
-
-	upstream := make([]*config.SlackAction, 0, len(actions))
-	for _, action := range actions {
-		upstreamAction := &config.SlackAction{Type: action.Type, Text: action.Text, URL: action.URL, Style: action.Style, Name: action.Name, Value: action.Value}
-		if action.Confirm != nil {
-			upstreamAction.ConfirmField = &config.SlackConfirmationField{Text: action.Confirm.Text, Title: action.Confirm.Title, OkText: action.Confirm.OkText, DismissText: action.Confirm.DismissText}
-		}
-		upstream = append(upstream, upstreamAction)
-	}
-
-	return upstream
-}
-
-func newChannelSlackActions(upstream []*config.SlackAction) []ChannelSlackAction {
-	if len(upstream) == 0 {
-		return nil
-	}
-
-	actions := make([]ChannelSlackAction, 0, len(upstream))
-	for _, upstreamAction := range upstream {
-		action := ChannelSlackAction{Type: upstreamAction.Type, Text: upstreamAction.Text, URL: upstreamAction.URL, Style: upstreamAction.Style, Name: upstreamAction.Name, Value: upstreamAction.Value}
-		if upstreamAction.ConfirmField != nil {
-			action.Confirm = &ChannelSlackConfirmation{Text: upstreamAction.ConfirmField.Text, Title: upstreamAction.ConfirmField.Title, OkText: upstreamAction.ConfirmField.OkText, DismissText: upstreamAction.ConfirmField.DismissText}
-		}
-		actions = append(actions, action)
-	}
-
-	return actions
-}

pkg/types/alertmanagertypes/channel_webhook.go

@@ -1,98 +0,0 @@
-package alertmanagertypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/prometheus/alertmanager/config"
-	commoncfg "github.com/prometheus/common/config"
-)
-
-// ChannelWebhookConfig splits apart the two authentication modes the legacy API
-// overloaded onto one password field, where an empty username meant the password
-// was really a bearer token. Username or Password may be set without the other,
-// as upstream allows, but not together with BearerToken.
-type ChannelWebhookConfig struct {
-	SendResolved *bool  `json:"sendResolved,omitempty"`
-	URL          string `json:"url" required:"true" format:"password"`
-	Username     string `json:"username"`
-	Password     string `json:"password" format:"password"`
-	BearerToken  string `json:"bearerToken" format:"password"`
-}
-
-func (c ChannelWebhookConfig) Validate() error {
-	if c.URL == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.url is required for a webhook channel")
-	}
-
-	usesBasicAuth := c.Username != "" || c.Password != ""
-
-	if usesBasicAuth && c.BearerToken != "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.bearerToken cannot be combined with config.spec.username or config.spec.password")
-	}
-
-	return nil
-}
-
-func (c ChannelWebhookConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	webhook := &config.WebhookConfig{
-		NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultWebhookConfig.VSendResolved)},
-		URL:            config.SecretTemplateURL(c.URL),
-	}
-
-	// Seeded from upstream's default rather than a zero value: FollowRedirects
-	// and EnableHTTP2 marshal unconditionally, so a zero value would persist
-	// them as false and read back as a config ChannelWebhookConfig cannot represent.
-	switch {
-	case c.Username != "" || c.Password != "":
-		httpConfig := commoncfg.DefaultHTTPClientConfig
-		httpConfig.BasicAuth = &commoncfg.BasicAuth{
-			Username: c.Username,
-			Password: commoncfg.Secret(c.Password),
-		}
-		webhook.HTTPConfig = &httpConfig
-	case c.BearerToken != "":
-		httpConfig := commoncfg.DefaultHTTPClientConfig
-		httpConfig.Authorization = &commoncfg.Authorization{
-			Type:        bearerAuthorizationType,
-			Credentials: commoncfg.Secret(c.BearerToken),
-		}
-		webhook.HTTPConfig = &httpConfig
-	}
-
-	return &Receiver{Receiver: &config.Receiver{
-		Name:           displayName,
-		WebhookConfigs: []*config.WebhookConfig{webhook},
-	}}, nil
-}
-
-func newChannelWebhookConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	upstream := receiver.WebhookConfigs[0]
-	sendResolved := upstream.VSendResolved
-	if err := rejectUnsupportedHTTPConfig(name, upstream.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	if err := rejectHTTPBasicAuthBeyondPassword(name, upstream.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	if err := rejectHTTPAuthorizationBeyondBearer(name, upstream.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	webhook := &ChannelWebhookConfig{
-		SendResolved: &sendResolved,
-		URL:          string(upstream.URL),
-	}
-
-	if upstream.HTTPConfig != nil {
-		if basicAuth := upstream.HTTPConfig.BasicAuth; basicAuth != nil {
-			webhook.Username = basicAuth.Username
-			webhook.Password = string(basicAuth.Password)
-		}
-		if authorization := upstream.HTTPConfig.Authorization; authorization != nil {
-			webhook.BearerToken = string(authorization.Credentials)
-		}
-	}
-
-	return webhook, nil
-}

pkg/types/alertmanagertypes/channelconfig.go

@@ -3,6 +3,8 @@ package alertmanagertypes
 import (
 	"bytes"
 	"encoding/json"
+	"maps"
+	"net/textproto"
 	"net/url"
 	"reflect"
 	"slices"
@@ -12,6 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
+	"github.com/prometheus/common/model"
 	"github.com/swaggest/jsonschema-go"
 )
 
@@ -202,6 +205,808 @@ type ChannelSpec interface {
 	toUndefaultedReceiver(displayName string) (*Receiver, error)
 }
 
+type ChannelSlackConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	APIURL       string                       `json:"apiUrl" required:"true" format:"password"`
+	Channel      string                       `json:"channel"`
+	Title        valuer.UnsetOrNonEmptyString `json:"title"`
+	Text         valuer.UnsetOrNonEmptyString `json:"text"`
+	Color        valuer.UnsetOrNonEmptyString `json:"color"`
+	TitleLink    valuer.UnsetOrNonEmptyString `json:"titleLink"`
+	Pretext      valuer.UnsetOrNonEmptyString `json:"pretext"`
+	Fallback     valuer.UnsetOrNonEmptyString `json:"fallback"`
+	Footer       valuer.UnsetOrNonEmptyString `json:"footer"`
+	Fields       []ChannelSlackField          `json:"fields,omitempty"`
+	Actions      []ChannelSlackAction         `json:"actions,omitempty"`
+}
+
+type ChannelSlackField struct {
+	Title string `json:"title" required:"true"`
+	Value string `json:"value" required:"true"`
+	Short *bool  `json:"short,omitempty"`
+}
+
+// ChannelSlackAction is a link button when URL is set, otherwise a message
+// button that needs Name. Upstream clears whichever side is not in use.
+type ChannelSlackAction struct {
+	Type    string                    `json:"type" required:"true"`
+	Text    string                    `json:"text" required:"true"`
+	URL     string                    `json:"url"`
+	Style   string                    `json:"style"`
+	Name    string                    `json:"name"`
+	Value   string                    `json:"value"`
+	Confirm *ChannelSlackConfirmation `json:"confirm,omitempty"`
+}
+
+type ChannelSlackConfirmation struct {
+	Text        string `json:"text" required:"true"`
+	Title       string `json:"title"`
+	OkText      string `json:"okText"`
+	DismissText string `json:"dismissText"`
+}
+
+func (c ChannelSlackConfig) Validate() error {
+	if c.APIURL == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiUrl is required for a slack channel")
+	}
+
+	for i, field := range c.Fields {
+		if field.Title == "" || field.Value == "" {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.fields[%d] requires title and value", i)
+		}
+	}
+
+	for i, action := range c.Actions {
+		if action.Type == "" || action.Text == "" {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d] requires type and text", i)
+		}
+		if action.URL == "" && action.Name == "" {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d] requires url or name", i)
+		}
+		if action.Confirm != nil && action.Confirm.Text == "" {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.actions[%d].confirm requires text", i)
+		}
+	}
+
+	return nil
+}
+
+func (c ChannelSlackConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	apiURL, err := parseSecretURL(c.APIURL)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Receiver{Receiver: &config.Receiver{
+		Name: displayName,
+		SlackConfigs: []*config.SlackConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultSlackConfig.VSendResolved)},
+			APIURL:         apiURL,
+			Channel:        c.Channel,
+			Title:          c.Title.StringValue(),
+			Text:           c.Text.StringValue(),
+			Color:          c.Color.StringValue(),
+			TitleLink:      c.TitleLink.StringValue(),
+			Pretext:        c.Pretext.StringValue(),
+			Fallback:       c.Fallback.StringValue(),
+			Footer:         c.Footer.StringValue(),
+			Fields:         newUpstreamSlackFields(c.Fields),
+			Actions:        newUpstreamSlackActions(c.Actions),
+		}},
+	}}, nil
+}
+
+func newChannelSlackConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	slack := receiver.SlackConfigs[0]
+	sendResolved := slack.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, slack.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelSlackConfig{
+		SendResolved: &sendResolved,
+		APIURL:       formatSecretURL(slack.APIURL),
+		Channel:      slack.Channel,
+		Title:        valuer.UnsetIfEmpty(slack.Title),
+		Text:         valuer.UnsetIfEmpty(slack.Text),
+		Color:        valuer.UnsetIfEmpty(slack.Color),
+		TitleLink:    valuer.UnsetIfEmpty(slack.TitleLink),
+		Pretext:      valuer.UnsetIfEmpty(slack.Pretext),
+		Fallback:     valuer.UnsetIfEmpty(slack.Fallback),
+		Footer:       valuer.UnsetIfEmpty(slack.Footer),
+		Fields:       newChannelSlackFields(slack.Fields),
+		Actions:      newChannelSlackActions(slack.Actions),
+	}, nil
+}
+
+func newUpstreamSlackFields(fields []ChannelSlackField) []*config.SlackField {
+	if len(fields) == 0 {
+		return nil
+	}
+
+	upstream := make([]*config.SlackField, 0, len(fields))
+	for _, field := range fields {
+		upstream = append(upstream, &config.SlackField{Title: field.Title, Value: field.Value, Short: field.Short})
+	}
+
+	return upstream
+}
+
+func newChannelSlackFields(upstream []*config.SlackField) []ChannelSlackField {
+	if len(upstream) == 0 {
+		return nil
+	}
+
+	fields := make([]ChannelSlackField, 0, len(upstream))
+	for _, field := range upstream {
+		fields = append(fields, ChannelSlackField{Title: field.Title, Value: field.Value, Short: field.Short})
+	}
+
+	return fields
+}
+
+func newUpstreamSlackActions(actions []ChannelSlackAction) []*config.SlackAction {
+	if len(actions) == 0 {
+		return nil
+	}
+
+	upstream := make([]*config.SlackAction, 0, len(actions))
+	for _, action := range actions {
+		upstreamAction := &config.SlackAction{Type: action.Type, Text: action.Text, URL: action.URL, Style: action.Style, Name: action.Name, Value: action.Value}
+		if action.Confirm != nil {
+			upstreamAction.ConfirmField = &config.SlackConfirmationField{Text: action.Confirm.Text, Title: action.Confirm.Title, OkText: action.Confirm.OkText, DismissText: action.Confirm.DismissText}
+		}
+		upstream = append(upstream, upstreamAction)
+	}
+
+	return upstream
+}
+
+func newChannelSlackActions(upstream []*config.SlackAction) []ChannelSlackAction {
+	if len(upstream) == 0 {
+		return nil
+	}
+
+	actions := make([]ChannelSlackAction, 0, len(upstream))
+	for _, upstreamAction := range upstream {
+		action := ChannelSlackAction{Type: upstreamAction.Type, Text: upstreamAction.Text, URL: upstreamAction.URL, Style: upstreamAction.Style, Name: upstreamAction.Name, Value: upstreamAction.Value}
+		if upstreamAction.ConfirmField != nil {
+			action.Confirm = &ChannelSlackConfirmation{Text: upstreamAction.ConfirmField.Text, Title: upstreamAction.ConfirmField.Title, OkText: upstreamAction.ConfirmField.OkText, DismissText: upstreamAction.ConfirmField.DismissText}
+		}
+		actions = append(actions, action)
+	}
+
+	return actions
+}
+
+// ChannelEmailConfig carries no SMTP transport fields: the smarthost,
+// credentials and TLS settings come from the deployment's global config, so a
+// channel can only choose recipients and body.
+type ChannelEmailConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	To           string                       `json:"to" required:"true"`
+	HTML         valuer.UnsetOrNonEmptyString `json:"html"`
+	Headers      map[string]string            `json:"headers,omitempty"`
+}
+
+func (c ChannelEmailConfig) Validate() error {
+	if c.To == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.to is required for an email channel")
+	}
+
+	// A read reports header names as textproto canonicalizes them, turning
+	// "subject" into "Subject", so a name that is not already in that form is
+	// rejected rather than answered with one the caller never sent.
+	for _, header := range slices.Sorted(maps.Keys(c.Headers)) {
+		if canonical := textproto.CanonicalMIMEHeaderKey(header); canonical != header {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.headers name %q must be written as %q", header, canonical)
+		}
+	}
+
+	return nil
+}
+
+func (c ChannelEmailConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	return &Receiver{Receiver: &config.Receiver{
+		Name: displayName,
+		EmailConfigs: []*config.EmailConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultEmailConfig.VSendResolved)},
+			To:             c.To,
+			HTML:           c.HTML.StringValue(),
+			Headers:        c.Headers,
+		}},
+	}}, nil
+}
+
+func newChannelEmailConfigFromReceiver(_ string, receiver *Receiver) (ChannelSpec, error) {
+	email := receiver.EmailConfigs[0]
+	sendResolved := email.VSendResolved
+
+	return &ChannelEmailConfig{
+		SendResolved: &sendResolved,
+		To:           email.To,
+		HTML:         valuer.UnsetIfEmpty(email.HTML),
+		Headers:      email.Headers,
+	}, nil
+}
+
+// ChannelWebhookConfig splits apart the two authentication modes the legacy API
+// overloaded onto one password field, where an empty username meant the password
+// was really a bearer token. Username or Password may be set without the other,
+// as upstream allows, but not together with BearerToken.
+type ChannelWebhookConfig struct {
+	SendResolved *bool  `json:"sendResolved,omitempty"`
+	URL          string `json:"url" required:"true" format:"password"`
+	Username     string `json:"username"`
+	Password     string `json:"password" format:"password"`
+	BearerToken  string `json:"bearerToken" format:"password"`
+}
+
+func (c ChannelWebhookConfig) Validate() error {
+	if c.URL == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.url is required for a webhook channel")
+	}
+
+	usesBasicAuth := c.Username != "" || c.Password != ""
+
+	if usesBasicAuth && c.BearerToken != "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.bearerToken cannot be combined with config.spec.username or config.spec.password")
+	}
+
+	return nil
+}
+
+func (c ChannelWebhookConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	webhook := &config.WebhookConfig{
+		NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultWebhookConfig.VSendResolved)},
+		URL:            config.SecretTemplateURL(c.URL),
+	}
+
+	// Seeded from upstream's default rather than a zero value: FollowRedirects
+	// and EnableHTTP2 marshal unconditionally, so a zero value would persist
+	// them as false and read back as a config ChannelWebhookConfig cannot represent.
+	switch {
+	case c.Username != "" || c.Password != "":
+		httpConfig := commoncfg.DefaultHTTPClientConfig
+		httpConfig.BasicAuth = &commoncfg.BasicAuth{
+			Username: c.Username,
+			Password: commoncfg.Secret(c.Password),
+		}
+		webhook.HTTPConfig = &httpConfig
+	case c.BearerToken != "":
+		httpConfig := commoncfg.DefaultHTTPClientConfig
+		httpConfig.Authorization = &commoncfg.Authorization{
+			Type:        bearerAuthorizationType,
+			Credentials: commoncfg.Secret(c.BearerToken),
+		}
+		webhook.HTTPConfig = &httpConfig
+	}
+
+	return &Receiver{Receiver: &config.Receiver{
+		Name:           displayName,
+		WebhookConfigs: []*config.WebhookConfig{webhook},
+	}}, nil
+}
+
+func newChannelWebhookConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	upstream := receiver.WebhookConfigs[0]
+	sendResolved := upstream.VSendResolved
+	if err := rejectUnsupportedHTTPConfig(name, upstream.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	if err := rejectHTTPBasicAuthBeyondPassword(name, upstream.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	if err := rejectHTTPAuthorizationBeyondBearer(name, upstream.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	webhook := &ChannelWebhookConfig{
+		SendResolved: &sendResolved,
+		URL:          string(upstream.URL),
+	}
+
+	if upstream.HTTPConfig != nil {
+		if basicAuth := upstream.HTTPConfig.BasicAuth; basicAuth != nil {
+			webhook.Username = basicAuth.Username
+			webhook.Password = string(basicAuth.Password)
+		}
+		if authorization := upstream.HTTPConfig.Authorization; authorization != nil {
+			webhook.BearerToken = string(authorization.Credentials)
+		}
+	}
+
+	return webhook, nil
+}
+
+type ChannelPagerdutyConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	RoutingKey   string                       `json:"routingKey" required:"true" format:"password"`
+	URL          string                       `json:"url"`
+	Source       valuer.UnsetOrNonEmptyString `json:"source"`
+	Client       valuer.UnsetOrNonEmptyString `json:"client"`
+	ClientURL    valuer.UnsetOrNonEmptyString `json:"clientUrl"`
+	Description  valuer.UnsetOrNonEmptyString `json:"description"`
+	Severity     string                       `json:"severity"`
+	Component    string                       `json:"component"`
+	Group        string                       `json:"group"`
+	Class        string                       `json:"class"`
+	Details      map[string]string            `json:"details,omitempty"`
+}
+
+func (c ChannelPagerdutyConfig) Validate() error {
+	if c.RoutingKey == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.routingKey is required for a pagerduty channel")
+	}
+
+	return nil
+}
+
+func (c ChannelPagerdutyConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	var eventsURL *config.URL
+	if c.URL != "" {
+		parsed, err := parseUpstreamURL(c.URL)
+		if err != nil {
+			return nil, err
+		}
+		eventsURL = parsed
+	}
+
+	return &Receiver{Receiver: &config.Receiver{
+		Name: displayName,
+		PagerdutyConfigs: []*config.PagerdutyConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultPagerdutyConfig.VSendResolved)},
+			RoutingKey:     config.Secret(c.RoutingKey),
+			URL:            eventsURL,
+			Source:         c.Source.StringValue(),
+			Client:         c.Client.StringValue(),
+			ClientURL:      c.ClientURL.StringValue(),
+			Description:    c.Description.StringValue(),
+			Severity:       c.Severity,
+			Component:      c.Component,
+			Group:          c.Group,
+			Class:          c.Class,
+			Details:        newUpstreamDetails(c.Details),
+		}},
+	}}, nil
+}
+
+func newChannelPagerdutyConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	pagerduty := receiver.PagerdutyConfigs[0]
+	sendResolved := pagerduty.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, pagerduty.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	var details map[string]string
+	if len(pagerduty.Details) > 0 {
+		extracted, err := extractStringDetails(name, pagerduty.Details)
+		if err != nil {
+			return nil, err
+		}
+		details = extracted
+	}
+
+	return &ChannelPagerdutyConfig{
+		SendResolved: &sendResolved,
+		RoutingKey:   string(pagerduty.RoutingKey),
+		URL:          formatUpstreamURL(pagerduty.URL),
+		Source:       valuer.UnsetIfEmpty(pagerduty.Source),
+		Client:       valuer.UnsetIfEmpty(pagerduty.Client),
+		ClientURL:    valuer.UnsetIfEmpty(pagerduty.ClientURL),
+		Description:  valuer.UnsetIfEmpty(pagerduty.Description),
+		Severity:     pagerduty.Severity,
+		Component:    pagerduty.Component,
+		Group:        pagerduty.Group,
+		Class:        pagerduty.Class,
+		Details:      details,
+	}, nil
+}
+
+type ChannelOpsgenieConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	APIKey       string                       `json:"apiKey" required:"true" format:"password"`
+	APIURL       string                       `json:"apiUrl"`
+	Message      valuer.UnsetOrNonEmptyString `json:"message"`
+	Description  valuer.UnsetOrNonEmptyString `json:"description"`
+	Source       valuer.UnsetOrNonEmptyString `json:"source"`
+	Details      map[string]string            `json:"details,omitempty"`
+	Priority     string                       `json:"priority"`
+}
+
+func (c ChannelOpsgenieConfig) Validate() error {
+	if c.APIKey == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiKey is required for an opsgenie channel")
+	}
+
+	return nil
+}
+
+func (c ChannelOpsgenieConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	var apiURL *config.URL
+	if c.APIURL != "" {
+		parsed, err := parseUpstreamURL(c.APIURL)
+		if err != nil {
+			return nil, err
+		}
+		apiURL = parsed
+	}
+
+	return &Receiver{Receiver: &config.Receiver{
+		Name: displayName,
+		OpsGenieConfigs: []*config.OpsGenieConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultOpsGenieConfig.VSendResolved)},
+			APIKey:         config.Secret(c.APIKey),
+			APIURL:         apiURL,
+			Message:        c.Message.StringValue(),
+			Description:    c.Description.StringValue(),
+			Source:         c.Source.StringValue(),
+			Priority:       c.Priority,
+			Details:        c.Details,
+		}},
+	}}, nil
+}
+
+func newChannelOpsgenieConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	opsgenie := receiver.OpsGenieConfigs[0]
+	sendResolved := opsgenie.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, opsgenie.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelOpsgenieConfig{
+		SendResolved: &sendResolved,
+		APIKey:       string(opsgenie.APIKey),
+		APIURL:       formatUpstreamURL(opsgenie.APIURL),
+		Message:      valuer.UnsetIfEmpty(opsgenie.Message),
+		Description:  valuer.UnsetIfEmpty(opsgenie.Description),
+		Source:       valuer.UnsetIfEmpty(opsgenie.Source),
+		Priority:     opsgenie.Priority,
+		Details:      opsgenie.Details,
+	}, nil
+}
+
+type ChannelMSTeamsConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	WebhookURL   string                       `json:"webhookUrl" required:"true" format:"password"`
+	Title        valuer.UnsetOrNonEmptyString `json:"title"`
+	Text         valuer.UnsetOrNonEmptyString `json:"text"`
+}
+
+func (c ChannelMSTeamsConfig) Validate() error {
+	if c.WebhookURL == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.webhookUrl is required for an msteams channel")
+	}
+
+	return nil
+}
+
+func (c ChannelMSTeamsConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	webhookURL, err := parseSecretURL(c.WebhookURL)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Receiver{Receiver: &config.Receiver{
+		Name: displayName,
+		MSTeamsV2Configs: []*config.MSTeamsV2Config{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, config.DefaultMSTeamsV2Config.VSendResolved)},
+			WebhookURL:     webhookURL,
+			Title:          c.Title.StringValue(),
+			Text:           c.Text.StringValue(),
+		}},
+	}}, nil
+}
+
+func newChannelMSTeamsConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	msteams := receiver.MSTeamsV2Configs[0]
+	sendResolved := msteams.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, msteams.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelMSTeamsConfig{
+		SendResolved: &sendResolved,
+		WebhookURL:   formatSecretURL(msteams.WebhookURL),
+		Title:        valuer.UnsetIfEmpty(msteams.Title),
+		Text:         valuer.UnsetIfEmpty(msteams.Text),
+	}, nil
+}
+
+type ChannelGoogleChatConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	WebhookURL   string                       `json:"webhookUrl" required:"true" format:"password"`
+	Title        valuer.UnsetOrNonEmptyString `json:"title"`
+	Text         valuer.UnsetOrNonEmptyString `json:"text"`
+}
+
+func (c ChannelGoogleChatConfig) Validate() error {
+	if c.WebhookURL == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.webhookUrl is required for a googlechat channel")
+	}
+
+	return nil
+}
+
+func (c ChannelGoogleChatConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	webhookURL, err := parseSecretURL(c.WebhookURL)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Receiver{
+		Receiver: &config.Receiver{Name: displayName},
+		GoogleChatConfigs: []*GoogleChatReceiverConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultGoogleChatReceiverConfig.VSendResolved)},
+			WebhookURL:     webhookURL,
+			Title:          c.Title.StringValue(),
+			Text:           c.Text.StringValue(),
+		}},
+	}, nil
+}
+
+func newChannelGoogleChatConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	googlechat := receiver.GoogleChatConfigs[0]
+	sendResolved := googlechat.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, googlechat.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelGoogleChatConfig{
+		SendResolved: &sendResolved,
+		WebhookURL:   formatSecretURL(googlechat.WebhookURL),
+		Title:        valuer.UnsetIfEmpty(googlechat.Title),
+		Text:         valuer.UnsetIfEmpty(googlechat.Text),
+	}, nil
+}
+
+type ChannelJiraConfig struct {
+	SendResolved *bool `json:"sendResolved,omitempty"`
+	// Site is the Jira Cloud base URL, https://<site>.atlassian.net. Only Jira
+	// Cloud is supported; the REST base is derived from it.
+	Site              string                       `json:"site" required:"true"`
+	Project           string                       `json:"project" required:"true"`
+	IssueType         string                       `json:"issueType" required:"true"`
+	Summary           valuer.UnsetOrNonEmptyString `json:"summary"`
+	Description       valuer.UnsetOrNonEmptyString `json:"description"`
+	Priority          string                       `json:"priority"`
+	Labels            []string                     `json:"labels,omitempty"`
+	ResolveTransition string                       `json:"resolveTransition"`
+	ReopenTransition  string                       `json:"reopenTransition"`
+	ReopenDuration    valuer.UnsetOrNonEmptyString `json:"reopenDuration"`
+	WontFixResolution string                       `json:"wontFixResolution"`
+	CustomFields      map[string]any               `json:"customFields,omitempty"`
+
+	Email    string `json:"email" required:"true"`
+	APIToken string `json:"apiToken" required:"true" format:"password"`
+}
+
+func (c ChannelJiraConfig) Validate() error {
+	for _, required := range []struct {
+		value string
+		field string
+	}{
+		{c.Site, "site"},
+		{c.Project, "project"},
+		{c.IssueType, "issueType"},
+		{c.Email, "email"},
+		{c.APIToken, "apiToken"},
+	} {
+		if required.value == "" {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.%s is required for a jira channel", required.field)
+		}
+	}
+
+	if !c.ReopenDuration.IsZero() {
+		reopenDuration, err := model.ParseDuration(c.ReopenDuration.StringValue())
+		if err != nil {
+			return errors.WrapInvalidInputf(err, ErrCodeAlertmanagerChannelInvalid, "config.spec.reopenDuration %q is not a valid duration", c.ReopenDuration)
+		}
+
+		// A read reports the duration as model.Duration formats it, collapsing
+		// "72h" into "3d", so a value that is not already in that form is rejected
+		// rather than answered with one the caller never sent.
+		if canonical := reopenDuration.String(); canonical != c.ReopenDuration.StringValue() {
+			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.reopenDuration %q must be written as %q", c.ReopenDuration, canonical)
+		}
+	}
+
+	return nil
+}
+
+func (c ChannelJiraConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	// Seeded from upstream's default rather than a zero value: FollowRedirects
+	// and EnableHTTP2 marshal unconditionally, so a zero value would persist them
+	// as false and read back as a config ChannelJiraConfig cannot represent.
+	httpConfig := commoncfg.DefaultHTTPClientConfig
+	httpConfig.BasicAuth = &commoncfg.BasicAuth{
+		Username: c.Email,
+		Password: commoncfg.Secret(c.APIToken),
+	}
+
+	jira := &JiraReceiverConfig{
+		// JiraReceiverConfig seeds no send_resolved of its own, so unset means off.
+		NotifierConfig:    config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, false)},
+		Site:              c.Site,
+		Project:           c.Project,
+		IssueType:         c.IssueType,
+		Summary:           c.Summary.StringValue(),
+		Description:       c.Description.StringValue(),
+		Priority:          c.Priority,
+		Labels:            c.Labels,
+		ResolveTransition: c.ResolveTransition,
+		ReopenTransition:  c.ReopenTransition,
+		WontFixResolution: c.WontFixResolution,
+		CustomFields:      c.CustomFields,
+		HTTPConfig:        &httpConfig,
+	}
+
+	if !c.ReopenDuration.IsZero() {
+		reopenDuration, err := model.ParseDuration(c.ReopenDuration.StringValue())
+		if err != nil {
+			return nil, errors.WrapInvalidInputf(err, ErrCodeAlertmanagerChannelInvalid, "parse reopenDuration %q", c.ReopenDuration)
+		}
+		jira.ReopenDuration = reopenDuration
+	}
+
+	return &Receiver{
+		Receiver:    &config.Receiver{Name: displayName},
+		JiraConfigs: []*JiraReceiverConfig{jira},
+	}, nil
+}
+
+func newChannelJiraConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	jira := receiver.JiraConfigs[0]
+	sendResolved := jira.VSendResolved
+
+	if err := rejectUnsupportedHTTPConfig(name, jira.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	if jira.HTTPConfig != nil && jira.HTTPConfig.Authorization != nil {
+		return nil, errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.authorization, which is not supported", name)
+	}
+
+	if err := rejectHTTPBasicAuthBeyondPassword(name, jira.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	spec := &ChannelJiraConfig{
+		SendResolved:      &sendResolved,
+		Site:              jira.Site,
+		Project:           jira.Project,
+		IssueType:         jira.IssueType,
+		Summary:           valuer.UnsetIfEmpty(jira.Summary),
+		Description:       valuer.UnsetIfEmpty(jira.Description),
+		Priority:          jira.Priority,
+		Labels:            jira.Labels,
+		ResolveTransition: jira.ResolveTransition,
+		ReopenTransition:  jira.ReopenTransition,
+		ReopenDuration:    valuer.UnsetIfEmpty(jira.ReopenDuration.String()),
+		WontFixResolution: jira.WontFixResolution,
+		CustomFields:      jira.CustomFields,
+	}
+
+	if jira.HTTPConfig != nil && jira.HTTPConfig.BasicAuth != nil {
+		spec.Email = jira.HTTPConfig.BasicAuth.Username
+		spec.APIToken = string(jira.HTTPConfig.BasicAuth.Password)
+	}
+
+	return spec, nil
+}
+
+// ChannelJSMOpsConfig carries no API URL: JSM Ops is a single global gateway
+// keyed by the integration API key, which the notifier pins itself.
+type ChannelJSMOpsConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	APIKey       string                       `json:"apiKey" required:"true" format:"password"`
+	Message      valuer.UnsetOrNonEmptyString `json:"message"`
+	Description  valuer.UnsetOrNonEmptyString `json:"description"`
+	Priority     string                       `json:"priority"`
+	// Tags is the comma-separated list JSM Ops attaches to the alert.
+	Tags valuer.UnsetOrNonEmptyString `json:"tags"`
+}
+
+func (c ChannelJSMOpsConfig) Validate() error {
+	if c.APIKey == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiKey is required for a jsmops channel")
+	}
+
+	return nil
+}
+
+func (c ChannelJSMOpsConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	return &Receiver{
+		Receiver: &config.Receiver{Name: displayName},
+		JSMOpsConfigs: []*JSMOpsReceiverConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultJSMOpsReceiverConfig.VSendResolved)},
+			APIKey:         config.Secret(c.APIKey),
+			Message:        c.Message.StringValue(),
+			Description:    c.Description.StringValue(),
+			Priority:       c.Priority,
+			Tags:           c.Tags.StringValue(),
+		}},
+	}, nil
+}
+
+func newChannelJSMOpsConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	jsmops := receiver.JSMOpsConfigs[0]
+	sendResolved := jsmops.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, jsmops.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelJSMOpsConfig{
+		SendResolved: &sendResolved,
+		APIKey:       string(jsmops.APIKey),
+		Message:      valuer.UnsetIfEmpty(jsmops.Message),
+		Description:  valuer.UnsetIfEmpty(jsmops.Description),
+		Priority:     jsmops.Priority,
+		Tags:         valuer.UnsetIfEmpty(jsmops.Tags),
+	}, nil
+}
+
+type ChannelIncidentIOConfig struct {
+	SendResolved *bool                        `json:"sendResolved,omitempty"`
+	URL          string                       `json:"url" required:"true"`
+	Token        string                       `json:"token" required:"true" format:"password"`
+	Title        valuer.UnsetOrNonEmptyString `json:"title"`
+	Description  valuer.UnsetOrNonEmptyString `json:"description"`
+	Metadata     map[string]string            `json:"metadata,omitempty"`
+}
+
+func (c ChannelIncidentIOConfig) Validate() error {
+	if c.URL == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.url is required for an incidentio channel")
+	}
+
+	if c.Token == "" {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.token is required for an incidentio channel")
+	}
+
+	return nil
+}
+
+func (c ChannelIncidentIOConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
+	return &Receiver{
+		Receiver: &config.Receiver{Name: displayName},
+		IncidentIOConfigs: []*IncidentIOReceiverConfig{{
+			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultIncidentIOReceiverConfig.VSendResolved)},
+			URL:            c.URL,
+			Token:          config.Secret(c.Token),
+			Title:          c.Title.StringValue(),
+			Description:    c.Description.StringValue(),
+			Metadata:       c.Metadata,
+		}},
+	}, nil
+}
+
+func newChannelIncidentIOConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
+	incidentio := receiver.IncidentIOConfigs[0]
+	sendResolved := incidentio.VSendResolved
+
+	if err := rejectAnyHTTPAuth(name, incidentio.HTTPConfig); err != nil {
+		return nil, err
+	}
+
+	return &ChannelIncidentIOConfig{
+		SendResolved: &sendResolved,
+		URL:          incidentio.URL,
+		Token:        string(incidentio.Token),
+		Title:        valuer.UnsetIfEmpty(incidentio.Title),
+		Description:  valuer.UnsetIfEmpty(incidentio.Description),
+		Metadata:     incidentio.Metadata,
+	}, nil
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // Helpers
 // ════════════════════════════════════════════════════════════════════════

pkg/types/alertmanagertypes/googlechat.go

@@ -5,59 +5,10 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
 )
 
-type ChannelGoogleChatConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	WebhookURL   string                       `json:"webhookUrl" required:"true" format:"password"`
-	Title        valuer.UnsetOrNonEmptyString `json:"title"`
-	Text         valuer.UnsetOrNonEmptyString `json:"text"`
-}
-
-func (c ChannelGoogleChatConfig) Validate() error {
-	if c.WebhookURL == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.webhookUrl is required for a googlechat channel")
-	}
-
-	return nil
-}
-
-func (c ChannelGoogleChatConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	webhookURL, err := parseSecretURL(c.WebhookURL)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Receiver{
-		Receiver: &config.Receiver{Name: displayName},
-		GoogleChatConfigs: []*GoogleChatReceiverConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultGoogleChatReceiverConfig.VSendResolved)},
-			WebhookURL:     webhookURL,
-			Title:          c.Title.StringValue(),
-			Text:           c.Text.StringValue(),
-		}},
-	}, nil
-}
-
-func newChannelGoogleChatConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	googlechat := receiver.GoogleChatConfigs[0]
-	sendResolved := googlechat.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, googlechat.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelGoogleChatConfig{
-		SendResolved: &sendResolved,
-		WebhookURL:   formatSecretURL(googlechat.WebhookURL),
-		Title:        valuer.UnsetIfEmpty(googlechat.Title),
-		Text:         valuer.UnsetIfEmpty(googlechat.Text),
-	}, nil
-}
-
 type GoogleChatReceiverConfig struct {
 	config.NotifierConfig `yaml:",inline" json:",inline"`
 

pkg/types/alertmanagertypes/incidentio.go

@@ -6,64 +6,10 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
 )
 
-type ChannelIncidentIOConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	URL          string                       `json:"url" required:"true"`
-	Token        string                       `json:"token" required:"true" format:"password"`
-	Title        valuer.UnsetOrNonEmptyString `json:"title"`
-	Description  valuer.UnsetOrNonEmptyString `json:"description"`
-	Metadata     map[string]string            `json:"metadata,omitempty"`
-}
-
-func (c ChannelIncidentIOConfig) Validate() error {
-	if c.URL == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.url is required for an incidentio channel")
-	}
-
-	if c.Token == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.token is required for an incidentio channel")
-	}
-
-	return nil
-}
-
-func (c ChannelIncidentIOConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	return &Receiver{
-		Receiver: &config.Receiver{Name: displayName},
-		IncidentIOConfigs: []*IncidentIOReceiverConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultIncidentIOReceiverConfig.VSendResolved)},
-			URL:            c.URL,
-			Token:          config.Secret(c.Token),
-			Title:          c.Title.StringValue(),
-			Description:    c.Description.StringValue(),
-			Metadata:       c.Metadata,
-		}},
-	}, nil
-}
-
-func newChannelIncidentIOConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	incidentio := receiver.IncidentIOConfigs[0]
-	sendResolved := incidentio.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, incidentio.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelIncidentIOConfig{
-		SendResolved: &sendResolved,
-		URL:          incidentio.URL,
-		Token:        string(incidentio.Token),
-		Title:        valuer.UnsetIfEmpty(incidentio.Title),
-		Description:  valuer.UnsetIfEmpty(incidentio.Description),
-		Metadata:     incidentio.Metadata,
-	}, nil
-}
-
 // incidentIOEventsPathPrefix is the path of incident.io's HTTP alert source
 // endpoint (Alert Events V2 API). The full URL is per-source:
 // https://api.incident.io/v2/alert_events/http/<source_config_id>.

pkg/types/alertmanagertypes/jira.go

@@ -7,147 +7,11 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 )
 
-type ChannelJiraConfig struct {
-	SendResolved *bool `json:"sendResolved,omitempty"`
-	// Site is the Jira Cloud base URL, https://<site>.atlassian.net. Only Jira
-	// Cloud is supported; the REST base is derived from it.
-	Site              string                       `json:"site" required:"true"`
-	Project           string                       `json:"project" required:"true"`
-	IssueType         string                       `json:"issueType" required:"true"`
-	Summary           valuer.UnsetOrNonEmptyString `json:"summary"`
-	Description       valuer.UnsetOrNonEmptyString `json:"description"`
-	Priority          string                       `json:"priority"`
-	Labels            []string                     `json:"labels,omitempty"`
-	ResolveTransition string                       `json:"resolveTransition"`
-	ReopenTransition  string                       `json:"reopenTransition"`
-	ReopenDuration    valuer.UnsetOrNonEmptyString `json:"reopenDuration"`
-	WontFixResolution string                       `json:"wontFixResolution"`
-	CustomFields      map[string]any               `json:"customFields,omitempty"`
-
-	Email    string `json:"email" required:"true"`
-	APIToken string `json:"apiToken" required:"true" format:"password"`
-}
-
-func (c ChannelJiraConfig) Validate() error {
-	for _, required := range []struct {
-		value string
-		field string
-	}{
-		{c.Site, "site"},
-		{c.Project, "project"},
-		{c.IssueType, "issueType"},
-		{c.Email, "email"},
-		{c.APIToken, "apiToken"},
-	} {
-		if required.value == "" {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.%s is required for a jira channel", required.field)
-		}
-	}
-
-	if !c.ReopenDuration.IsZero() {
-		reopenDuration, err := model.ParseDuration(c.ReopenDuration.StringValue())
-		if err != nil {
-			return errors.WrapInvalidInputf(err, ErrCodeAlertmanagerChannelInvalid, "config.spec.reopenDuration %q is not a valid duration", c.ReopenDuration)
-		}
-
-		// A read reports the duration as model.Duration formats it, collapsing
-		// "72h" into "3d", so a value that is not already in that form is rejected
-		// rather than answered with one the caller never sent.
-		if canonical := reopenDuration.String(); canonical != c.ReopenDuration.StringValue() {
-			return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.reopenDuration %q must be written as %q", c.ReopenDuration, canonical)
-		}
-	}
-
-	return nil
-}
-
-func (c ChannelJiraConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	// Seeded from upstream's default rather than a zero value: FollowRedirects
-	// and EnableHTTP2 marshal unconditionally, so a zero value would persist them
-	// as false and read back as a config ChannelJiraConfig cannot represent.
-	httpConfig := commoncfg.DefaultHTTPClientConfig
-	httpConfig.BasicAuth = &commoncfg.BasicAuth{
-		Username: c.Email,
-		Password: commoncfg.Secret(c.APIToken),
-	}
-
-	jira := &JiraReceiverConfig{
-		// JiraReceiverConfig seeds no send_resolved of its own, so unset means off.
-		NotifierConfig:    config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, false)},
-		Site:              c.Site,
-		Project:           c.Project,
-		IssueType:         c.IssueType,
-		Summary:           c.Summary.StringValue(),
-		Description:       c.Description.StringValue(),
-		Priority:          c.Priority,
-		Labels:            c.Labels,
-		ResolveTransition: c.ResolveTransition,
-		ReopenTransition:  c.ReopenTransition,
-		WontFixResolution: c.WontFixResolution,
-		CustomFields:      c.CustomFields,
-		HTTPConfig:        &httpConfig,
-	}
-
-	if !c.ReopenDuration.IsZero() {
-		reopenDuration, err := model.ParseDuration(c.ReopenDuration.StringValue())
-		if err != nil {
-			return nil, errors.WrapInvalidInputf(err, ErrCodeAlertmanagerChannelInvalid, "parse reopenDuration %q", c.ReopenDuration)
-		}
-		jira.ReopenDuration = reopenDuration
-	}
-
-	return &Receiver{
-		Receiver:    &config.Receiver{Name: displayName},
-		JiraConfigs: []*JiraReceiverConfig{jira},
-	}, nil
-}
-
-func newChannelJiraConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	jira := receiver.JiraConfigs[0]
-	sendResolved := jira.VSendResolved
-
-	if err := rejectUnsupportedHTTPConfig(name, jira.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	if jira.HTTPConfig != nil && jira.HTTPConfig.Authorization != nil {
-		return nil, errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.authorization, which is not supported", name)
-	}
-
-	if err := rejectHTTPBasicAuthBeyondPassword(name, jira.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	spec := &ChannelJiraConfig{
-		SendResolved:      &sendResolved,
-		Site:              jira.Site,
-		Project:           jira.Project,
-		IssueType:         jira.IssueType,
-		Summary:           valuer.UnsetIfEmpty(jira.Summary),
-		Description:       valuer.UnsetIfEmpty(jira.Description),
-		Priority:          jira.Priority,
-		Labels:            jira.Labels,
-		ResolveTransition: jira.ResolveTransition,
-		ReopenTransition:  jira.ReopenTransition,
-		ReopenDuration:    valuer.UnsetIfEmpty(jira.ReopenDuration.String()),
-		WontFixResolution: jira.WontFixResolution,
-		CustomFields:      jira.CustomFields,
-	}
-
-	if jira.HTTPConfig != nil && jira.HTTPConfig.BasicAuth != nil {
-		spec.Email = jira.HTTPConfig.BasicAuth.Username
-		spec.APIToken = string(jira.HTTPConfig.BasicAuth.Password)
-	}
-
-	return spec, nil
-}
-
 const defaultJiraReopenDuration = model.Duration(3 * 24 * time.Hour)
 
 // Service accounts authenticate against the api.atlassian.com gateway (keyed by

pkg/types/alertmanagertypes/jsmops.go

@@ -2,63 +2,10 @@ package alertmanagertypes
 
 import (
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
 )
 
-// ChannelJSMOpsConfig carries no API URL: JSM Ops is a single global gateway
-// keyed by the integration API key, which the notifier pins itself.
-type ChannelJSMOpsConfig struct {
-	SendResolved *bool                        `json:"sendResolved,omitempty"`
-	APIKey       string                       `json:"apiKey" required:"true" format:"password"`
-	Message      valuer.UnsetOrNonEmptyString `json:"message"`
-	Description  valuer.UnsetOrNonEmptyString `json:"description"`
-	Priority     string                       `json:"priority"`
-	// Tags is the comma-separated list JSM Ops attaches to the alert.
-	Tags valuer.UnsetOrNonEmptyString `json:"tags"`
-}
-
-func (c ChannelJSMOpsConfig) Validate() error {
-	if c.APIKey == "" {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.apiKey is required for a jsmops channel")
-	}
-
-	return nil
-}
-
-func (c ChannelJSMOpsConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {
-	return &Receiver{
-		Receiver: &config.Receiver{Name: displayName},
-		JSMOpsConfigs: []*JSMOpsReceiverConfig{{
-			NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultJSMOpsReceiverConfig.VSendResolved)},
-			APIKey:         config.Secret(c.APIKey),
-			Message:        c.Message.StringValue(),
-			Description:    c.Description.StringValue(),
-			Priority:       c.Priority,
-			Tags:           c.Tags.StringValue(),
-		}},
-	}, nil
-}
-
-func newChannelJSMOpsConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {
-	jsmops := receiver.JSMOpsConfigs[0]
-	sendResolved := jsmops.VSendResolved
-
-	if err := rejectAnyHTTPAuth(name, jsmops.HTTPConfig); err != nil {
-		return nil, err
-	}
-
-	return &ChannelJSMOpsConfig{
-		SendResolved: &sendResolved,
-		APIKey:       string(jsmops.APIKey),
-		Message:      valuer.UnsetIfEmpty(jsmops.Message),
-		Description:  valuer.UnsetIfEmpty(jsmops.Description),
-		Priority:     jsmops.Priority,
-		Tags:         valuer.UnsetIfEmpty(jsmops.Tags),
-	}, nil
-}
-
 // JSMOpsAPIBaseURL is the native JSM Ops integration-events gateway. It is a
 // single global host keyed by the integration API key (no region/cloud id in
 // the path). The trailing slash is required: the Opsgenie notifier appends

pkg/types/authtypes/token.go

@@ -258,6 +258,6 @@ type TokenStore interface {
 	// Delete a token by userID.
 	DeleteByUserID(context.Context, valuer.UUID) error
 
-	// Update last observed at of the given tokens.
-	UpdateLastObservedAt(context.Context, []*StorableToken) error
+	// Update last observed at by access token.
+	UpdateLastObservedAtByAccessToken(context.Context, []map[string]any) error
 }

pkg/types/cloudintegrationtypes/account.go

@@ -3,7 +3,6 @@ package cloudintegrationtypes
 import (
 	"encoding/json"
 	"fmt"
-	"maps"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -27,17 +26,6 @@ type Account struct {
 type AgentReport struct {
 	TimestampMillis int64          `json:"timestampMillis" required:"true"`
 	Data            map[string]any `json:"data" required:"true" nullable:"true"`
-	SyncState       *SyncState     `json:"syncState" required:"true" nullable:"true"`
-}
-
-type SyncState struct {
-	Version int64                       `json:"version" required:"true"`
-	InSync  bool                        `json:"inSync" required:"true"`
-	Regions map[string]*RegionSyncState `json:"regions" required:"true" nullable:"false"`
-}
-
-type RegionSyncState struct {
-	State RegionState `json:"state" required:"true"`
 }
 
 type AccountConfig struct {
@@ -162,7 +150,6 @@ func NewAccountFromStorable(storableAccount *StorableCloudIntegration) (*Account
 		account.AgentReport = &AgentReport{
 			TimestampMillis: storableAccount.LastAgentReport.TimestampMillis,
 			Data:            storableAccount.LastAgentReport.Data,
-			SyncState:       NewSyncStateFromStorable(storableAccount.LastAgentReport.SyncState),
 		}
 	}
 
@@ -321,28 +308,10 @@ func NewAccountConfigFromUpdatable(provider CloudProviderType, config *Updatable
 	}
 }
 
-func NewAgentReport(data map[string]any, syncState *SyncState) *AgentReport {
+func NewAgentReport(data map[string]any) *AgentReport {
 	return &AgentReport{
 		TimestampMillis: time.Now().UnixMilli(),
 		Data:            data,
-		SyncState:       syncState,
-	}
-}
-
-func NewSyncStateFromStorable(storableSyncState *StorableSyncState) *SyncState {
-	if storableSyncState == nil {
-		return nil
-	}
-
-	regions := make(map[string]*RegionSyncState, len(storableSyncState.Regions))
-	for region, regionSyncState := range storableSyncState.Regions {
-		regions[region] = &RegionSyncState{State: regionSyncState.State}
-	}
-
-	return &SyncState{
-		Version: storableSyncState.Version,
-		InSync:  storableSyncState.InSync,
-		Regions: regions,
 	}
 }
 
@@ -366,40 +335,6 @@ func (account *Account) Update(provider CloudProviderType, config *AccountConfig
 	return nil
 }
 
-func (account *Account) UpdateAgentReport(providerAccountID *string, agentReport *AgentReport) {
-	account.ProviderAccountID = providerAccountID
-	account.AgentReport = agentReport
-}
-
-// UpdateSyncState keeps the rest of the agent report, and is a no-op when the agent has never checked in.
-func (account *Account) UpdateSyncState(syncState *SyncState) {
-	if account.AgentReport == nil {
-		return
-	}
-
-	account.AgentReport.SyncState = syncState
-}
-
-// NextSyncState returns the sync state for this check-in, or nil for providers without one.
-func (account *Account) NextSyncState(syncedVersion *int64) *SyncState {
-	if account.Provider != CloudProviderTypeAWS {
-		return nil
-	}
-
-	var previous *SyncState
-	if account.AgentReport != nil {
-		previous = account.AgentReport.SyncState
-	}
-
-	regions := account.Config.AWS.Regions
-	// Removed before the agent ever checked in: no region was sent to it, so there is nothing to clean up.
-	if account.AgentReport == nil && account.RemovedAt != nil {
-		regions = nil
-	}
-
-	return newSyncState(previous, regions, account.RemovedAt != nil, syncedVersion)
-}
-
 func (postableAccount *PostableAccount) UnmarshalJSON(data []byte) error {
 	type Alias PostableAccount
 
@@ -471,79 +406,3 @@ func (config *AccountConfig) ToJSON() ([]byte, error) {
 func NewIngestionKeyName(provider CloudProviderType) string {
 	return fmt.Sprintf("%s-integration", provider.StringValue())
 }
-
-// newSyncState returns the sync state after a check-in without mutating previous.
-func newSyncState(previous *SyncState, regions []string, removed bool, syncedVersion *int64) *SyncState {
-	if previous == nil {
-		previous = newSyncStateFromRegions(regions)
-	}
-
-	next := previous.copy()
-
-	// The agent synced this version, so its disabled regions are cleaned up and can be dropped.
-	if syncedVersion != nil && *syncedVersion == next.Version {
-		next.InSync = true
-		maps.DeleteFunc(next.Regions, func(_ string, regionSyncState *RegionSyncState) bool {
-			return regionSyncState.State == RegionStateDisabled
-		})
-	}
-
-	// Once the integration is removed, every region is disabled.
-	if removed {
-		regions = nil
-	}
-
-	changed := false
-	desiredRegionsMap := make(map[string]struct{}, len(regions))
-
-	for _, region := range regions {
-		desiredRegionsMap[region] = struct{}{}
-
-		if regionSyncState, ok := next.Regions[region]; ok && regionSyncState.State == RegionStateEnabled {
-			continue
-		}
-
-		next.Regions[region] = &RegionSyncState{State: RegionStateEnabled}
-		changed = true
-	}
-
-	for region, regionSyncState := range next.Regions {
-		_, ok := desiredRegionsMap[region]
-		if ok && regionSyncState.State == RegionStateEnabled {
-			continue
-		}
-
-		if !ok && regionSyncState.State == RegionStateDisabled {
-			continue
-		}
-
-		regionSyncState.State = RegionStateDisabled
-		changed = true
-	}
-
-	if changed {
-		next.Version++
-		next.InSync = false
-	}
-
-	return next
-}
-
-// newSyncStateFromRegions is used on the first check-in, when the agent has already deployed regions, so it starts in sync.
-func newSyncStateFromRegions(regions []string) *SyncState {
-	syncState := &SyncState{Version: 1, InSync: true, Regions: make(map[string]*RegionSyncState, len(regions))}
-	for _, region := range regions {
-		syncState.Regions[region] = &RegionSyncState{State: RegionStateEnabled}
-	}
-
-	return syncState
-}
-
-func (syncState *SyncState) copy() *SyncState {
-	regions := make(map[string]*RegionSyncState, len(syncState.Regions))
-	for region, regionSyncState := range syncState.Regions {
-		regions[region] = &RegionSyncState{State: regionSyncState.State}
-	}
-
-	return &SyncState{Version: syncState.Version, InSync: syncState.InSync, Regions: regions}
-}

pkg/types/cloudintegrationtypes/checkin.go

@@ -12,8 +12,7 @@ type AgentCheckInRequest struct {
 	ProviderAccountID  string      `json:"providerAccountId" required:"false"`
 	CloudIntegrationID valuer.UUID `json:"cloudIntegrationId" required:"false"`
 
-	Data          map[string]any `json:"data" required:"true" nullable:"true"`
-	SyncedVersion *int64         `json:"syncedVersion" required:"false" nullable:"true"`
+	Data map[string]any `json:"data" required:"true" nullable:"true"`
 }
 
 type PostableAgentCheckIn struct {
@@ -29,7 +28,6 @@ type AgentCheckInResponse struct {
 	ProviderAccountID  string                     `json:"providerAccountId" required:"true"`
 	IntegrationConfig  *ProviderIntegrationConfig `json:"integrationConfig" required:"true"`
 	RemovedAt          *time.Time                 `json:"removedAt" required:"true" nullable:"true"`
-	SyncState          *SyncState                 `json:"syncState" required:"true" nullable:"true"`
 }
 
 type GettableAgentCheckIn struct {
@@ -75,13 +73,12 @@ func NewGettableAgentCheckIn(provider CloudProviderType, resp *AgentCheckInRespo
 	return gettable
 }
 
-func NewAgentCheckInResponse(providerAccountID, cloudIntegrationID string, integrationConfig *ProviderIntegrationConfig, removedAt *time.Time, syncState *SyncState) *AgentCheckInResponse {
+func NewAgentCheckInResponse(providerAccountID, cloudIntegrationID string, integrationConfig *ProviderIntegrationConfig, removedAt *time.Time) *AgentCheckInResponse {
 	return &AgentCheckInResponse{
 		CloudIntegrationID: cloudIntegrationID,
 		ProviderAccountID:  providerAccountID,
 		IntegrationConfig:  integrationConfig,
 		RemovedAt:          removedAt,
-		SyncState:          syncState,
 	}
 }
 

pkg/types/cloudintegrationtypes/cloudintegration.go

@@ -25,17 +25,6 @@ var (
 	ErrCodeServiceDefinitionNotFound            = errors.MustNewCode("service_definition_not_found")
 )
 
-var (
-	RegionStateEnabled  = RegionState{valuer.NewString("enabled")}
-	RegionStateDisabled = RegionState{valuer.NewString("disabled")}
-)
-
-type RegionState struct{ valuer.String }
-
-func (RegionState) Enum() []any {
-	return []any{RegionStateEnabled, RegionStateDisabled}
-}
-
 // StorableCloudIntegration represents a cloud integration stored in the database.
 // This is also referred as "Account" in the context of cloud integrations.
 type StorableCloudIntegration struct {
@@ -54,16 +43,8 @@ type StorableCloudIntegration struct {
 // StorableAgentReport represents the last heartbeat and arbitrary data sent by the agent
 // as of now there is no use case for Data field, but keeping it for backwards compatibility with older structure.
 type StorableAgentReport struct {
-	TimestampMillis int64              `json:"timestamp_millis"` // backward compatibility
-	Data            map[string]any     `json:"data"`
-	SyncState       *StorableSyncState `json:"sync_state,omitempty"`
-}
-
-// StorableSyncState holds every region sent to the agent. A disabled region is dropped only after the agent acks Version.
-type StorableSyncState struct {
-	Version int64                       `json:"version"`
-	InSync  bool                        `json:"in_sync"`
-	Regions map[string]*RegionSyncState `json:"regions"`
+	TimestampMillis int64          `json:"timestamp_millis"` // backward compatibility
+	Data            map[string]any `json:"data"`
 }
 
 // StorableCloudIntegrationService is to store service config for a cloud integration, which is a cloud provider specific configuration.
@@ -167,30 +148,12 @@ func NewStorableCloudIntegration(account *Account) (*StorableCloudIntegration, e
 		storableAccount.LastAgentReport = &StorableAgentReport{
 			TimestampMillis: account.AgentReport.TimestampMillis,
 			Data:            account.AgentReport.Data,
-			SyncState:       NewStorableSyncState(account.AgentReport.SyncState),
 		}
 	}
 
 	return storableAccount, nil
 }
 
-func NewStorableSyncState(syncState *SyncState) *StorableSyncState {
-	if syncState == nil {
-		return nil
-	}
-
-	regions := make(map[string]*RegionSyncState, len(syncState.Regions))
-	for region, regionSyncState := range syncState.Regions {
-		regions[region] = &RegionSyncState{State: regionSyncState.State}
-	}
-
-	return &StorableSyncState{
-		Version: syncState.Version,
-		InSync:  syncState.InSync,
-		Regions: regions,
-	}
-}
-
 // NewStorableCloudIntegrationService creates a new StorableCloudIntegrationService with
 // generated ID and timestamps from a CloudIntegrationService and its serialized config JSON.
 func NewStorableCloudIntegrationService(svc *CloudIntegrationService, configJSON string) *StorableCloudIntegrationService {
@@ -209,7 +172,6 @@ func (account *StorableCloudIntegration) Update(providerAccountID *string, agent
 		account.LastAgentReport = &StorableAgentReport{
 			TimestampMillis: agentReport.TimestampMillis,
 			Data:            agentReport.Data,
-			SyncState:       NewStorableSyncState(agentReport.SyncState),
 		}
 	}
 }

pkg/types/cloudintegrationtypes/store.go

@@ -25,12 +25,9 @@ type Store interface {
 	// CreateAccount creates a new cloud integration account
 	CreateAccount(ctx context.Context, account *StorableCloudIntegration) error
 
-	// UpdateAccount updates the user updatable fields (config) of an existing cloud integration account
+	// UpdateAccount updates an existing cloud integration account
 	UpdateAccount(ctx context.Context, account *StorableCloudIntegration) error
 
-	// UpdateAgentReport updates the provider account id and last agent report of an existing cloud integration account
-	UpdateAgentReport(ctx context.Context, account *StorableCloudIntegration) error
-
 	// RemoveAccount marks a cloud integration account as removed by setting the RemovedAt field
 	RemoveAccount(ctx context.Context, orgID, id valuer.UUID, provider CloudProviderType) error
 

pkg/types/llmpricingruletypes/pricing.go

@@ -208,35 +208,6 @@ func NewGettableUnmappedModels(items []*UnmappedModel) *GettableUnmappedModels {
 	}
 }
 
-func (u *UpdatableLLMPricingRule) UnmarshalJSON(data []byte) error {
-	type Alias UpdatableLLMPricingRule
-
-	var temp Alias
-	if err := json.Unmarshal(data, &temp); err != nil {
-		return err
-	}
-
-	*u = UpdatableLLMPricingRule(temp)
-	return u.Validate()
-}
-
-// Validate mirrors the collector's pattern check: at least one pattern, none
-// empty, all valid path.Match globs.
-func (u *UpdatableLLMPricingRule) Validate() error {
-	if len(u.ModelPattern) == 0 {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern must contain at least one pattern", u.Model)
-	}
-	for _, p := range u.ModelPattern {
-		if p == "" {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern must not contain an empty pattern", u.Model)
-		}
-		if _, err := path.Match(p, ""); err != nil {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodePricingRuleInvalidInput, "model %q: modelPattern %q is not a valid glob", u.Model, p)
-		}
-	}
-	return nil
-}
-
 func NewLLMPricingRuleFromUpdatable(u *UpdatableLLMPricingRule, orgID valuer.UUID, userEmail string, now time.Time) *LLMPricingRule {
 	id := valuer.GenerateUUID()
 	if u.ID != nil {

pkg/types/llmpricingruletypes/processorconfig_test.go

@@ -1,7 +1,6 @@
 package llmpricingruletypes
 
 import (
-	"encoding/json"
 	"os"
 	"path/filepath"
 	"testing"
@@ -127,34 +126,3 @@ func TestGenerateCollectorConfig_EmptyInputPassthrough(t *testing.T) {
 		assert.Equal(t, in, out)
 	}
 }
-
-func TestUpdatableLLMPricingRuleUnmarshalJSON(t *testing.T) {
-	tests := []struct {
-		name    string
-		pattern string
-		wantErr bool
-	}{
-		{name: "valid", pattern: `["gpt-4o*", "gpt-4o"]`},
-		{name: "missing", pattern: ``, wantErr: true},
-		{name: "null", pattern: `null`, wantErr: true},
-		{name: "empty_list", pattern: `[]`, wantErr: true},
-		{name: "empty_entry", pattern: `["gpt-4o*", ""]`, wantErr: true},
-		{name: "bad_glob", pattern: `["gpt-["]`, wantErr: true},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			body := `{"modelName": "gpt-4o"}`
-			if tc.pattern != "" {
-				body = `{"modelName": "gpt-4o", "modelPattern": ` + tc.pattern + `}`
-			}
-			var req UpdatableLLMPricingRules
-			err := json.Unmarshal([]byte(`{"rules": [`+body+`]}`), &req)
-			if tc.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}

tests/fixtures/cloudintegrations.py

@@ -34,8 +34,6 @@ class ProviderAccountSpec:
     expected_config: Callable[[dict], dict]
     # only the suites that exercise updates need to supply it.
     updated_params: dict = field(default_factory=dict)
-    # params -> the agentReport.syncState the API is expected to return after the first check-in.
-    expected_sync_state: Callable[[dict], dict | None] = lambda p: None
     # id shown in parametrized test names; defaults to the provider slug.
     id: str = field(default="")
 
@@ -317,7 +315,6 @@ def simulate_agent_checkin(
     account_id: str,
     cloud_account_id: str,
     data: dict | None = None,
-    synced_version: int | None = None,
 ) -> requests.Response:
     endpoint = f"/api/v1/cloud_integrations/{cloud_provider}/accounts/check_in"
 
@@ -326,8 +323,6 @@ def simulate_agent_checkin(
         "providerAccountId": cloud_account_id,
         "data": data or {},
     }
-    if synced_version is not None:
-        checkin_payload["syncedVersion"] = synced_version
 
     response = requests.post(
         signoz.self.host_configs["8080"].get(endpoint),

tests/integration/tests/cloudintegrations/03_agent_check_in.py

@@ -3,7 +3,6 @@ from collections.abc import Callable
 from http import HTTPStatus
 
 import pytest
-import requests
 
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
@@ -153,230 +152,3 @@ def test_duplicate_cloud_account_checkins(
     # Second check-in: account2 tries to claim the same provider account ID → 409
     response = simulate_agent_checkin(signoz, admin_token, spec.provider, account2["id"], same_provider_account_id)
     assert response.status_code == HTTPStatus.CONFLICT, f"Expected 409 for duplicate providerAccountId, got {response.status_code}: {response.text}"
-
-
-def test_sync_state_drops_removed_region_after_ack(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-) -> None:
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"regions": ["us-east-1"]}}},
-        timeout=10,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == {
-        "version": 2,
-        "inSync": False,
-        "regions": {"us-east-1": {"state": "enabled"}, "us-west-2": {"state": "disabled"}},
-    }, "removed region should be marked disabled and the version bumped"
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=2)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == {
-        "version": 2,
-        "inSync": True,
-        "regions": {"us-east-1": {"state": "enabled"}},
-    }, "acked removed region should be dropped"
-
-
-def test_sync_state_keeps_removed_region_without_ack(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-) -> None:
-    """The agent failed to clean up or crashed, so it never acks: the removed region stays and the version stays put."""
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"regions": ["us-east-1"]}}},
-        timeout=10,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    for _ in range(3):
-        response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-        assert response.status_code == HTTPStatus.OK, response.text
-        assert response.json()["data"]["syncState"] == {
-            "version": 2,
-            "inSync": False,
-            "regions": {"us-east-1": {"state": "enabled"}, "us-west-2": {"state": "disabled"}},
-        }, "unacked removed region should stay without bumping the version"
-
-
-@pytest.mark.parametrize("synced_version", [2, 9], ids=["stale", "ahead"])
-def test_sync_state_ignores_mismatched_ack(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-    synced_version: int,
-) -> None:
-    """An ack for any version other than the current one (v3) is ignored,
-    so us-west-2, removed at v2 and still unacked, is not dropped.
-    """
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    for regions in (["us-east-1"], ["us-east-1", "eu-west-1"]):
-        response = requests.put(
-            signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-            headers={"Authorization": f"Bearer {admin_token}"},
-            json={"config": {"aws": {"regions": regions}}},
-            timeout=10,
-        )
-        assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-        response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-        assert response.status_code == HTTPStatus.OK, response.text
-
-    expected_sync_state = {
-        "version": 3,
-        "inSync": False,
-        "regions": {"us-east-1": {"state": "enabled"}, "us-west-2": {"state": "disabled"}, "eu-west-1": {"state": "enabled"}},
-    }
-    assert response.json()["data"]["syncState"] == expected_sync_state
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=synced_version)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == expected_sync_state, "an ack for another version should be ignored"
-
-
-def test_sync_state_applies_ack_before_config_change(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-) -> None:
-    """The user changes regions while the agent syncs: the ack for the version it synced still lands."""
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    for regions, synced_version in ((["us-east-1"], None), (["us-east-1", "eu-west-1"], 2)):
-        response = requests.put(
-            signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-            headers={"Authorization": f"Bearer {admin_token}"},
-            json={"config": {"aws": {"regions": regions}}},
-            timeout=10,
-        )
-        assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-        response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=synced_version)
-        assert response.status_code == HTTPStatus.OK, response.text
-
-    assert response.json()["data"]["syncState"] == {
-        "version": 3,
-        "inSync": False,
-        "regions": {"us-east-1": {"state": "enabled"}, "eu-west-1": {"state": "enabled"}},
-    }, "ack should drop the removed region before the new region bumps the version"
-
-
-@pytest.mark.parametrize("synced_version", [1, None], ids=["agent_acks_synced_version", "agent_crashed"])
-def test_sync_state_region_removed_during_sync(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-    synced_version: int | None,
-) -> None:
-    """The user removes a region while the agent syncs v1; whether the agent acks v1 or crashed, the region must not be lost."""
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == {
-        "version": 1,
-        "inSync": True,
-        "regions": {"us-east-1": {"state": "enabled"}, "us-west-2": {"state": "enabled"}},
-    }
-
-    response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"regions": ["us-east-1"]}}},
-        timeout=10,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=synced_version)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == {
-        "version": 2,
-        "inSync": False,
-        "regions": {"us-east-1": {"state": "enabled"}, "us-west-2": {"state": "disabled"}},
-    }, "region removed mid-sync should be marked disabled"
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=2)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["data"]["syncState"] == {
-        "version": 2,
-        "inSync": True,
-        "regions": {"us-east-1": {"state": "enabled"}},
-    }
-
-
-def test_sync_state_after_disconnect(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-) -> None:
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    account_id = create_cloud_integration_account(admin_token, "aws", regions=["us-east-1", "us-west-2"])["id"]
-    provider_account_id = str(uuid.uuid4())
-
-    response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    response = requests.delete(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/aws/accounts/{account_id}"),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=10,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    for _ in range(2):
-        response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id)
-        assert response.status_code == HTTPStatus.OK, response.text
-        assert response.json()["data"]["removedAt"] is not None, "removedAt should be set after disconnect"
-        assert response.json()["data"]["syncState"] == {
-            "version": 2,
-            "inSync": False,
-            "regions": {"us-east-1": {"state": "disabled"}, "us-west-2": {"state": "disabled"}},
-        }, "every region should be disabled once, without bumping the version on later check-ins"
-
-    for _ in range(2):
-        response = simulate_agent_checkin(signoz, admin_token, "aws", account_id, provider_account_id, synced_version=2)
-        assert response.status_code == HTTPStatus.OK, response.text
-        assert response.json()["data"]["syncState"] == {"version": 2, "inSync": True, "regions": {}}, "acked removal should leave no regions"

tests/integration/tests/cloudintegrations/04_accounts.py

@@ -21,11 +21,6 @@ AWS_ACCOUNT_SPEC = ProviderAccountSpec(
     updated_params={"deployment_region": "us-east-1", "regions": ["us-east-1", "us-west-2", "eu-west-1"]},
     build_config=lambda p: {"aws": {"deploymentRegion": p["deployment_region"], "regions": p["regions"]}},
     expected_config=lambda p: {"regions": p["regions"]},
-    expected_sync_state=lambda p: {
-        "version": 1,
-        "inSync": True,
-        "regions": {region: {"state": "enabled"} for region in p["regions"]},
-    },
 )
 
 GCP_ACCOUNT_SPEC = ProviderAccountSpec(
@@ -133,7 +128,6 @@ def test_list_accounts_after_checkin(
     assert found["providerAccountId"] == provider_account_id, "providerAccountId should match"
     assert found["config"][spec.provider] == spec.expected_config(spec.initial_params), "config should match account config"
     assert found["agentReport"] is not None, "agentReport should be present after check-in"
-    assert found["agentReport"]["syncState"] == spec.expected_sync_state(spec.initial_params), "syncState should be seeded from the account regions on first check-in"
     assert found["removedAt"] is None, "removedAt should be null for a live account"
 
 
@@ -288,7 +282,6 @@ def test_update_account_after_checkin_preserves_connected_status(
     assert found_after is not None, "Account must still be listed after config update (account_id should not be reset)"
     assert found_after["providerAccountId"] == provider_account_id, "providerAccountId should be preserved after update"
     assert found_after["agentReport"] is not None, "agentReport should be preserved after update"
-    assert found_after["agentReport"]["syncState"] == found_before["agentReport"]["syncState"], "config update must not change syncState"
     assert found_after["config"][spec.provider] == spec.expected_config(spec.updated_params), "Config should reflect the update"
     assert found_after["removedAt"] is None, "removedAt should still be null"
 

tests/integration/tests/llmpricingrules/01_upsert.py

@@ -130,17 +130,3 @@ def test_bulk_sync(
     assert all(r["pricing"]["input"] == 5 for r in stored)
 
     delete_all_llm_pricing_rules(signoz, token)
-
-
-def test_rejects_rule_without_pattern(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    delete_all_llm_pricing_rules(signoz, token)
-
-    rules = zeus_rules(10)
-    rules[1]["modelPattern"] = []
-    assert upsert_llm_pricing_rules(signoz, token, rules).status_code == HTTPStatus.BAD_REQUEST
-    assert list_llm_pricing_rules(signoz, token) == []

tests/integration/tests/passwordauthn/09_last_observed_at.py

@@ -1,36 +0,0 @@
-import time
-from collections.abc import Callable
-from http import HTTPStatus
-
-import requests
-from sqlalchemy import sql
-
-from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-
-
-def test_last_observed_at_is_flushed(signoz: types.SigNoz, get_token: Callable[[str, str], str]) -> None:
-    """Verify the tokenizer GC persists the cached last observed at of a used token to the sql store."""
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v2/users/me"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK
-
-    deadline = time.time() + 30
-    while time.time() < deadline:
-        with signoz.sqlstore.conn.connect() as conn:
-            row = conn.execute(
-                sql.text("SELECT last_observed_at FROM auth_token WHERE access_token = :access_token"),
-                {"access_token": token},
-            ).fetchone()
-
-        if row is not None and row[0] is not None:
-            return
-
-        time.sleep(1)
-
-    raise AssertionError("last_observed_at was not flushed to the sql store within 30s")

tests/integration/tests/passwordauthn/conftest.py

@@ -1,33 +0,0 @@
-import pytest
-from testcontainers.core.container import Network
-
-from fixtures import types
-from fixtures.signoz import create_signoz
-
-
-@pytest.fixture(name="signoz", scope="package")
-def signoz_passwordauthn(
-    network: Network,
-    zeus: types.TestContainerDocker,
-    gateway: types.TestContainerDocker,
-    sqlstore: types.TestContainerSQL,
-    clickhouse: types.TestContainerClickhouse,
-    request: pytest.FixtureRequest,
-    pytestconfig: pytest.Config,
-) -> types.SigNoz:
-    """
-    Package-scoped fixture for SigNoz with a short tokenizer GC interval so the last observed at flush runs within a test.
-    """
-    return create_signoz(
-        network=network,
-        zeus=zeus,
-        gateway=gateway,
-        sqlstore=sqlstore,
-        clickhouse=clickhouse,
-        request=request,
-        pytestconfig=pytestconfig,
-        cache_key="signoz-passwordauthn",
-        env_overrides={
-            "SIGNOZ_TOKENIZER_OPAQUE_GC_INTERVAL": "5s",
-        },
-    )