chore: temp commit

Signed-off-by: Niladri Adhikary <niladrix719@gmail.com>

cmd/community/Dockerfile

@@ -11,7 +11,7 @@ RUN apk update && \
 
 
 COPY ./target/${OS}-${TARGETARCH}/signoz-community /root/signoz
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/community/Dockerfile.multi-arch

@@ -12,7 +12,7 @@ RUN apk update && \
     rm -rf /var/cache/apk/*
 
 COPY ./target/${OS}-${ARCH}/signoz-community /root/signoz-community
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz-community

cmd/enterprise/Dockerfile

@@ -11,7 +11,7 @@ RUN apk update && \
 
 
 COPY ./target/${OS}-${TARGETARCH}/signoz /root/signoz
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/enterprise/Dockerfile.integration

@@ -26,7 +26,7 @@ RUN go mod download
 COPY ./cmd/ ./cmd/
 COPY ./ee/ ./ee/
 COPY ./pkg/ ./pkg/
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 
 COPY Makefile Makefile
 RUN TARGET_DIR=/root ARCHS=${TARGETARCH} ZEUS_URL=${ZEUSURL} LICENSE_URL=${ZEUSURL}/api/v1 make go-build-enterprise-race

cmd/enterprise/Dockerfile.multi-arch

@@ -12,7 +12,7 @@ RUN apk update && \
     rm -rf /var/cache/apk/*
 
 COPY ./target/${OS}-${ARCH}/signoz /root/signoz
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/enterprise/Dockerfile.with-web.integration

@@ -35,7 +35,7 @@ RUN go mod download
 COPY ./cmd/ ./cmd/
 COPY ./ee/ ./ee/
 COPY ./pkg/ ./pkg/
-COPY ./templates/email /root/templates
+COPY ./templates /root/templates
 
 COPY Makefile Makefile
 RUN TARGET_DIR=/root ARCHS=${TARGETARCH} ZEUS_URL=${ZEUSURL} LICENSE_URL=${ZEUSURL}/api/v1 make go-build-enterprise-race

conf/example.yaml

@@ -182,6 +182,11 @@ alertmanager:
     poll_interval: 1m
     # The URL under which Alertmanager is externally reachable (for example, if Alertmanager is served via a reverse proxy). Used for generating relative and absolute links back to Alertmanager itself.
     external_url: http://localhost:8080
+    # The list of globs from which SigNoz's alertmanager notification templates are loaded (e.g. the email.signoz.html layout).
+    # This mirrors the upstream alertmanager `templates` config option. The upstream default templates (default.tmpl, email.tmpl)
+    # are always loaded from the embedded alertmanager assets, so only SigNoz's own templates need to be listed here.
+    templates:
+      - /opt/signoz/conf/templates/alertmanager/*.gotmpl
     # The global configuration for the alertmanager. All the exahustive fields can be found in the upstream: https://github.com/prometheus/alertmanager/blob/efa05feffd644ba4accb526e98a8c6545d26a783/config/config.go#L833
     global:
       # ResolveTimeout is the time after which an alert is declared resolved if it has not been updated.

docs/api/openapi.yml

@@ -1544,6 +1544,17 @@ components:
         webhook_url_file:
           type: string
       type: object
+    ConfigGoogleChatConfig:
+      properties:
+        send_resolved:
+          type: boolean
+        text:
+          type: string
+        title:
+          type: string
+        webhook_url:
+          $ref: '#/components/schemas/ConfigSecretURL'
+      type: object
     ConfigMattermostAttachment:
       properties:
         author_icon:
@@ -1847,6 +1858,10 @@ components:
           items:
             $ref: '#/components/schemas/ConfigEmailConfig'
           type: array
+        googlechat_configs:
+          items:
+            $ref: '#/components/schemas/ConfigGoogleChatConfig'
+          type: array
         incidentio_configs:
           items:
             $ref: '#/components/schemas/ConfigIncidentioConfig'
@@ -5109,23 +5124,6 @@ components:
       - start
       - end
       type: object
-    RuletypesActiveMuteInfo:
-      properties:
-        description:
-          type: string
-        effectiveEndTime:
-          format: date-time
-          nullable: true
-          type: string
-        effectiveStartTime:
-          format: date-time
-          nullable: true
-          type: string
-        id:
-          type: string
-        name:
-          type: string
-      type: object
     RuletypesAlertCompositeQuery:
       properties:
         panelType:
@@ -5376,8 +5374,6 @@ components:
       type: object
     RuletypesRule:
       properties:
-        activeMute:
-          $ref: '#/components/schemas/RuletypesActiveMuteInfo'
         alert:
           type: string
         alertType:

ee/query-service/app/api/featureFlags.go

@@ -89,6 +89,15 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 		Route:      "",
 	})
 
+	useDashboardV2 := ah.Signoz.Flagger.BooleanOrEmpty(ctx, flagger.FeatureUseDashboardV2, evalCtx)
+	featureSet = append(featureSet, &licensetypes.Feature{
+		Name:       valuer.NewString(flagger.FeatureUseDashboardV2.String()),
+		Active:     useDashboardV2,
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	})
+
 	if constants.IsDotMetricsEnabled {
 		for idx, feature := range featureSet {
 			if feature.Name == licensetypes.DotMetricsEnabled {

frontend/public/locales/en/channels.json

@@ -24,9 +24,12 @@
   "tooltip_opsgenie_api_key": "Learn how to obtain the API key from your OpsGenie account [here](https://support.atlassian.com/opsgenie/docs/integrate-opsgenie-with-prometheus/).",
   "tooltip_email_to": "Enter email addresses separated by commas.",
   "tooltip_ms_teams_url": "The URL of the Microsoft Teams [webhook](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498) to send alerts to. Learn more about Microsoft Teams integration in the docs [here](https://signoz.io/docs/alerts-management/notification-channel/ms-teams/).",
+  "tooltip_googlechat_url": "The URL of the Google Chat [incoming webhook](https://developers.google.com/workspace/chat/quickstart/webhooks) to send alerts to.",
   "field_slack_recipient": "Recipient",
   "field_slack_title": "Title",
   "field_slack_description": "Description",
+  "field_googlechat_title": "Title",
+  "field_googlechat_description": "Description",
   "field_opsgenie_api_key": "API Key",
   "field_opsgenie_description": "Description",
   "placeholder_opsgenie_description": "Description",
@@ -77,6 +80,7 @@
   "channel_test_failed": "Failed to send a test message to this channel, please confirm that the parameters are set correctly",
   "channel_test_unexpected": "An unexpected error occurred while sending a message to this channel, please try again",
   "webhook_url_required": "Webhook URL is mandatory",
+  "googlechat_webhook_url_required": "Google Chat webhook URL is mandatory",
   "slack_channel_help": "Specify channel or user, use #channel-name, @username (has to be all lowercase, no whitespace)",
   "api_key_required": "API Key is mandatory",
 	"to_required": "To field is mandatory",

frontend/src/api/channels/createGoogleChat.ts

@@ -0,0 +1,33 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/channels/createGoogleChat';
+
+const create = async (
+	props: Props,
+): Promise<SuccessResponseV2<PayloadProps>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/channels', {
+			name: props.name,
+			googlechat_configs: [
+				{
+					send_resolved: props.send_resolved,
+					webhook_url: props.webhook_url,
+					title: props.title,
+					text: props.text,
+				},
+			],
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+		throw error;
+	}
+};
+
+export default create;

frontend/src/api/channels/editGoogleChat.ts

@@ -0,0 +1,33 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/channels/editGoogleChat';
+
+const editGoogleChat = async (
+	props: Props,
+): Promise<SuccessResponseV2<PayloadProps>> => {
+	try {
+		const response = await axios.put<PayloadProps>(`/channels/${props.id}`, {
+			name: props.name,
+			googlechat_configs: [
+				{
+					send_resolved: props.send_resolved,
+					webhook_url: props.webhook_url,
+					title: props.title,
+					text: props.text,
+				},
+			],
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+		throw error;
+	}
+};
+
+export default editGoogleChat;

frontend/src/api/channels/testGoogleChat.ts

@@ -0,0 +1,33 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/channels/createGoogleChat';
+
+const testGoogleChat = async (
+	props: Props,
+): Promise<SuccessResponseV2<PayloadProps>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/testChannel', {
+			name: props.name,
+			googlechat_configs: [
+				{
+					send_resolved: true,
+					webhook_url: props.webhook_url,
+					title: props.title,
+					text: props.text,
+				},
+			],
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+		throw error;
+	}
+};
+
+export default testGoogleChat;

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

@@ -6082,31 +6082,6 @@ export interface RulestatehistorytypesGettableRuleStateWindowDTO {
 	state: RuletypesAlertStateDTO;
 }
 
-export interface RuletypesActiveMuteInfoDTO {
-	/**
-	 * @type string
-	 */
-	description?: string;
-	/**
-	 * @type string,null
-	 * @format date-time
-	 */
-	effectiveEndTime?: string | null;
-	/**
-	 * @type string,null
-	 * @format date-time
-	 */
-	effectiveStartTime?: string | null;
-	/**
-	 * @type string
-	 */
-	id?: string;
-	/**
-	 * @type string
-	 */
-	name?: string;
-}
-
 export enum RuletypesPanelTypeDTO {
 	value = 'value',
 	table = 'table',
@@ -6431,7 +6406,6 @@ export type RuletypesRuleDTOAnnotations = { [key: string]: string };
 export type RuletypesRuleDTOLabels = { [key: string]: string };
 
 export interface RuletypesRuleDTO {
-	activeMute?: RuletypesActiveMuteInfoDTO;
 	/**
 	 * @type string
 	 */

frontend/src/constants/app.ts

@@ -10,9 +10,6 @@ export const DEFAULT_AUTH0_APP_REDIRECTION_PATH = ROUTES.APPLICATION;
 
 export const INVITE_MEMBERS_HASH = '#invite-team-members';
 
-export const SIGNOZ_UPGRADE_PLAN_URL =
-	'https://upgrade.signoz.io/upgrade-from-app';
-
 export const DASHBOARD_TIME_IN_DURATION = 'refreshInterval';
 
 export const DEFAULT_ENTITY_VERSION = 'v3';

frontend/src/constants/features.ts

@@ -11,4 +11,5 @@ export enum FeatureKeys {
 	DOT_METRICS_ENABLED = 'dot_metrics_enabled',
 	USE_JSON_BODY = 'use_json_body',
 	USE_FINE_GRAINED_AUTHZ = 'use_fine_grained_authz',
+	USE_DASHBOARD_V2 = 'use_dashboard_v2',
 }

frontend/src/container/AllAlertChannels/__tests__/CreateAlertChannel.test.tsx

@@ -1,6 +1,8 @@
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
 import {
+	googleChatTextDefaultValue,
+	googleChatTitleDefaultValue,
 	opsGenieDescriptionDefaultValue,
 	opsGenieMessageDefaultValue,
 	opsGeniePriorityDefaultValue,
@@ -419,5 +421,47 @@ describe('Create Alert Channel', () => {
 				expect(descriptionTextArea).toHaveTextContent(slackDescriptionDefaultValue);
 			});
 		});
+		describe('Google Chat', () => {
+			beforeEach(() => {
+				render(<CreateAlertChannels preType={ChannelType.GoogleChat} />);
+			});
+
+			it('Should check if the selected item in the type dropdown has text "Google Chat"', () => {
+				expect(screen.getByText('Google Chat')).toBeInTheDocument();
+			});
+
+			it('Should check if Webhook URL label and input are displayed properly ', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_webhook_url',
+					testId: 'webhook-url-textbox',
+				});
+			});
+
+			it('Should check if Title label and text area are displayed properly ', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_googlechat_title',
+					testId: 'title-textarea',
+				});
+			});
+
+			it('Should check if Title contains template', () => {
+				const titleTextArea = screen.getByTestId('title-textarea');
+
+				expect(titleTextArea).toHaveTextContent(googleChatTitleDefaultValue);
+			});
+
+			it('Should check if Description label and text area are displayed properly ', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_googlechat_description',
+					testId: 'description-textarea',
+				});
+			});
+
+			it('Should check if Description contains template', () => {
+				const descriptionTextArea = screen.getByTestId('description-textarea');
+
+				expect(descriptionTextArea).toHaveTextContent(googleChatTextDefaultValue);
+			});
+		});
 	});
 });

frontend/src/container/AllAlertChannels/__tests__/CreateAlertChannelNormalUser.test.tsx

@@ -1,7 +1,8 @@
-import { SIGNOZ_UPGRADE_PLAN_URL } from 'constants/app';
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
 import {
+	googleChatTextDefaultValue,
+	googleChatTitleDefaultValue,
 	opsGenieDescriptionDefaultValue,
 	opsGenieMessageDefaultValue,
 	opsGeniePriorityDefaultValue,
@@ -313,16 +314,6 @@ describe('Create Alert Channel (Normal User)', () => {
 				expect(screen.getByText('Microsoft Teams')).toBeInTheDocument();
 			});
 
-			it.skip('Should check if the upgrade plan message is shown', () => {
-				expect(screen.getByText('Upgrade to a Paid Plan')).toBeInTheDocument();
-				expect(
-					screen.getByText(/This feature is available for paid plans only./),
-				).toBeInTheDocument();
-				const link = screen.getByRole('link', { name: 'Click here' });
-				expect(link).toBeInTheDocument();
-				expect(link).toHaveAttribute('href', SIGNOZ_UPGRADE_PLAN_URL);
-				expect(screen.getByText(/to Upgrade/)).toBeInTheDocument();
-			});
 			it('Should check if the form buttons are displayed properly (Save, Test, Back)', () => {
 				expect(
 					screen.getByRole('button', { name: 'button_save_channel' }),
@@ -343,5 +334,42 @@ describe('Create Alert Channel (Normal User)', () => {
 				).toBeDisabled();
 			});
 		});
+		describe('Google Chat', () => {
+			beforeEach(() => {
+				render(<CreateAlertChannels preType={ChannelType.GoogleChat} />);
+			});
+
+			it('Should check if the selected item in the type dropdown has text "Google Chat"', () => {
+				expect(screen.getByText('Google Chat')).toBeInTheDocument();
+			});
+			it('Should check if Webhook URL label and input are displayed properly', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_webhook_url',
+					testId: 'webhook-url-textbox',
+				});
+			});
+			it('Should check if Title label and text area are displayed properly', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_googlechat_title',
+					testId: 'title-textarea',
+				});
+			});
+			it('Should check if Title contains template', () => {
+				const titleTextArea = screen.getByTestId('title-textarea');
+
+				expect(titleTextArea).toHaveTextContent(googleChatTitleDefaultValue);
+			});
+			it('Should check if Description label and text area are displayed properly', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_googlechat_description',
+					testId: 'description-textarea',
+				});
+			});
+			it('Should check if Description contains template', () => {
+				const descriptionTextArea = screen.getByTestId('description-textarea');
+
+				expect(descriptionTextArea).toHaveTextContent(googleChatTextDefaultValue);
+			});
+		});
 	});
 });

frontend/src/container/CreateAlertChannels/config.ts

@@ -104,6 +104,7 @@ export enum ChannelType {
 	Pagerduty = 'pagerduty',
 	Opsgenie = 'opsgenie',
 	MsTeams = 'msteams',
+	GoogleChat = 'googlechat',
 }
 
 // LabelFilterStatement will be used for preparing filter conditions / matchers
@@ -125,3 +126,9 @@ export interface MsTeamsChannel extends Channel {
 	title?: string;
 	text?: string;
 }
+
+export interface GoogleChatChannel extends Channel {
+	webhook_url?: string;
+	title?: string;
+	text?: string;
+}

frontend/src/container/CreateAlertChannels/defaults.ts

@@ -1,16 +1,32 @@
-import { EmailChannel, OpsgenieChannel, PagerChannel } from './config';
+import {
+	EmailChannel,
+	GoogleChatChannel,
+	OpsgenieChannel,
+	PagerChannel,
+} from './config';
 
 export const PagerInitialConfig: Partial<PagerChannel> = {
-	description: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
-	{{- if gt (len .CommonLabels) (len .GroupLabels) -}}
-	  {{" "}}(
-	  {{- with .CommonLabels.Remove .GroupLabels.Names }}
-		{{- range $index, $label := .SortedPairs -}}
-		  {{ if $index }}, {{ end }}
-		  {{- $label.Name }}="{{ $label.Value -}}"
-		{{- end }}
-	  {{- end -}}
-	  )
+	description: `{{ if gt (len .Alerts.Firing) 0 -}}
+	Alerts Firing:
+	{{ range .Alerts.Firing }}
+	 - Message: {{ .Annotations.description }}
+	Labels:
+	{{ range .Labels.SortedPairs }}   - {{ .Name }} = {{ .Value }}
+	{{ end }}   Annotations:
+	{{ range .Annotations.SortedPairs }}   - {{ .Name }} = {{ .Value }}
+	{{ end }}   Source: {{ .GeneratorURL }}
+	{{ end }}
+	{{- end }}
+	{{ if gt (len .Alerts.Resolved) 0 -}}
+	Alerts Resolved:
+	{{ range .Alerts.Resolved }}
+	 - Message: {{ .Annotations.description }}
+	Labels:
+	{{ range .Labels.SortedPairs }}   - {{ .Name }} = {{ .Value }}
+	{{ end }}   Annotations:
+	{{ range .Annotations.SortedPairs }}   - {{ .Name }} = {{ .Value }}
+	{{ end }}   Source: {{ .GeneratorURL }}
+	{{ end }}
 	{{- end }}`,
 	severity: '{{ (index .Alerts 0).Labels.severity }}',
 	client: 'SigNoz Alert Manager',
@@ -446,3 +462,20 @@ export const EmailInitialConfig: Partial<EmailChannel> = {
 	</body>
   </html>`,
 };
+
+export const GoogleChatInitialConfig: Partial<GoogleChatChannel> = {
+	title: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`,
+	text: `{{ range .Alerts -}}
+*Alert:* {{ .Labels.alertname }}{{ if .Labels.severity }}
+*Severity:* {{ .Labels.severity }}{{ end }}{{ if .Annotations.summary }}
+*Summary:* {{ .Annotations.summary }}{{ end }}{{ if .Annotations.description }}
+*Description:* {{ .Annotations.description }}{{ end }}{{ if .Annotations.related_logs }}
+*Related Logs:* {{ .Annotations.related_logs }}{{ end }}{{ if .Annotations.related_traces }}
+*Related Traces:* {{ .Annotations.related_traces }}{{ end }}
+
+*Labels:*
+{{ range .Labels.SortedPairs -}}
+	• \`{{ .Name }}\`: {{ .Value }}
+{{ end }}
+{{ end }}`,
+};

frontend/src/container/CreateAlertChannels/index.tsx

@@ -2,12 +2,14 @@ import { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Form } from 'antd';
 import createEmail from 'api/channels/createEmail';
+import createGoogleChat from 'api/channels/createGoogleChat';
 import createMsTeamsApi from 'api/channels/createMsTeams';
 import createOpsgenie from 'api/channels/createOpsgenie';
 import createPagerApi from 'api/channels/createPager';
 import createSlackApi from 'api/channels/createSlack';
 import createWebhookApi from 'api/channels/createWebhook';
 import testEmail from 'api/channels/testEmail';
+import testGoogleChat from 'api/channels/testGoogleChat';
 import testMsTeamsApi from 'api/channels/testMsTeams';
 import testOpsGenie from 'api/channels/testOpsgenie';
 import testPagerApi from 'api/channels/testPager';
@@ -24,6 +26,7 @@ import APIError from 'types/api/error';
 import {
 	ChannelType,
 	EmailChannel,
+	GoogleChatChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -33,6 +36,7 @@ import {
 } from './config';
 import {
 	EmailInitialConfig,
+	GoogleChatInitialConfig,
 	OpsgenieInitialConfig,
 	PagerInitialConfig,
 } from './defaults';
@@ -59,6 +63,7 @@ function CreateAlertChannels({
 				WebhookChannel &
 				PagerChannel &
 				MsTeamsChannel &
+				GoogleChatChannel &
 				OpsgenieChannel &
 				EmailChannel
 		>
@@ -121,6 +126,14 @@ function CreateAlertChannels({
 					...EmailInitialConfig,
 				}));
 			}
+
+			// reset config to Google Chat defaults
+			if (value === ChannelType.GoogleChat && currentType !== value) {
+				setSelectedConfig((selectedConfig) => ({
+					...selectedConfig,
+					...GoogleChatInitialConfig,
+				}));
+			}
 		},
 		[type, selectedConfig],
 	);
@@ -406,7 +419,49 @@ function CreateAlertChannels({
 		prepareMsTeamsRequest,
 		showErrorModal,
 	]);
+	const prepareGoogleChatRequest = useCallback(
+		() => ({
+			webhook_url: selectedConfig?.webhook_url || '',
+			name: selectedConfig?.name || '',
+			send_resolved: selectedConfig?.send_resolved || false,
+			text: selectedConfig?.text || '',
+			title: selectedConfig?.title || '',
+		}),
+		[selectedConfig],
+	);
 
+	const onGoogleChatHandler = useCallback(async () => {
+		if (!selectedConfig.webhook_url) {
+			notifications.error({
+				message: 'Error',
+				description: t('googlechat_webhook_url_required'),
+			});
+			return;
+		}
+
+		setSavingState(true);
+
+		try {
+			await createGoogleChat(prepareGoogleChatRequest());
+			notifications.success({
+				message: 'Success',
+				description: t('channel_creation_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_creation_done') };
+		} catch (error) {
+			showErrorModal(error as APIError);
+			return { status: 'failed', statusMessage: t('channel_creation_failed') };
+		} finally {
+			setSavingState(false);
+		}
+	}, [
+		selectedConfig.webhook_url,
+		notifications,
+		t,
+		prepareGoogleChatRequest,
+		showErrorModal,
+	]);
 	const onSaveHandler = useCallback(
 		async (value: ChannelType) => {
 			if (!selectedConfig.name) {
@@ -424,6 +479,7 @@ function CreateAlertChannels({
 				[ChannelType.Opsgenie]: onOpsgenieHandler,
 				[ChannelType.MsTeams]: onMsTeamsHandler,
 				[ChannelType.Email]: onEmailHandler,
+				[ChannelType.GoogleChat]: onGoogleChatHandler,
 			};
 
 			if (isChannelType(value)) {
@@ -455,6 +511,7 @@ function CreateAlertChannels({
 			onOpsgenieHandler,
 			onMsTeamsHandler,
 			onEmailHandler,
+			onGoogleChatHandler,
 			notifications,
 			t,
 		],
@@ -492,6 +549,10 @@ function CreateAlertChannels({
 						request = prepareEmailRequest();
 						await testEmail(request);
 						break;
+					case ChannelType.GoogleChat:
+						request = prepareGoogleChatRequest();
+						await testGoogleChat(request);
+						break;
 					default:
 						notifications.error({
 							message: 'Error',
@@ -534,6 +595,7 @@ function CreateAlertChannels({
 			prepareOpsgenieRequest,
 			prepareSlackRequest,
 			prepareMsTeamsRequest,
+			prepareGoogleChatRequest,
 			prepareEmailRequest,
 			notifications,
 		],
@@ -546,6 +608,23 @@ function CreateAlertChannels({
 		[performChannelTest],
 	);
 
+	const getInitialConfigForType = (): Partial<
+		PagerChannel & OpsgenieChannel & EmailChannel & GoogleChatChannel
+	> => {
+		switch (type) {
+			case ChannelType.Pagerduty:
+				return PagerInitialConfig;
+			case ChannelType.Opsgenie:
+				return OpsgenieInitialConfig;
+			case ChannelType.Email:
+				return EmailInitialConfig;
+			case ChannelType.GoogleChat:
+				return GoogleChatInitialConfig;
+			default:
+				return {};
+		}
+	};
+
 	return (
 		<div className="create-alert-channels-container">
 			<FormAlertChannels
@@ -562,9 +641,7 @@ function CreateAlertChannels({
 					initialValue: {
 						type,
 						...selectedConfig,
-						...PagerInitialConfig,
-						...OpsgenieInitialConfig,
-						...EmailInitialConfig,
+						...getInitialConfigForType(),
 					},
 				}}
 			/>

frontend/src/container/EditAlertChannels/index.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Form } from 'antd';
+import editGoogleChat from 'api/channels/editGoogleChat';
 import editEmail from 'api/channels/editEmail';
 import editMsTeamsApi from 'api/channels/editMsTeams';
 import editOpsgenie from 'api/channels/editOpsgenie';
@@ -8,6 +9,7 @@ import editPagerApi from 'api/channels/editPager';
 import editSlackApi from 'api/channels/editSlack';
 import editWebhookApi from 'api/channels/editWebhook';
 import testEmail from 'api/channels/testEmail';
+import testGoogleChat from 'api/channels/testGoogleChat';
 import testMsTeamsApi from 'api/channels/testMsTeams';
 import testOpsgenie from 'api/channels/testOpsgenie';
 import testPagerApi from 'api/channels/testPager';
@@ -18,6 +20,7 @@ import ROUTES from 'constants/routes';
 import {
 	ChannelType,
 	EmailChannel,
+	GoogleChatChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -43,6 +46,7 @@ function EditAlertChannels({
 				WebhookChannel &
 				PagerChannel &
 				MsTeamsChannel &
+				GoogleChatChannel &
 				OpsgenieChannel &
 				EmailChannel
 		>
@@ -333,6 +337,56 @@ function EditAlertChannels({
 		[id, selectedConfig],
 	);
 
+	const prepareGoogleChatRequest = useCallback(
+		() => ({
+			webhook_url: selectedConfig?.webhook_url || '',
+			name: selectedConfig?.name || '',
+			send_resolved: selectedConfig?.send_resolved || false,
+			text: selectedConfig?.text || '',
+			title: selectedConfig?.title || '',
+			id,
+		}),
+		[id, selectedConfig],
+	);
+
+	const onGoogleChatEditHandler = useCallback(async () => {
+		setSavingState(true);
+
+		if (selectedConfig?.webhook_url === '') {
+			notifications.error({
+				message: 'Error',
+				description: t('googlechat_webhook_url_required'),
+			});
+			setSavingState(false);
+			return {
+				status: 'failed',
+				statusMessage: t('googlechat_webhook_url_required'),
+			};
+		}
+
+		try {
+			await editGoogleChat(prepareGoogleChatRequest());
+			notifications.success({
+				message: 'Success',
+				description: t('channel_edit_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_edit_done') };
+		} catch (error) {
+			notifications.error({
+				message: (error as APIError).getErrorCode(),
+				description: (error as APIError).getErrorMessage(),
+			});
+			return {
+				status: 'failed',
+				statusMessage:
+					(error as APIError).getErrorMessage() || t('channel_edit_failed'),
+			};
+		} finally {
+			setSavingState(false);
+		}
+	}, [prepareGoogleChatRequest, notifications, selectedConfig, t]);
+
 	const onMsTeamsEditHandler = useCallback(async () => {
 		setSavingState(true);
 
@@ -383,6 +437,8 @@ function EditAlertChannels({
 				result = await onOpsgenieEditHandler();
 			} else if (value === ChannelType.Email) {
 				result = await onEmailEditHandler();
+			} else if (value === ChannelType.GoogleChat) {
+				result = await onGoogleChatEditHandler();
 			}
 			logEvent('Alert Channel: Save channel', {
 				type: value,
@@ -401,6 +457,7 @@ function EditAlertChannels({
 			onMsTeamsEditHandler,
 			onOpsgenieEditHandler,
 			onEmailEditHandler,
+			onGoogleChatEditHandler,
 		],
 	);
 
@@ -442,6 +499,12 @@ function EditAlertChannels({
 							await testEmail(request);
 						}
 						break;
+					case ChannelType.GoogleChat:
+						request = prepareGoogleChatRequest();
+						if (request) {
+							await testGoogleChat(request);
+						}
+						break;
 					default:
 						notifications.error({
 							message: 'Error',
@@ -484,6 +547,7 @@ function EditAlertChannels({
 			preparePagerRequest,
 			prepareSlackRequest,
 			prepareMsTeamsRequest,
+			prepareGoogleChatRequest,
 			prepareOpsgenieRequest,
 			prepareEmailRequest,
 			notifications,

frontend/src/container/FormAlertChannels/Settings/GoogleChat.tsx

@@ -0,0 +1,76 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Form, Input } from 'antd';
+import { MarkdownRenderer } from 'components/MarkdownRenderer/MarkdownRenderer';
+
+import { GoogleChatChannel } from '../../CreateAlertChannels/config';
+
+function GoogleChat({ setSelectedConfig }: GoogleChatProps): JSX.Element {
+	const { t } = useTranslation('channels');
+
+	return (
+		<>
+			<Form.Item
+				name="webhook_url"
+				label={t('field_webhook_url')}
+				tooltip={{
+					title: (
+						<MarkdownRenderer
+							markdownContent={t('tooltip_googlechat_url')}
+							variables={{}}
+						/>
+					),
+					overlayInnerStyle: { maxWidth: 400 },
+					placement: 'right',
+				}}
+			>
+				<Input
+					onChange={(event): void => {
+						setSelectedConfig((value) => ({
+							...value,
+							webhook_url: event.target.value,
+						}));
+					}}
+					data-testid="webhook-url-textbox"
+					placeholder="https://chat.googleapis.com/v1/spaces/..."
+				/>
+			</Form.Item>
+
+			<Form.Item name="title" label={t('field_googlechat_title')}>
+				<Input.TextArea
+					rows={2}
+					onChange={(event): void =>
+						setSelectedConfig((value) => ({
+							...value,
+							title: event.target.value,
+						}))
+					}
+					data-testid="title-textarea"
+					placeholder={`[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`}
+				/>
+			</Form.Item>
+
+			<Form.Item name="text" label={t('field_googlechat_description')}>
+				<Input.TextArea
+					rows={4}
+					onChange={(event): void =>
+						setSelectedConfig((value) => ({
+							...value,
+							text: event.target.value,
+						}))
+					}
+					data-testid="description-textarea"
+					placeholder={t('placeholder_slack_description')}
+				/>
+			</Form.Item>
+		</>
+	);
+}
+
+interface GoogleChatProps {
+	setSelectedConfig: React.Dispatch<
+		React.SetStateAction<Partial<GoogleChatChannel>>
+	>;
+}
+
+export default GoogleChat;

frontend/src/container/FormAlertChannels/index.tsx

@@ -8,6 +8,7 @@ import ROUTES from 'constants/routes';
 import {
 	ChannelType,
 	EmailChannel,
+	GoogleChatChannel,
 	OpsgenieChannel,
 	PagerChannel,
 	SlackChannel,
@@ -16,6 +17,7 @@ import {
 import history from 'lib/history';
 
 import EmailSettings from './Settings/Email';
+import GoogleChatSettings from './Settings/GoogleChat';
 import MsTeamsSettings from './Settings/MsTeams';
 import OpsgenieSettings from './Settings/Opsgenie';
 import PagerSettings from './Settings/Pager';
@@ -52,6 +54,8 @@ function FormAlertChannels({
 				return <OpsgenieSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.Email:
 				return <EmailSettings setSelectedConfig={setSelectedConfig} />;
+			case ChannelType.GoogleChat:
+				return <GoogleChatSettings setSelectedConfig={setSelectedConfig} />;
 			default:
 				return null;
 		}
@@ -128,6 +132,13 @@ function FormAlertChannels({
 						<Select.Option value="msteams" key="msteams" data-testid="select-option">
 							Microsoft Teams
 						</Select.Option>
+						<Select.Option
+							value="googlechat"
+							key="googlechat"
+							data-testid="select-option"
+						>
+							Google Chat
+						</Select.Option>
 					</Select>
 				</Form.Item>
 
@@ -172,6 +183,7 @@ interface FormAlertChannelsProps {
 					WebhookChannel &
 					PagerChannel &
 					OpsgenieChannel &
+					GoogleChatChannel &
 					EmailChannel
 			>
 		>

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -43,7 +43,6 @@ import { isModifierKeyPressed } from 'utils/app';
 
 import DeleteAlert from './DeleteAlert';
 import { ColumnButton, SearchContainer } from './styles';
-import MutedBadge from './TableComponents/MutedBadge';
 import Status from './TableComponents/Status';
 import ToggleAlertState from './ToggleAlertState';
 import { alertActionLogEvent, filterAlerts } from './utils';
@@ -277,14 +276,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 					onEditHandler(record, { newTab: isModifierKeyPressed(e) });
 				};
 
-				const muteEndTime = record.activeMute?.effectiveEndTime ?? undefined;
-
-				return (
-					<span className="alert-list-name-cell">
-						<Typography.Link onClick={onClickHandler}>{value}</Typography.Link>
-						<MutedBadge muteEndTime={muteEndTime} />
-					</span>
-				);
+				return <Typography.Link onClick={onClickHandler}>{value}</Typography.Link>;
 			},
 			sortOrder: sortedInfo.columnKey === 'name' ? sortedInfo.order : null,
 		},

frontend/src/container/ListAlertRules/TableComponents/MutedBadge.styles.scss

@@ -1,20 +0,0 @@
-.alert-list-name-cell {
-	display: inline-flex;
-	align-items: center;
-	gap: 8px;
-}
-
-.alert-list-muted-badge {
-	display: inline-flex;
-	align-items: center;
-	gap: 4px;
-	padding: 2px 7px;
-	font-size: 11px;
-	font-weight: 600;
-	letter-spacing: 0.04em;
-	text-transform: uppercase;
-	color: var(--bg-amber-500);
-	background: rgba(255, 205, 86, 0.12);
-	border: 1px solid rgba(255, 205, 86, 0.25);
-	border-radius: 4px;
-}

frontend/src/container/ListAlertRules/TableComponents/MutedBadge.tsx

@@ -1,46 +0,0 @@
-import { BellOff } from '@signozhq/icons';
-import dayjs from 'dayjs';
-
-import './MutedBadge.styles.scss';
-
-const formatRemaining = (endTime: string | undefined): string | null => {
-	if (!endTime) {
-		return null;
-	}
-	const end = dayjs(endTime);
-	const now = dayjs();
-	const diffMs = end.diff(now);
-	if (diffMs <= 0) {
-		return null;
-	}
-	const totalMinutes = Math.floor(diffMs / 60000);
-	const days = Math.floor(totalMinutes / (60 * 24));
-	const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
-	const minutes = totalMinutes % 60;
-	if (days > 0) {
-		return `${days}d ${hours}h`;
-	}
-	if (hours > 0) {
-		return `${hours}h ${minutes}m`;
-	}
-	return `${minutes}m`;
-};
-
-interface MutedBadgeProps {
-	muteEndTime?: string;
-}
-
-function MutedBadge({ muteEndTime }: MutedBadgeProps): JSX.Element | null {
-	if (!muteEndTime) {
-		return null;
-	}
-	const remaining = formatRemaining(muteEndTime);
-	return (
-		<span className="alert-list-muted-badge">
-			<BellOff size={10} />
-			<span>MUTED{remaining ? ` · ${remaining}` : ''}</span>
-		</span>
-	);
-}
-
-export default MutedBadge;

frontend/src/container/PlannedDowntime/PlannedDowntime.styles.scss

@@ -81,6 +81,20 @@
 		}
 	}
 
+	.alert-rule-scope {
+		margin-bottom: 12px;
+
+		.ant-radio-wrapper {
+			color: var(--l1-foreground);
+		}
+	}
+
+	.alert-rule-all-warning {
+		font-size: 12px;
+		font-weight: 400;
+		color: var(--l2-foreground);
+	}
+
 	.formItemWithBullet {
 		margin-bottom: 0;
 	}

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -8,6 +8,7 @@ import {
 	FormInstance,
 	Input,
 	Modal,
+	Radio,
 	Select,
 	SelectProps,
 	Spin,
@@ -71,11 +72,14 @@ const TZ_OPTIONS: DefaultOptionType[] = ALL_TIME_ZONES.map(
 	}),
 );
 
+type AlertRuleScope = 'all' | 'specific';
+
 interface PlannedDowntimeFormData {
 	name: string;
 	startTime: dayjs.Dayjs | null;
 	endTime: dayjs.Dayjs | null;
 	recurrence?: AlertmanagertypesRecurrenceDTO;
+	alertRuleScope: AlertRuleScope;
 	alertRules: DefaultOptionType[];
 	recurrenceSelect?: AlertmanagertypesRecurrenceDTO;
 	timezone?: string;
@@ -129,6 +133,12 @@ export function PlannedDowntimeForm(
 			recurrenceOptions.doesNotRepeat.value,
 	);
 
+	const [alertRuleScope, setAlertRuleScope] = useState<AlertRuleScope>(
+		initialValues.id && (initialValues.alertIds || []).length === 0
+			? 'all'
+			: 'specific',
+	);
+
 	const { notifications } = useNotifications();
 	const { showErrorModal } = useErrorModal();
 
@@ -142,9 +152,12 @@ export function PlannedDowntimeForm(
 	const saveHandler = useCallback(
 		async (values: PlannedDowntimeFormData) => {
 			const data: AlertmanagertypesPostablePlannedMaintenanceDTO = {
-				alertIds: values.alertRules
-					.map((alert) => alert.value)
-					.filter((alert) => alert !== undefined) as string[],
+				alertIds:
+					values.alertRuleScope === 'all'
+						? []
+						: (values.alertRules
+								.map((alert) => alert.value)
+								.filter((alert) => alert !== undefined) as string[]),
 				name: values.name,
 				scope: values.scope,
 				schedule: {
@@ -265,12 +278,13 @@ export function PlannedDowntimeForm(
 		const startTime = schedule?.recurrence?.startTime || schedule?.startTime;
 		const endTime = schedule?.recurrence?.endTime || schedule?.endTime;
 
+		const initialAlertIds = initialValues.alertIds || [];
+
 		return {
 			name: defaultTo(initialValues.name, ''),
-			alertRules: getAlertOptionsFromIds(
-				initialValues.alertIds || [],
-				alertOptions,
-			),
+			alertRuleScope:
+				isEditMode && initialAlertIds.length === 0 ? 'all' : 'specific',
+			alertRules: getAlertOptionsFromIds(initialAlertIds, alertOptions),
 			startTime: startTime ? dayjs(startTime).tz(schedule.timezone) : null,
 			endTime: endTime ? dayjs(endTime).tz(schedule.timezone) : null,
 			recurrence: {
@@ -287,6 +301,7 @@ export function PlannedDowntimeForm(
 
 	useEffect(() => {
 		setSelectedTags(formattedInitialValues.alertRules);
+		setAlertRuleScope(formattedInitialValues.alertRuleScope);
 		form.setFieldsValue({ ...formattedInitialValues });
 	}, [form, formattedInitialValues, initialValues]);
 
@@ -349,6 +364,7 @@ export function PlannedDowntimeForm(
 				onFinish={onFinish}
 				onValuesChange={(): void => {
 					setRecurrenceType(form.getFieldValue('recurrence')?.repeatType as string);
+					setAlertRuleScope(form.getFieldValue('alertRuleScope') as AlertRuleScope);
 					handleFormData(form.getFieldsValue());
 				}}
 				autoComplete="off"
@@ -448,49 +464,76 @@ export function PlannedDowntimeForm(
 					<div className="scheduleTimeInfoText">{endTimeText}</div>
 				)}
 				<div>
-					<div className="alert-rule-form">
-						<Typography style={{ marginBottom: 8 }}>Silence Alerts</Typography>
-						<Typography style={{ marginBottom: 8 }} className="alert-rule-info">
-							(Leave empty to silence all alerts)
-						</Typography>
-					</div>
-					<Form.Item noStyle shouldUpdate>
-						<AlertRuleTags
-							closable
-							selectedTags={selectedTags}
-							handleClose={handleClose}
-						/>
-					</Form.Item>
-					<Form.Item name={alertRuleFormName}>
-						<Select
-							placeholder="Search for alerts rules or groups..."
-							mode="multiple"
-							status={isError ? 'error' : undefined}
-							loading={isLoading}
-							tagRender={noTagRenderer}
-							onChange={handleAlertRulesChange}
-							showSearch
-							options={alertOptions}
-							filterOption={(input, option): boolean =>
-								(option?.label as string)?.toLowerCase()?.includes(input.toLowerCase())
-							}
-							notFoundContent={
-								isLoading ? (
-									<span>
-										<Spin size="small" /> Loading...
-									</span>
-								) : (
-									<span>No alert available.</span>
-								)
-							}
-						>
-							{alertOptions?.map((option) => (
-								<Select.Option key={option.value} value={option.value}>
-									{option.label}
-								</Select.Option>
-							))}
-						</Select>
+					<Typography style={{ marginBottom: 8 }}>Silence Alerts</Typography>
+					<Form.Item
+						name="alertRuleScope"
+						initialValue="specific"
+						className="alert-rule-scope"
+					>
+						<Radio.Group>
+							<Radio value="all">All alert rules</Radio>
+							<Radio value="specific">Specific alert rules</Radio>
+						</Radio.Group>
 					</Form.Item>
+					{alertRuleScope === 'specific' && (
+						<>
+							<Form.Item noStyle shouldUpdate>
+								<AlertRuleTags
+									closable
+									selectedTags={selectedTags}
+									handleClose={handleClose}
+								/>
+							</Form.Item>
+							<Form.Item
+								name={alertRuleFormName}
+								rules={[
+									{
+										validator: async (
+											_rule,
+											value: DefaultOptionType[] | undefined,
+										): Promise<void> => {
+											if (!value || value.length === 0) {
+												throw new Error(
+													'Select at least one alert rule, or choose "All alert rules" to silence everything.',
+												);
+											}
+										},
+									},
+								]}
+							>
+								<Select
+									placeholder="Search for alert rules or groups..."
+									mode="multiple"
+									status={isError ? 'error' : undefined}
+									loading={isLoading}
+									tagRender={noTagRenderer}
+									onChange={handleAlertRulesChange}
+									showSearch
+									options={alertOptions}
+									filterOption={(input, option): boolean =>
+										(option?.label as string)
+											?.toLowerCase()
+											?.includes(input.toLowerCase())
+									}
+									notFoundContent={
+										isLoading ? (
+											<span>
+												<Spin size="small" /> Loading...
+											</span>
+										) : (
+											<span>No alert available.</span>
+										)
+									}
+								>
+									{alertOptions?.map((option) => (
+										<Select.Option key={option.value} value={option.value}>
+											{option.label}
+										</Select.Option>
+									))}
+								</Select>
+							</Form.Item>
+						</>
+					)}
 				</div>
 				<Form.Item
 					label={

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -204,7 +204,7 @@ export function CollapseListContent({
 						selectedTags={alertOptions}
 					/>
 				) : (
-					'-'
+					<Tag className="all-alerts-tag">All alert rules</Tag>
 				),
 			)}
 		</Flex>

frontend/src/mocks-server/__mockdata__/alerts.ts

@@ -47,3 +47,7 @@ export const opsGeniePriorityDefaultValue =
 
 export const pagerDutySeverityTextDefaultValue =
 	'{{ (index .Alerts 0).Labels.severity }}';
+
+export const googleChatTitleDefaultValue = `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`;
+
+export const googleChatTextDefaultValue = `{{ range .Alerts -}} *Alert:* {{ .Labels.alertname }}{{ if .Labels.severity }} *Severity:* {{ .Labels.severity }}{{ end }}{{ if .Annotations.summary }} *Summary:* {{ .Annotations.summary }}{{ end }}{{ if .Annotations.description }} *Description:* {{ .Annotations.description }}{{ end }}{{ if .Annotations.related_logs }} *Related Logs:* {{ .Annotations.related_logs }}{{ end }}{{ if .Annotations.related_traces }} *Related Traces:* {{ .Annotations.related_traces }}{{ end }} *Labels:* {{ range .Labels.SortedPairs -}} • \`{{ .Name }}\`: {{ .Value }} {{ end }} {{ end }}`;

frontend/src/pages/AlertDetails/AlertHeader/ActionButtons/ActionButtons.styles.scss

@@ -12,20 +12,6 @@
 		margin-right: 4px;
 	}
 }
-
-.alert-state-segmented-wrapper {
-	position: relative;
-	display: inline-flex;
-}
-
-.alert-state-segmented-anchor {
-	position: absolute;
-	right: 0;
-	bottom: 0;
-	width: 0;
-	height: 0;
-	pointer-events: none;
-}
 .dropdown-menu {
 	border-radius: 4px;
 	box-shadow: none;

frontend/src/pages/AlertDetails/AlertHeader/ActionButtons/ActionButtons.tsx

@@ -1,6 +1,7 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { Color } from '@signozhq/design-tokens';
 import { Divider, Dropdown, MenuProps, Tooltip } from 'antd';
+import { Switch } from '@signozhq/ui/switch';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { Copy, Ellipsis, PenLine, Trash2 } from '@signozhq/icons';
 import {
@@ -16,13 +17,6 @@ import { NEW_ALERT_SCHEMA_VERSION } from 'types/api/alerts/alertTypesV2';
 import { AlertDef } from 'types/api/alerts/def';
 
 import { AlertHeaderProps } from '../AlertHeader';
-import AlertStateSegmented, {
-	AlertSegmentedState,
-} from '../MuteAlert/AlertStateSegmented';
-import MutePopover from '../MuteAlert/MutePopover';
-import MuteSchedulerDrawer from '../MuteAlert/MuteSchedulerDrawer';
-import { useActiveMute } from '../MuteAlert/useActiveMute';
-import { useMuteAlertRule } from '../MuteAlert/useMuteAlertRule';
 import RenameModal from './RenameModal';
 
 import './ActionButtons.styles.scss';
@@ -129,77 +123,19 @@ function AlertActionButtons({
 	// eslint-disable-next-line react-hooks/exhaustive-deps
 	useEffect(() => (): void => setAlertRuleState(undefined), []);
 
-	const { activeMute, refetch: refetchActiveMute } = useActiveMute(ruleId);
-
-	const segmentedState: AlertSegmentedState = useMemo(() => {
-		if (isAlertRuleDisabled) {
-			return 'disabled';
-		}
-		if (activeMute) {
-			return 'muted';
-		}
-		return 'active';
-	}, [isAlertRuleDisabled, activeMute]);
-
-	const [isMutePopoverOpen, setIsMutePopoverOpen] = useState<boolean>(false);
-	const [isMuteDrawerOpen, setIsMuteDrawerOpen] = useState<boolean>(false);
-
-	const { mute, isLoading: isMuting } = useMuteAlertRule({
-		ruleId,
-		onSuccess: () => {
-			setIsMutePopoverOpen(false);
-			setIsMuteDrawerOpen(false);
-			refetchActiveMute();
-		},
-	});
-
-	const handleActiveClick = useCallback(() => {
-		// If currently disabled, re-enable. Otherwise (already active) no-op.
-		// When muted, the segmented control disables this button.
-		if (isAlertRuleDisabled) {
-			setIsAlertRuleDisabled(false);
-			handleAlertStateToggle();
-		}
-	}, [isAlertRuleDisabled, handleAlertStateToggle]);
-
-	const handleMuteClick = useCallback(() => {
-		if (segmentedState === 'active') {
-			setIsMutePopoverOpen(true);
-		}
-	}, [segmentedState]);
-
-	const handleDisableClick = useCallback(() => {
-		if (!isAlertRuleDisabled) {
-			setIsAlertRuleDisabled(true);
-			handleAlertStateToggle();
-		}
-	}, [isAlertRuleDisabled, handleAlertStateToggle]);
-
-	const ruleDisplayName = alertRuleName ?? alertDetails.alert;
+	const toggleAlertRule = useCallback(() => {
+		setIsAlertRuleDisabled((prev) => !prev);
+		handleAlertStateToggle();
+	}, [handleAlertStateToggle]);
 
 	return (
 		<>
 			<div className="alert-action-buttons">
-				{isAlertRuleDisabled !== undefined && (
-					<div className="alert-state-segmented-wrapper">
-						<AlertStateSegmented
-							state={segmentedState}
-							onActive={handleActiveClick}
-							onMute={handleMuteClick}
-							onDisable={handleDisableClick}
-						/>
-						<MutePopover
-							open={isMutePopoverOpen}
-							onOpenChange={setIsMutePopoverOpen}
-							ruleName={ruleDisplayName}
-							isLoading={isMuting}
-							onSubmit={mute}
-							onOpenCustomWindow={(): void => setIsMuteDrawerOpen(true)}
-							anchor={<span className="alert-state-segmented-anchor" />}
-						/>
-					</div>
-				)}
-
+				<Tooltip title={isAlertRuleDisabled ? 'Enable alert' : 'Disable alert'}>
+					{isAlertRuleDisabled !== undefined && (
+						<Switch onChange={toggleAlertRule} value={!isAlertRuleDisabled} />
+					)}
+				</Tooltip>
 				<CopyToClipboard textToCopy={window.location.href} />
 
 				<Divider type="vertical" />
@@ -216,14 +152,6 @@ function AlertActionButtons({
 				</Dropdown>
 			</div>
 
-			<MuteSchedulerDrawer
-				open={isMuteDrawerOpen}
-				onClose={(): void => setIsMuteDrawerOpen(false)}
-				ruleName={ruleDisplayName}
-				isLoading={isMuting}
-				onSubmit={mute}
-			/>
-
 			<RenameModal
 				isOpen={isRenameAlertOpen}
 				setIsOpen={setIsRenameAlertOpen}

frontend/src/pages/AlertDetails/AlertHeader/AlertHeader.styles.scss

@@ -1,13 +1,3 @@
-.alert-info-wrapper {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-}
-
-.alert-info__banner {
-	padding: 0 16px;
-}
-
 .alert-info {
 	display: flex;
 	justify-content: space-between;

frontend/src/pages/AlertDetails/AlertHeader/AlertHeader.tsx

@@ -12,9 +12,6 @@ import AlertActionButtons from './ActionButtons/ActionButtons';
 import AlertLabels from './AlertLabels/AlertLabels';
 import AlertSeverity from './AlertSeverity/AlertSeverity';
 import AlertState from './AlertState/AlertState';
-import DisabledBanner from './MuteAlert/DisabledBanner';
-import MutedBanner from './MuteAlert/MutedBanner';
-import { useActiveMute } from './MuteAlert/useActiveMute';
 
 import './AlertHeader.styles.scss';
 
@@ -46,13 +43,6 @@ function AlertHeader({ alertDetails }: AlertHeaderProps): JSX.Element {
 
 	const isV2Alert = alertDetails.schemaVersion === NEW_ALERT_SCHEMA_VERSION;
 
-	const ruleId = alertDetails?.id || '';
-	const { activeMute } = useActiveMute(ruleId);
-	const effectiveState = alertRuleState ?? state ?? '';
-	const isDisabled = effectiveState === 'disabled';
-	const showMutedBanner = !isDisabled && Boolean(activeMute);
-	const showDisabledBanner = isDisabled;
-
 	const CreateAlertV1Header = (
 		<div className="alert-info__info-wrapper">
 			<div className="top-section">
@@ -77,23 +67,14 @@ function AlertHeader({ alertDetails }: AlertHeaderProps): JSX.Element {
 	);
 
 	return (
-		<div className="alert-info-wrapper">
-			<div className="alert-info">
-				{isV2Alert ? <CreateAlertV2Header /> : CreateAlertV1Header}
-				<div className="alert-info__action-buttons">
-					<AlertActionButtons alertDetails={alertDetails} ruleId={ruleId} />
-				</div>
+		<div className="alert-info">
+			{isV2Alert ? <CreateAlertV2Header /> : CreateAlertV1Header}
+			<div className="alert-info__action-buttons">
+				<AlertActionButtons
+					alertDetails={alertDetails}
+					ruleId={alertDetails?.id || ''}
+				/>
 			</div>
-			{showMutedBanner && activeMute && (
-				<div className="alert-info__banner">
-					<MutedBanner activeMute={activeMute} />
-				</div>
-			)}
-			{showDisabledBanner && (
-				<div className="alert-info__banner">
-					<DisabledBanner rule={alertDetails as RuletypesRuleDTO} />
-				</div>
-			)}
 		</div>
 	);
 }

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/AlertStateSegmented.styles.scss

@@ -1,102 +0,0 @@
-.alert-state-segmented {
-	display: inline-flex;
-	align-items: center;
-	gap: 2px;
-	padding: 3px;
-	background: var(--bg-ink-300);
-	border: 1px solid var(--bg-slate-300);
-	border-radius: 999px;
-
-	&__pill {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		padding: 5px 12px;
-		font-size: 12px;
-		font-weight: 500;
-		line-height: 1;
-		color: var(--bg-vanilla-400);
-		background: transparent;
-		border: 0;
-		border-radius: 999px;
-		cursor: pointer;
-		transition:
-			background 140ms,
-			color 140ms;
-
-		&:hover:not(:disabled) {
-			color: var(--bg-vanilla-100);
-			background: var(--bg-ink-200);
-		}
-
-		&:disabled {
-			cursor: not-allowed;
-		}
-
-		&:focus-visible {
-			outline: 2px solid var(--bg-robin-500);
-			outline-offset: 2px;
-		}
-
-		&--active-active {
-			background: var(--bg-robin-500);
-			color: var(--bg-vanilla-100);
-
-			&:hover:not(:disabled) {
-				background: var(--bg-robin-600);
-				color: var(--bg-vanilla-100);
-			}
-		}
-
-		&.alert-state-segmented__pill--active-muted {
-			background: var(--bg-amber-500);
-			color: #1a1407;
-
-			.alert-state-segmented__icon,
-			.alert-state-segmented__label {
-				color: #1a1407;
-			}
-
-			&:hover:not(:disabled) {
-				background: var(--bg-amber-600);
-			}
-		}
-
-		&--active-disabled {
-			background: var(--bg-slate-100);
-			color: var(--bg-vanilla-100);
-
-			&:hover:not(:disabled) {
-				background: var(--bg-slate-200);
-				color: var(--bg-vanilla-100);
-			}
-		}
-	}
-
-	&__dot {
-		width: 6px;
-		height: 6px;
-		background: var(--bg-vanilla-100);
-		border-radius: 999px;
-	}
-
-	&__icon {
-		flex-shrink: 0;
-	}
-}
-
-.lightMode {
-	.alert-state-segmented {
-		background: var(--bg-vanilla-200);
-		border-color: var(--bg-slate-500);
-
-		&__pill {
-			color: var(--bg-ink-300);
-
-			&:hover:not(:disabled) {
-				color: var(--bg-ink-500);
-				background: var(--bg-vanilla-300);
-			}
-		}
-	}
-}

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/AlertStateSegmented.tsx

@@ -1,86 +0,0 @@
-import { forwardRef } from 'react';
-import { BellOff } from '@signozhq/icons';
-import classNames from 'classnames';
-
-import './AlertStateSegmented.styles.scss';
-
-export type AlertSegmentedState = 'active' | 'muted' | 'disabled';
-
-export interface AlertStateSegmentedProps {
-	state: AlertSegmentedState;
-	onActive: () => void;
-	onMute: () => void;
-	onDisable: () => void;
-	disabled?: boolean;
-}
-
-const AlertStateSegmented = forwardRef<
-	HTMLDivElement,
-	AlertStateSegmentedProps
->(function AlertStateSegmented(props, ref): JSX.Element {
-	const { state, onActive, onMute, onDisable, disabled } = props;
-
-	const isMuted = state === 'muted';
-	const isDisabled = state === 'disabled';
-
-	return (
-		<div
-			className="alert-state-segmented"
-			role="tablist"
-			aria-label="Alert rule state"
-			ref={ref}
-		>
-			<button
-				type="button"
-				role="tab"
-				aria-selected={state === 'active'}
-				aria-label="Active"
-				className={classNames('alert-state-segmented__pill', {
-					'alert-state-segmented__pill--active-active': state === 'active',
-				})}
-				onClick={onActive}
-				// Per spec: when muted, un-muting must happen via Planned Downtimes,
-				// so the Active pill is non-interactive while muted.
-				disabled={disabled || isMuted}
-			>
-				{state === 'active' && (
-					<span className="alert-state-segmented__dot" aria-hidden />
-				)}
-				<span className="alert-state-segmented__label">Active</span>
-			</button>
-			<button
-				type="button"
-				role="tab"
-				aria-selected={state === 'muted'}
-				aria-label="Mute"
-				className={classNames('alert-state-segmented__pill', {
-					'alert-state-segmented__pill--active-muted': state === 'muted',
-				})}
-				onClick={onMute}
-				// Muting a disabled rule wouldn't change observable behavior, so the
-				// Mute pill is non-interactive while disabled.
-				disabled={disabled || isDisabled}
-			>
-				{state === 'muted' && (
-					<BellOff size={12} className="alert-state-segmented__icon" />
-				)}
-				<span className="alert-state-segmented__label">Mute</span>
-			</button>
-			<button
-				type="button"
-				role="tab"
-				aria-selected={state === 'disabled'}
-				aria-label="Disable"
-				className={classNames('alert-state-segmented__pill', {
-					'alert-state-segmented__pill--active-disabled': state === 'disabled',
-				})}
-				onClick={onDisable}
-				disabled={disabled}
-			>
-				<span className="alert-state-segmented__label">Disable</span>
-			</button>
-		</div>
-	);
-});
-
-export default AlertStateSegmented;

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/DisabledBanner.tsx

@@ -1,43 +0,0 @@
-import { CircleOff } from '@signozhq/icons';
-import type { RuletypesRuleDTO } from 'api/generated/services/sigNoz.schemas';
-import dayjs from 'dayjs';
-import relativeTime from 'dayjs/plugin/relativeTime';
-
-import './StateBanners.styles.scss';
-
-dayjs.extend(relativeTime);
-
-interface DisabledBannerProps {
-	rule: RuletypesRuleDTO;
-}
-
-function DisabledBanner({ rule }: DisabledBannerProps): JSX.Element {
-	const updatedAt = rule.updatedAt ? dayjs(rule.updatedAt) : null;
-
-	return (
-		<div className="state-banner state-banner--disabled" role="status">
-			<div className="state-banner__icon-disc state-banner__icon-disc--disabled">
-				<CircleOff size={18} color="var(--bg-slate-50)" />
-			</div>
-			<div className="state-banner__body">
-				<div className="state-banner__title">
-					<span>Rule disabled</span>
-					<span className="state-banner__pill state-banner__pill--disabled">
-						NOT EVALUATING
-					</span>
-				</div>
-				<div className="state-banner__meta">
-					<span>Evaluation paused — no fires will be recorded.</span>
-					{updatedAt && (
-						<>
-							{' · '}
-							<span>{updatedAt.fromNow()}</span>
-						</>
-					)}
-				</div>
-			</div>
-		</div>
-	);
-}
-
-export default DisabledBanner;

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/MutePopover.styles.scss

@@ -1,193 +0,0 @@
-.mute-popover-overlay {
-	.ant-popover-inner {
-		padding: 0;
-		background: var(--bg-ink-400);
-		border: 1px solid var(--bg-slate-300);
-		border-radius: 10px;
-		box-shadow: 0 12px 48px rgba(0, 0, 0, 0.55);
-	}
-	.ant-popover-inner-content {
-		padding: 0;
-	}
-}
-
-.mute-popover {
-	width: 320px;
-	padding: 14px;
-	font-family: 'Inter', sans-serif;
-	color: var(--bg-vanilla-100);
-
-	&__header {
-		display: flex;
-		align-items: center;
-		justify-content: space-between;
-		margin-bottom: 6px;
-	}
-
-	&__title {
-		display: inline-flex;
-		align-items: center;
-		gap: 8px;
-		font-size: 13px;
-		font-weight: 600;
-		color: var(--bg-vanilla-100);
-	}
-
-	&__close {
-		display: inline-flex;
-		align-items: center;
-		justify-content: center;
-		width: 22px;
-		height: 22px;
-		padding: 0;
-		color: var(--bg-vanilla-400);
-		background: transparent;
-		border: 0;
-		border-radius: 4px;
-		cursor: pointer;
-		transition:
-			color 140ms,
-			background 140ms;
-
-		&:hover {
-			color: var(--bg-vanilla-100);
-			background: var(--bg-ink-300);
-		}
-	}
-
-	&__hint {
-		margin: 0 0 12px 0;
-		font-size: 12px;
-		line-height: 1.45;
-		color: var(--bg-vanilla-400);
-
-		strong {
-			color: var(--bg-vanilla-100);
-			font-weight: 600;
-		}
-	}
-
-	&__grid {
-		display: grid;
-		grid-template-columns: repeat(3, 1fr);
-		gap: 6px;
-		margin-bottom: 8px;
-	}
-
-	&__cell {
-		padding: 9px 0;
-		font-size: 12.5px;
-		color: var(--bg-vanilla-100);
-		background: var(--bg-ink-300);
-		border: 1px solid var(--bg-slate-300);
-		border-radius: 6px;
-		cursor: pointer;
-		transition:
-			background 140ms,
-			border-color 140ms,
-			color 140ms;
-
-		&:hover:not(&--selected) {
-			background: rgba(78, 116, 248, 0.08);
-			border-color: var(--bg-robin-500);
-		}
-
-		&--selected {
-			background: var(--bg-robin-500);
-			border-color: var(--bg-robin-500);
-			color: var(--bg-vanilla-100);
-		}
-	}
-
-	&__custom {
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		gap: 6px;
-		width: 100%;
-		padding: 8px 12px;
-		font-size: 12.5px;
-		color: var(--bg-vanilla-100);
-		background: transparent;
-		border: 1px dashed var(--bg-slate-200);
-		border-radius: 6px;
-		cursor: pointer;
-		transition:
-			border-color 140ms,
-			background 140ms;
-
-		&:hover {
-			border-color: var(--bg-robin-500);
-			background: rgba(78, 116, 248, 0.06);
-		}
-	}
-
-	&__divider {
-		height: 1px;
-		margin: 12px 0;
-		background: var(--bg-slate-300);
-	}
-
-	&__label {
-		display: block;
-		margin-bottom: 6px;
-		font-size: 12px;
-		color: var(--bg-vanilla-400);
-	}
-
-	&__input.ant-input {
-		padding: 8px 10px;
-		font-size: 12.5px;
-		background: var(--bg-ink-300);
-		border: 1px solid var(--bg-slate-300);
-		border-radius: 6px;
-		color: var(--bg-vanilla-100);
-	}
-
-	&__footer {
-		display: flex;
-		justify-content: flex-end;
-		gap: 8px;
-		margin-top: 12px;
-	}
-
-	&__btn {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		padding: 6px 12px;
-		font-size: 12.5px;
-		font-weight: 500;
-		border-radius: 6px;
-		cursor: pointer;
-		transition:
-			background 140ms,
-			color 140ms;
-
-		&:disabled {
-			opacity: 0.5;
-			cursor: not-allowed;
-		}
-
-		&--ghost {
-			color: var(--bg-vanilla-400);
-			background: transparent;
-			border: 1px solid transparent;
-
-			&:hover:not(:disabled) {
-				color: var(--bg-vanilla-100);
-				background: var(--bg-ink-300);
-			}
-		}
-
-		&--primary {
-			color: var(--bg-vanilla-100);
-			background: var(--bg-robin-500);
-			border: 1px solid var(--bg-robin-500);
-
-			&:hover:not(:disabled) {
-				background: var(--bg-robin-600);
-			}
-		}
-	}
-}

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/MutePopover.tsx

@@ -1,256 +0,0 @@
-import { useEffect, useState } from 'react';
-import { BellOff, Calendar, X } from '@signozhq/icons';
-import { Input, Popover } from 'antd';
-import classNames from 'classnames';
-import dayjs from 'dayjs';
-import timezone from 'dayjs/plugin/timezone';
-import utc from 'dayjs/plugin/utc';
-
-import type { MutePayload } from './useMuteAlertRule';
-
-import './MutePopover.styles.scss';
-
-dayjs.extend(utc);
-dayjs.extend(timezone);
-
-type QuickDuration = {
-	label: string;
-	value: string;
-	minutes: number | null; // null = forever
-};
-
-export const QUICK_DURATIONS: QuickDuration[] = [
-	{ label: '15 min', value: '15m', minutes: 15 },
-	{ label: '1 hour', value: '1h', minutes: 60 },
-	{ label: '4 hours', value: '4h', minutes: 240 },
-	{ label: '1 day', value: '1d', minutes: 60 * 24 },
-	{ label: '1 week', value: '1w', minutes: 60 * 24 * 7 },
-	{ label: 'Forever', value: 'forever', minutes: null },
-];
-
-const DEFAULT_DURATION_VALUE = '4h';
-
-export const buildMutePayloadFromQuickDuration = (
-	durationValue: string,
-	name: string,
-): MutePayload | null => {
-	const duration = QUICK_DURATIONS.find((d) => d.value === durationValue);
-	if (!duration) {
-		return null;
-	}
-	const now = dayjs();
-	const startTime = now.toISOString();
-	// duration.minutes === null → "Forever"; send endTime as null so the
-	// backend treats the mute as indefinite.
-	const endTime =
-		duration.minutes === null
-			? null
-			: now.add(duration.minutes, 'minute').toISOString();
-	return {
-		name,
-		startTime,
-		endTime,
-		timezone: dayjs.tz.guess?.() || 'UTC',
-	};
-};
-
-const getDefaultMuteName = (ruleName: string | undefined): string =>
-	ruleName ? `Muted: ${ruleName}` : 'Muted alert';
-
-interface MutePopoverProps {
-	open: boolean;
-	onOpenChange: (open: boolean) => void;
-	anchor: React.ReactNode;
-	ruleName: string | undefined;
-	isLoading: boolean;
-	onSubmit: (payload: MutePayload) => Promise<void> | void;
-	onOpenCustomWindow: () => void;
-}
-
-function MutePopover(props: MutePopoverProps): JSX.Element {
-	const {
-		open,
-		onOpenChange,
-		anchor,
-		ruleName,
-		isLoading,
-		onSubmit,
-		onOpenCustomWindow,
-	} = props;
-
-	const [selected, setSelected] = useState<string>(DEFAULT_DURATION_VALUE);
-	const [name, setName] = useState<string>(getDefaultMuteName(ruleName));
-
-	useEffect(() => {
-		if (open) {
-			setSelected(DEFAULT_DURATION_VALUE);
-			setName(getDefaultMuteName(ruleName));
-		}
-	}, [open, ruleName]);
-
-	// Close on outside click / Escape. We use trigger={[]} on the Popover so
-	// antd doesn't handle these — without this hook, the popover only closes
-	// via Cancel / × / Mute submit.
-	useEffect(() => {
-		if (!open) {
-			return undefined;
-		}
-
-		// Drop focus so the trigger button doesn't show a :focus-visible
-		// outline after the popover closes via Escape / outside click.
-		const closeAndBlur = (): void => {
-			(document.activeElement as HTMLElement | null)?.blur();
-			onOpenChange(false);
-		};
-
-		const handleMouseDown = (e: MouseEvent): void => {
-			const target = e.target as HTMLElement | null;
-			if (target?.closest('.mute-popover-overlay')) {
-				return;
-			}
-			closeAndBlur();
-		};
-		const handleKey = (e: KeyboardEvent): void => {
-			if (e.key === 'Escape') {
-				closeAndBlur();
-			}
-		};
-
-		// Defer attaching listeners until after the click that opened the
-		// popover has finished bubbling — otherwise it counts as an outside
-		// click and we close immediately.
-		const timer = window.setTimeout(() => {
-			document.addEventListener('mousedown', handleMouseDown);
-			document.addEventListener('keydown', handleKey);
-		}, 0);
-
-		return (): void => {
-			window.clearTimeout(timer);
-			document.removeEventListener('mousedown', handleMouseDown);
-			document.removeEventListener('keydown', handleKey);
-		};
-	}, [open, onOpenChange]);
-
-	const selectedDuration = QUICK_DURATIONS.find((d) => d.value === selected);
-	const primaryLabel =
-		selectedDuration?.minutes === null
-			? 'Mute indefinitely'
-			: `Mute for ${selectedDuration?.label.toLowerCase() ?? '4 hours'}`;
-
-	const handleSubmit = async (): Promise<void> => {
-		const payload = buildMutePayloadFromQuickDuration(selected, name.trim());
-		if (!payload || !payload.name) {
-			return;
-		}
-		await onSubmit(payload);
-	};
-
-	const content = (
-		<div
-			className="mute-popover"
-			onKeyDown={(e): void => {
-				if (e.key === 'Escape') {
-					onOpenChange(false);
-				}
-			}}
-		>
-			<div className="mute-popover__header">
-				<div className="mute-popover__title">
-					<BellOff size={14} />
-					<span>Mute notifications</span>
-				</div>
-				<button
-					type="button"
-					aria-label="Close"
-					className="mute-popover__close"
-					onClick={(): void => onOpenChange(false)}
-				>
-					<X size={14} />
-				</button>
-			</div>
-
-			<p className="mute-popover__hint">
-				Rule keeps evaluating in the background. You&apos;ll still see fires in{' '}
-				<strong>History</strong> — just no pages, Slack, or email.
-			</p>
-
-			<div className="mute-popover__grid">
-				{QUICK_DURATIONS.map((d) => (
-					<button
-						type="button"
-						key={d.value}
-						className={classNames('mute-popover__cell', {
-							'mute-popover__cell--selected': selected === d.value,
-						})}
-						onClick={(): void => setSelected(d.value)}
-					>
-						{d.label}
-					</button>
-				))}
-			</div>
-
-			<button
-				type="button"
-				className="mute-popover__custom"
-				onClick={(): void => {
-					onOpenChange(false);
-					onOpenCustomWindow();
-				}}
-			>
-				<Calendar size={14} />
-				Custom window…
-			</button>
-
-			<div className="mute-popover__divider" />
-
-			<label className="mute-popover__label" htmlFor="mute-popover-name">
-				Name
-			</label>
-			<Input
-				id="mute-popover-name"
-				className="mute-popover__input"
-				placeholder="e.g. Deployment window"
-				value={name}
-				onChange={(e): void => setName(e.target.value)}
-				maxLength={120}
-			/>
-
-			<div className="mute-popover__footer">
-				<button
-					type="button"
-					className="mute-popover__btn mute-popover__btn--ghost"
-					onClick={(): void => onOpenChange(false)}
-					disabled={isLoading}
-				>
-					Cancel
-				</button>
-				<button
-					type="button"
-					className="mute-popover__btn mute-popover__btn--primary"
-					onClick={handleSubmit}
-					disabled={isLoading || !name.trim()}
-				>
-					<BellOff size={12} />
-					{primaryLabel}
-				</button>
-			</div>
-		</div>
-	);
-
-	return (
-		<Popover
-			open={open}
-			onOpenChange={onOpenChange}
-			trigger={[]}
-			placement="bottomRight"
-			arrow={false}
-			destroyTooltipOnHide
-			overlayClassName="mute-popover-overlay"
-			content={content}
-		>
-			{anchor}
-		</Popover>
-	);
-}
-
-export default MutePopover;

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/MuteSchedulerDrawer.styles.scss

@@ -1,115 +0,0 @@
-.mute-scheduler-drawer {
-	.ant-drawer-body {
-		padding: 24px 28px;
-		background: var(--bg-ink-500);
-	}
-	.ant-drawer-header {
-		display: none;
-	}
-
-	&__header {
-		display: flex;
-		align-items: flex-start;
-		justify-content: space-between;
-		gap: 12px;
-	}
-
-	&__title {
-		display: inline-flex;
-		align-items: center;
-		gap: 8px;
-		font-size: 16px;
-		font-weight: 600;
-		color: var(--bg-vanilla-100);
-	}
-
-	&__close {
-		position: absolute;
-		top: 18px;
-		right: 24px;
-		width: 28px;
-		height: 28px;
-		font-size: 18px;
-		line-height: 1;
-		color: var(--bg-vanilla-400);
-		background: transparent;
-		border: 0;
-		border-radius: 4px;
-		cursor: pointer;
-		transition:
-			background 140ms,
-			color 140ms;
-
-		&:hover {
-			color: var(--bg-vanilla-100);
-			background: var(--bg-ink-300);
-		}
-	}
-
-	&__subtitle {
-		margin: 8px 0 14px 0;
-		font-size: 12.5px;
-		line-height: 1.55;
-		color: var(--bg-vanilla-400);
-
-		strong {
-			color: var(--bg-vanilla-100);
-			font-weight: 600;
-		}
-	}
-
-	&__divider {
-		height: 1px;
-		margin: 0 0 16px 0;
-		background: var(--bg-slate-300);
-	}
-
-	&__form {
-		.ant-form-item-label > label {
-			font-size: 12px;
-			color: var(--bg-vanilla-400);
-		}
-	}
-
-	&__row {
-		display: grid;
-		grid-template-columns: 1fr 1fr;
-		gap: 10px;
-	}
-
-	&__date {
-		width: 100%;
-	}
-
-	&__callout {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-		margin: 4px 0 18px 0;
-		padding: 10px;
-		background: rgba(35, 196, 248, 0.06);
-		border: 1px solid rgba(35, 196, 248, 0.2);
-		border-radius: 6px;
-
-		p {
-			margin: 0;
-			font-size: 12px;
-			line-height: 1.5;
-			color: var(--bg-vanilla-400);
-
-			strong {
-				color: var(--bg-vanilla-100);
-				font-weight: 600;
-			}
-		}
-	}
-
-	&__footer {
-		display: flex;
-		justify-content: flex-end;
-		gap: 8px;
-		padding-top: 16px;
-		margin-top: 6px;
-		border-top: 1px solid var(--bg-slate-300);
-	}
-}

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/MuteSchedulerDrawer.tsx

@@ -1,247 +0,0 @@
-import { useEffect, useMemo, useState } from 'react';
-import { BellOff, Check, Info } from '@signozhq/icons';
-import { Button, DatePicker, Drawer, Form, Input, Select } from 'antd';
-import type { DefaultOptionType } from 'antd/es/select';
-import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import {
-	recurrenceOptions,
-	recurrenceOptionWithSubmenu,
-	recurrenceWeeklyOptions,
-} from 'container/PlannedDowntime/PlannedDowntimeutils';
-import dayjs from 'dayjs';
-import timezone from 'dayjs/plugin/timezone';
-import utc from 'dayjs/plugin/utc';
-import { ALL_TIME_ZONES } from 'utils/timeZoneUtil';
-
-import type { MutePayload } from './useMuteAlertRule';
-
-import './MuteSchedulerDrawer.styles.scss';
-
-dayjs.extend(utc);
-dayjs.extend(timezone);
-
-const DATE_FORMAT = DATE_TIME_FORMATS.ORDINAL_DATETIME;
-
-const TZ_OPTIONS: DefaultOptionType[] = ALL_TIME_ZONES.map((tz) => ({
-	label: tz,
-	value: tz,
-	key: tz,
-}));
-
-const DURATION_UNIT_OPTIONS = [
-	{ label: 'Mins', value: 'm' },
-	{ label: 'Hours', value: 'h' },
-];
-
-type MuteSchedulerFormData = {
-	name: string;
-	startTime: dayjs.Dayjs | null;
-	endTime: dayjs.Dayjs | null;
-	repeatType: string;
-	repeatOn?: string[];
-	duration?: number;
-	timezone: string;
-};
-
-interface MuteSchedulerDrawerProps {
-	open: boolean;
-	onClose: () => void;
-	ruleName: string | undefined;
-	isLoading: boolean;
-	onSubmit: (payload: MutePayload) => Promise<void> | void;
-}
-
-function MuteSchedulerDrawer(props: MuteSchedulerDrawerProps): JSX.Element {
-	const { open, onClose, ruleName, isLoading, onSubmit } = props;
-	const [form] = Form.useForm<MuteSchedulerFormData>();
-	const [recurrenceType, setRecurrenceType] = useState<string>(
-		recurrenceOptions.doesNotRepeat.value,
-	);
-	const [durationUnit, setDurationUnit] = useState<string>('m');
-
-	const defaultName = useMemo(
-		() => (ruleName ? `Muted: ${ruleName}` : 'Muted alert'),
-		[ruleName],
-	);
-
-	useEffect(() => {
-		if (open) {
-			const guess = (dayjs as any).tz?.guess?.() || 'UTC';
-			form.setFieldsValue({
-				name: defaultName,
-				startTime: dayjs(),
-				endTime: dayjs().add(1, 'hour'),
-				repeatType: recurrenceOptions.doesNotRepeat.value,
-				timezone: guess,
-			});
-			setRecurrenceType(recurrenceOptions.doesNotRepeat.value);
-			setDurationUnit('m');
-		}
-	}, [open, defaultName, form]);
-
-	const handleFinish = async (values: MuteSchedulerFormData): Promise<void> => {
-		const isRecurring =
-			values.repeatType &&
-			values.repeatType !== recurrenceOptions.doesNotRepeat.value;
-
-		const payload: MutePayload = {
-			name: values.name.trim(),
-			startTime: values.startTime?.format() || dayjs().format(),
-			endTime: values.endTime ? values.endTime.format() : null,
-			timezone: values.timezone,
-			recurrence: isRecurring
-				? {
-						duration: values.duration ? `${values.duration}${durationUnit}` : '',
-						repeatOn: values.repeatOn as any,
-						repeatType: values.repeatType as any,
-						startTime: values.startTime?.format() || dayjs().format(),
-						endTime: values.endTime ? values.endTime.format() : undefined,
-					}
-				: undefined,
-		};
-
-		await onSubmit(payload);
-	};
-
-	const requiredRule = [{ required: true }];
-
-	return (
-		<Drawer
-			width={460}
-			open={open}
-			onClose={onClose}
-			placement="right"
-			closable={false}
-			destroyOnClose
-			className="mute-scheduler-drawer"
-			rootClassName="mute-scheduler-drawer-root"
-		>
-			<div className="mute-scheduler-drawer__header">
-				<div className="mute-scheduler-drawer__title">
-					<BellOff size={18} color="var(--bg-amber-500)" />
-					<span>Mute this alert rule</span>
-				</div>
-				<button
-					type="button"
-					className="mute-scheduler-drawer__close"
-					aria-label="Close"
-					onClick={onClose}
-				>
-					×
-				</button>
-			</div>
-			<p className="mute-scheduler-drawer__subtitle">
-				Creates a planned silence for <strong>{ruleName || 'this rule'}</strong> —
-				rule continues to evaluate; notifications are suppressed for the window
-				below.
-			</p>
-			<div className="mute-scheduler-drawer__divider" />
-
-			<Form<MuteSchedulerFormData>
-				form={form}
-				layout="vertical"
-				onFinish={handleFinish}
-				onValuesChange={(_, all): void => {
-					if (all.repeatType !== recurrenceType) {
-						setRecurrenceType(all.repeatType);
-					}
-				}}
-				className="mute-scheduler-drawer__form"
-				autoComplete="off"
-			>
-				<Form.Item label="Name" name="name" rules={requiredRule}>
-					<Input placeholder="e.g. Deployment window" maxLength={120} />
-				</Form.Item>
-
-				<Form.Item label="Starts" name="startTime" rules={requiredRule}>
-					<DatePicker
-						className="mute-scheduler-drawer__date"
-						showTime
-						showNow={false}
-						format={(date): string => date.format(DATE_FORMAT)}
-					/>
-				</Form.Item>
-
-				<Form.Item
-					label="Ends"
-					name="endTime"
-					required={recurrenceType === recurrenceOptions.doesNotRepeat.value}
-					rules={[
-						{
-							required: recurrenceType === recurrenceOptions.doesNotRepeat.value,
-						},
-					]}
-				>
-					<DatePicker
-						className="mute-scheduler-drawer__date"
-						showTime
-						showNow={false}
-						format={(date): string => date.format(DATE_FORMAT)}
-					/>
-				</Form.Item>
-
-				<div className="mute-scheduler-drawer__row">
-					<Form.Item label="Repeats every" name="repeatType" rules={requiredRule}>
-						<Select placeholder="Select" options={recurrenceOptionWithSubmenu} />
-					</Form.Item>
-					<Form.Item label="Timezone" name="timezone" rules={requiredRule}>
-						<Select placeholder="Select timezone" showSearch options={TZ_OPTIONS} />
-					</Form.Item>
-				</div>
-
-				{recurrenceType === recurrenceOptions.weekly.value && (
-					<Form.Item label="Weekly occurrence" name="repeatOn" rules={requiredRule}>
-						<Select
-							placeholder="Select days"
-							mode="multiple"
-							options={Object.values(recurrenceWeeklyOptions)}
-						/>
-					</Form.Item>
-				)}
-
-				{recurrenceType &&
-					recurrenceType !== recurrenceOptions.doesNotRepeat.value && (
-						<Form.Item label="Duration" name="duration" rules={requiredRule}>
-							<Input
-								type="number"
-								min={1}
-								placeholder="Enter duration"
-								addonAfter={
-									<Select
-										value={durationUnit}
-										onChange={(v): void => setDurationUnit(v)}
-										options={DURATION_UNIT_OPTIONS}
-									/>
-								}
-								onWheel={(e): void => e.currentTarget.blur()}
-							/>
-						</Form.Item>
-					)}
-
-				<div className="mute-scheduler-drawer__callout">
-					<Info size={14} color="var(--bg-aqua-500)" />
-					<p>
-						The rule will <strong>keep evaluating</strong> and firing alerts to the
-						History tab. Only notifications (Slack, PagerDuty, email) are silenced.
-					</p>
-				</div>
-
-				<div className="mute-scheduler-drawer__footer">
-					<Button type="text" onClick={onClose} disabled={isLoading}>
-						Cancel
-					</Button>
-					<Button
-						type="primary"
-						htmlType="submit"
-						loading={isLoading}
-						icon={<Check size={14} />}
-					>
-						Mute alert
-					</Button>
-				</div>
-			</Form>
-		</Drawer>
-	);
-}
-
-export default MuteSchedulerDrawer;

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/MutedBanner.tsx

@@ -1,115 +0,0 @@
-import { useEffect, useMemo, useState } from 'react';
-import { Link } from 'react-router-dom';
-import { BellOff } from '@signozhq/icons';
-import ROUTES from 'constants/routes';
-import dayjs from 'dayjs';
-
-import type { ActiveMute } from './useActiveMute';
-
-import './StateBanners.styles.scss';
-
-const PLANNED_DOWNTIMES_URL = `${ROUTES.LIST_ALL_ALERT}?tab=Configuration&subTab=planned-downtime`;
-
-const formatRemaining = (endTime: string | undefined): string | null => {
-	if (!endTime) {
-		return null;
-	}
-	const end = dayjs(endTime);
-	const now = dayjs();
-	const diffMs = end.diff(now);
-	if (diffMs <= 0) {
-		return null;
-	}
-
-	const totalMinutes = Math.floor(diffMs / 60000);
-	const days = Math.floor(totalMinutes / (60 * 24));
-	const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
-	const minutes = totalMinutes % 60;
-
-	if (days > 0) {
-		return `${days}d ${hours}h LEFT`;
-	}
-	if (hours > 0) {
-		return `${hours}h ${minutes}m LEFT`;
-	}
-	return `${minutes}m LEFT`;
-};
-
-const isIndefinite = (endTime: string | undefined): boolean => {
-	if (!endTime) {
-		return true;
-	}
-	// If end is more than 5 years away, treat as indefinite (matches "Forever" sentinel).
-	return dayjs(endTime).diff(dayjs(), 'year') >= 5;
-};
-
-interface MutedBannerProps {
-	activeMute: ActiveMute;
-}
-
-function MutedBanner({ activeMute }: MutedBannerProps): JSX.Element {
-	const endTime = activeMute.effectiveEndTime ?? undefined;
-	const indefinite = isIndefinite(endTime);
-	const [remaining, setRemaining] = useState<string | null>(
-		indefinite ? null : formatRemaining(endTime),
-	);
-
-	useEffect(() => {
-		if (indefinite) {
-			return undefined;
-		}
-		const interval = setInterval(() => {
-			setRemaining(formatRemaining(endTime));
-		}, 60_000);
-		return (): void => clearInterval(interval);
-	}, [endTime, indefinite]);
-
-	const titleText = useMemo(() => {
-		if (indefinite) {
-			return 'Notifications muted indefinitely';
-		}
-		if (!endTime) {
-			return 'Notifications muted';
-		}
-		return `Notifications muted until ${dayjs(endTime).format('MMM D, h:mm A')}`;
-	}, [endTime, indefinite]);
-
-	const reason = activeMute.description || activeMute.name;
-
-	return (
-		<div className="state-banner state-banner--muted" role="status">
-			<div className="state-banner__icon-disc state-banner__icon-disc--muted">
-				<BellOff size={18} color="var(--bg-amber-500)" />
-			</div>
-			<div className="state-banner__body">
-				<div className="state-banner__title">
-					<span>{titleText}</span>
-					{!indefinite && remaining && (
-						<span className="state-banner__pill state-banner__pill--muted">
-							{remaining}
-						</span>
-					)}
-				</div>
-				<div className="state-banner__meta">
-					<span>
-						Rule is still evaluating — fires will appear in <strong>History</strong>.
-					</span>
-					{reason && (
-						<>
-							{' · '}
-							<span>
-								Name: <strong>{reason}</strong>
-							</span>
-						</>
-					)}
-					{' · '}
-					<Link to={PLANNED_DOWNTIMES_URL} className="state-banner__link">
-						Manage in Planned Downtimes
-					</Link>
-				</div>
-			</div>
-		</div>
-	);
-}
-
-export default MutedBanner;

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/StateBanners.styles.scss

@@ -1,98 +0,0 @@
-.state-banner {
-	display: flex;
-	gap: 14px;
-	align-items: center;
-	margin-top: 16px;
-	padding: 12px 16px;
-	border-radius: 8px;
-	font-family: 'Inter', sans-serif;
-
-	&--muted {
-		background: linear-gradient(
-			90deg,
-			rgba(255, 205, 86, 0.1),
-			rgba(255, 205, 86, 0.04)
-		);
-		border: 1px solid rgba(255, 205, 86, 0.25);
-	}
-
-	&--disabled {
-		background: rgba(98, 104, 124, 0.06);
-		border: 1px solid var(--bg-slate-200);
-	}
-
-	&__icon-disc {
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		width: 36px;
-		height: 36px;
-		border-radius: 999px;
-		flex-shrink: 0;
-
-		&--muted {
-			background: rgba(255, 205, 86, 0.15);
-		}
-
-		&--disabled {
-			background: rgba(98, 104, 124, 0.15);
-		}
-	}
-
-	&__body {
-		flex: 1;
-		min-width: 0;
-	}
-
-	&__title {
-		display: flex;
-		align-items: center;
-		gap: 8px;
-		font-size: 13.5px;
-		font-weight: 600;
-		color: var(--bg-vanilla-100);
-		font-variant-numeric: tabular-nums;
-	}
-
-	&__pill {
-		display: inline-flex;
-		align-items: center;
-		padding: 2px 7px;
-		font-size: 11px;
-		font-weight: 600;
-		letter-spacing: 0.04em;
-		text-transform: uppercase;
-		border-radius: 4px;
-
-		&--muted {
-			color: var(--bg-amber-500);
-			background: rgba(255, 205, 86, 0.12);
-		}
-
-		&--disabled {
-			color: var(--bg-slate-50);
-			background: rgba(98, 104, 124, 0.18);
-		}
-	}
-
-	&__meta {
-		margin-top: 4px;
-		font-size: 12px;
-		line-height: 1.5;
-		color: var(--bg-vanilla-400);
-
-		strong {
-			color: var(--bg-vanilla-100);
-			font-weight: 600;
-		}
-	}
-
-	&__link {
-		color: var(--bg-robin-500);
-
-		&:hover {
-			color: var(--bg-robin-400);
-			text-decoration: underline;
-		}
-	}
-}

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/useActiveMute.ts

@@ -1,37 +0,0 @@
-import { useMemo } from 'react';
-import { useGetRuleByID } from 'api/generated/services/rules';
-import type { RuletypesActiveMuteInfoDTO } from 'api/generated/services/sigNoz.schemas';
-
-export type ActiveMute = RuletypesActiveMuteInfoDTO;
-
-type UseActiveMuteResult = {
-	activeMute: ActiveMute | undefined;
-	isLoading: boolean;
-	isFetching: boolean;
-	refetch: () => void;
-};
-
-export const useActiveMute = (
-	ruleId: string | undefined,
-): UseActiveMuteResult => {
-	const { data, isLoading, isFetching, refetch } = useGetRuleByID(
-		{ id: ruleId || '' },
-		{
-			query: {
-				enabled: Boolean(ruleId),
-				refetchOnWindowFocus: false,
-			},
-		},
-	);
-
-	const activeMute = useMemo(() => data?.data?.activeMute ?? undefined, [data]);
-
-	return {
-		activeMute,
-		isLoading,
-		isFetching,
-		refetch: () => {
-			void refetch();
-		},
-	};
-};

frontend/src/pages/AlertDetails/AlertHeader/MuteAlert/useMuteAlertRule.ts

@@ -1,92 +0,0 @@
-import { useCallback } from 'react';
-import { useMutation, useQueryClient } from 'react-query';
-import {
-	createDowntimeSchedule,
-	getListDowntimeSchedulesQueryKey,
-} from 'api/generated/services/downtimeschedules';
-import {
-	getGetRuleByIDQueryKey,
-	getListRulesQueryKey,
-} from 'api/generated/services/rules';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import type {
-	AlertmanagertypesPostablePlannedMaintenanceDTO,
-	AlertmanagertypesRecurrenceDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
-import { useNotifications } from 'hooks/useNotifications';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
-
-export type MutePayload = {
-	name: string;
-	startTime: string;
-	endTime?: string | null;
-	timezone: string;
-	recurrence?: AlertmanagertypesRecurrenceDTO;
-};
-
-type UseMuteAlertRuleArgs = {
-	ruleId: string;
-	onSuccess?: () => void;
-};
-
-type UseMuteAlertRuleResult = {
-	mute: (payload: MutePayload) => Promise<void>;
-	isLoading: boolean;
-};
-
-export const useMuteAlertRule = ({
-	ruleId,
-	onSuccess,
-}: UseMuteAlertRuleArgs): UseMuteAlertRuleResult => {
-	const { notifications } = useNotifications();
-	const { showErrorModal } = useErrorModal();
-	const queryClient = useQueryClient();
-
-	const { mutateAsync, isLoading } = useMutation(
-		['createMuteDowntime', ruleId],
-		(payload: AlertmanagertypesPostablePlannedMaintenanceDTO) =>
-			createDowntimeSchedule(payload),
-		{
-			onSuccess: () => {
-				void queryClient.invalidateQueries(getListDowntimeSchedulesQueryKey());
-				void queryClient.invalidateQueries(getGetRuleByIDQueryKey({ id: ruleId }));
-				void queryClient.invalidateQueries(getListRulesQueryKey());
-				notifications.success({ message: 'Alert muted' });
-				onSuccess?.();
-			},
-			onError: (error) => {
-				showErrorModal(
-					convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
-				);
-			},
-		},
-	);
-
-	const mute = useCallback(
-		async (payload: MutePayload): Promise<void> => {
-			if (!ruleId) {
-				return;
-			}
-			const body: AlertmanagertypesPostablePlannedMaintenanceDTO = {
-				name: payload.name,
-				alertIds: [ruleId],
-				schedule: {
-					startTime: payload.startTime,
-					// null = no end ("Forever"). The generated type narrows endTime to
-					// string, but the API accepts null to mean indefinite.
-					endTime:
-						payload.endTime === null ? (null as unknown as string) : payload.endTime,
-					timezone: payload.timezone,
-					recurrence: payload.recurrence,
-				},
-			};
-			await mutateAsync(body);
-		},
-		[mutateAsync, ruleId],
-	);
-
-	return { mute, isLoading };
-};

frontend/src/pages/ChannelsEdit/index.tsx

@@ -7,6 +7,7 @@ import get from 'api/channels/get';
 import Spinner from 'components/Spinner';
 import {
 	ChannelType,
+	GoogleChatChannel,
 	MsTeamsChannel,
 	PagerChannel,
 	SlackChannel,
@@ -56,9 +57,17 @@ function ChannelsEdit(): JSX.Element {
 
 	const prepChannelConfig = (): {
 		type: string;
-		channel: SlackChannel & WebhookChannel & PagerChannel & MsTeamsChannel;
+		channel: SlackChannel &
+			WebhookChannel &
+			PagerChannel &
+			MsTeamsChannel &
+			GoogleChatChannel;
 	} => {
-		let channel: SlackChannel & WebhookChannel & PagerChannel & MsTeamsChannel = {
+		let channel: SlackChannel &
+			WebhookChannel &
+			PagerChannel &
+			MsTeamsChannel &
+			GoogleChatChannel = {
 			name: '',
 		};
 		if (value && 'slack_configs' in value) {
@@ -78,6 +87,15 @@ function ChannelsEdit(): JSX.Element {
 				channel,
 			};
 		}
+
+		if (value && 'googlechat_configs' in value) {
+			const googleChatConfig = value.googlechat_configs[0];
+			channel = googleChatConfig;
+			return {
+				type: ChannelType.GoogleChat,
+				channel,
+			};
+		}
 		if (value && 'pagerduty_configs' in value) {
 			const pagerConfig = value.pagerduty_configs[0];
 			channel = pagerConfig;

frontend/src/types/api/channels/createGoogleChat.ts

@@ -0,0 +1,8 @@
+import { GoogleChatChannel } from 'container/CreateAlertChannels/config';
+
+export type Props = GoogleChatChannel;
+
+export interface PayloadProps {
+	data: string;
+	status: string;
+}

frontend/src/types/api/channels/editGoogleChat.ts

@@ -0,0 +1,10 @@
+import { GoogleChatChannel } from 'container/CreateAlertChannels/config';
+
+export interface Props extends GoogleChatChannel {
+	id: string;
+}
+
+export interface PayloadProps {
+	data: string;
+	status: string;
+}

pkg/alertmanager/alertmanager.go

@@ -25,7 +25,7 @@ type Alertmanager interface {
 	PutAlerts(context.Context, string, alertmanagertypes.PostableAlerts) error
 
 	// TestReceiver sends a test alert to a receiver.
-	TestReceiver(context.Context, string, alertmanagertypes.Receiver) error
+	TestReceiver(context.Context, string, *alertmanagertypes.Receiver) error
 
 	// TestAlert sends an alert to a list of receivers.
 	TestAlert(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string) error
@@ -40,10 +40,10 @@ type Alertmanager interface {
 	GetChannelByID(context.Context, string, valuer.UUID) (*alertmanagertypes.Channel, error)
 
 	// UpdateChannel updates a channel for the organization.
-	UpdateChannelByReceiverAndID(context.Context, string, alertmanagertypes.Receiver, valuer.UUID) error
+	UpdateChannelByReceiverAndID(context.Context, string, *alertmanagertypes.Receiver, valuer.UUID) error
 
 	// CreateChannel creates a channel for the organization.
-	CreateChannel(context.Context, string, alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)
+	CreateChannel(context.Context, string, *alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)
 
 	// DeleteChannelByID deletes a channel for the organization.
 	DeleteChannelByID(context.Context, string, valuer.UUID) error

pkg/alertmanager/alertmanagernotify/email/email.go

@@ -23,7 +23,13 @@ import (
 	"sync"
 	"time"
 
+	htmltemplate "html/template"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -34,20 +40,39 @@ import (
 
 const (
 	Integration = "email"
+
+	// alertEmailLayoutTemplate is the name of the HTML layout template that
+	// wraps the rendered alert bodies. It is loaded into the notification
+	// template (n.tmpl) from the alertmanager templates config and lives at
+	// templates/alertmanager/email.gotmpl.
+	alertEmailLayoutTemplate = "email.signoz.html"
 )
 
 // Email implements a Notifier for email notifications.
 type Email struct {
-	conf     *config.EmailConfig
-	tmpl     *template.Template
-	logger   *slog.Logger
-	hostname string
+	conf      *config.EmailConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	hostname  string
+	templater alertmanagertypes.Templater
+}
+
+// layoutData is the value passed to the email.signoz.html layout
+// template. It embeds NotificationTemplateData so templates can reference
+// `.Alert.Status`, `.Alert.TotalFiring`, `.Alert.TotalResolved`,
+// `.NotificationTemplateData.ExternalURL`, etc. alongside the rendered
+// Title and per-alert Bodies.
+type layoutData struct {
+	alertmanagertypes.NotificationTemplateData
+	Title  string
+	Bodies []htmltemplate.HTML
 }
 
 var errNoAuthUsernameConfigured = errors.NewInternalf(errors.CodeInternal, "no auth username configured")
 
-// New returns a new Email notifier.
-func New(c *config.EmailConfig, t *template.Template, l *slog.Logger) *Email {
+// New returns a new Email notifier. When the email.signoz.html layout is
+// not defined in t, custom-body alerts fall back to plain <div>-wrapped HTML.
+func New(c *config.EmailConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater) *Email {
 	if _, ok := c.Headers["Subject"]; !ok {
 		c.Headers["Subject"] = config.DefaultEmailSubject
 	}
@@ -63,7 +88,7 @@ func New(c *config.EmailConfig, t *template.Template, l *slog.Logger) *Email {
 	if err != nil {
 		h = "localhost.localdomain"
 	}
-	return &Email{conf: c, tmpl: t, logger: l, hostname: h}
+	return &Email{conf: c, tmpl: t, logger: l, hostname: h, templater: templater}
 }
 
 // auth resolves a string of authentication mechanisms.
@@ -199,9 +224,9 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 
 	if ok, mech := c.Extension("AUTH"); ok {
 		auth, err := n.auth(mech)
-		if err != nil && err != errNoAuthUsernameConfigured {
+		if err != nil && !errors.Is(err, errNoAuthUsernameConfigured) {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "find auth mechanism")
-		} else if err == errNoAuthUsernameConfigured {
+		} else if errors.Is(err, errNoAuthUsernameConfigured) {
 			n.logger.DebugContext(ctx, "no auth username configured. Attempting to send email without authenticating")
 		}
 		if auth != nil {
@@ -245,6 +270,16 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		}
 	}
 
+	// Prepare the content for the email. subject, when non-empty, overrides
+	// the configured Subject header for this notification only. We deliberately
+	// do not mutate n.conf.Headers here: the config map is shared across
+	// concurrent notifications to the same receiver.
+	subject, htmlBody, err := n.prepareContent(ctx, as)
+	if err != nil {
+		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+		return false, err
+	}
+
 	// Send the email headers and body.
 	message, err := c.Data()
 	if err != nil {
@@ -262,6 +297,10 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 
 	buffer := &bytes.Buffer{}
 	for header, t := range n.conf.Headers {
+		if header == "Subject" {
+			fmt.Fprintf(buffer, "%s: %s\r\n", header, mime.QEncoding.Encode("utf-8", subject))
+			continue
+		}
 		value, err := n.tmpl.ExecuteTextString(t, data)
 		if err != nil {
 			return false, errors.WrapInternalf(err, errors.CodeInternal, "execute %q header template", header)
@@ -336,7 +375,7 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		}
 	}
 
-	if len(n.conf.HTML) > 0 {
+	if htmlBody != "" {
 		// Html template
 		// Preferred alternative placed last per section 5.1.4 of RFC 2046
 		// https://www.ietf.org/rfc/rfc2046.txt
@@ -347,12 +386,8 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		if err != nil {
 			return false, errors.WrapInternalf(err, errors.CodeInternal, "create part for html template")
 		}
-		body, err := n.tmpl.ExecuteHTMLString(n.conf.HTML, data)
-		if err != nil {
-			return false, errors.WrapInternalf(err, errors.CodeInternal, "execute html template")
-		}
 		qw := quotedprintable.NewWriter(w)
-		_, err = qw.Write([]byte(body))
+		_, err = qw.Write([]byte(htmlBody))
 		if err != nil {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "write HTML part")
 		}
@@ -381,6 +416,124 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 	return false, nil
 }
 
+// prepareContent returns a subject override (empty when the default config
+// Subject should be used) and the HTML body for the email. Callers must treat
+// the subject as local state and never write it back to n.conf.Headers.
+func (n *Email) prepareContent(ctx context.Context, alerts []*types.Alert) (string, string, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Headers["Subject"],
+		DefaultBodyTemplate:  n.conf.HTML,
+	}, alerts)
+	if err != nil {
+		return "", "", err
+	}
+
+	subject := result.Title
+
+	if !result.IsDefaultBody {
+		// Custom-body path: render each expanded markdown body to HTML, then
+		// wrap the whole thing in the email.signoz.html layout (or fall
+		// back to plain <div> wrapping when the layout template is not loaded).
+		for i, body := range result.Body {
+			if body == "" {
+				continue
+			}
+			rendered, err := markdownrenderer.RenderHTML(body)
+			if err != nil {
+				return "", "", err
+			}
+			result.Body[i] = rendered
+		}
+		appendRelatedLinkButtons(alerts, result.Body)
+		html, err := n.renderLayout(result)
+		if err != nil {
+			n.logger.WarnContext(ctx, "custom email template rendering failed, falling back to plain <div> wrap", errors.Attr(err))
+			return subject, wrapBodiesAsDivs(result.Body), nil
+		}
+		return subject, html, nil
+	}
+
+	return subject, result.Body[0], nil
+}
+
+// renderLayout wraps result in the email.signoz.html HTML layout loaded
+// into n.tmpl from the alertmanager templates config. Returns an error when the
+// layout template is not defined (e.g. in tests where no templates are loaded)
+// so prepareContent can fall back to plain <div> wrapping.
+func (n *Email) renderLayout(result *alertmanagertypes.ExpandResult) (string, error) {
+	bodies := make([]htmltemplate.HTML, 0, len(result.Body))
+	for _, b := range result.Body {
+		bodies = append(bodies, htmltemplate.HTML(b))
+	}
+	data := layoutData{Title: result.Title, Bodies: bodies}
+	if result.NotificationData != nil {
+		data.NotificationTemplateData = *result.NotificationData
+	}
+	html, err := n.tmpl.ExecuteHTMLString(`{{ template "`+alertEmailLayoutTemplate+`" . }}`, data)
+	if err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to render email layout")
+	}
+	return html, nil
+}
+
+// appendRelatedLinkButtons appends "View Related Logs/Traces" buttons to each
+// per-alert body when the rule manager attached the corresponding annotation.
+// bodies is positionally aligned with alerts (see alertmanagertemplate.Prepare);
+// empty bodies are skipped so we never attach a button to an alert that produced
+// no visible content.
+func appendRelatedLinkButtons(alerts []*types.Alert, bodies []string) {
+	for i := range bodies {
+		if i >= len(alerts) || bodies[i] == "" {
+			continue
+		}
+		if link := alerts[i].Annotations[ruletypes.AnnotationRelatedLogs]; link != "" {
+			bodies[i] += htmlButton("View Related Logs", string(link))
+		}
+		if link := alerts[i].Annotations[ruletypes.AnnotationRelatedTraces]; link != "" {
+			bodies[i] += htmlButton("View Related Traces", string(link))
+		}
+	}
+}
+
+func wrapBodiesAsDivs(bodies []string) string {
+	var b strings.Builder
+	for _, part := range bodies {
+		if part == "" {
+			continue
+		}
+		b.WriteString("<div>")
+		b.WriteString(part)
+		b.WriteString("</div>")
+	}
+	return b.String()
+}
+
+func htmlButton(text, url string) string {
+	return fmt.Sprintf(`
+	<a href="%s" target="_blank" style="text-decoration: none;">
+<button style="
+    padding: 6px 16px;
+    /* Default System Font */
+    font-family: sans-serif;
+    font-size: 14px;
+    font-weight: 500;
+    line-height: 1.5;
+    /* Light Theme & Dynamic Background (Solid) */
+    color: #111827;
+    background-color: #f9fafb;
+    /* Static Outline */
+    border: 1px solid #d1d5db;
+    border-radius: 4px;
+    cursor: pointer;
+">
+  %s
+</button>
+</a>`, url, text)
+}
+
 type loginAuth struct {
 	username, password string
 }

pkg/alertmanager/alertmanagernotify/email/email_test.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
@@ -17,7 +18,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/emersion/go-smtp"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
@@ -42,6 +46,11 @@ const (
 	emailFrom = "alertmanager@example.com"
 )
 
+// testTemplater returns a Templater bound to tmpl with a discard logger.
+func testTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
 // email represents an email returned by the MailDev REST API.
 // See https://github.com/djfarrelly/MailDev/blob/master/docs/rest.md.
 type email struct {
@@ -162,7 +171,7 @@ func notifyEmailWithContext(ctx context.Context, t *testing.T, cfg *config.Email
 		return nil, false, err
 	}
 
-	email := New(cfg, tmpl, promslog.NewNopLogger())
+	email := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
 
 	retry, err := email.Notify(ctx, firingAlert)
 	if err != nil {
@@ -706,7 +715,7 @@ func TestEmailRejected(t *testing.T) {
 	tmpl, firingAlert, err := prepare(cfg)
 	require.NoError(t, err)
 
-	e := New(cfg, tmpl, promslog.NewNopLogger())
+	e := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
 
 	// Send the alert to mock SMTP server.
 	retry, err := e.Notify(context.Background(), firingAlert)
@@ -1030,6 +1039,135 @@ func TestEmailImplicitTLS(t *testing.T) {
 	}
 }
 
+func TestPrepareContent(t *testing.T) {
+	t.Run("default title template; custom body template", func(t *testing.T) {
+		tmpl, err := template.FromGlobs([]string{})
+		require.NoError(t, err)
+		tmpl.ExternalURL, _ = url.Parse("http://am")
+
+		bodyTpl := "line $labels.instance"
+		a1 := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					model.LabelName("instance"): model.LabelValue("one"),
+				},
+				Annotations: model.LabelSet{
+					model.LabelName(ruletypes.AnnotationBodyTemplate): model.LabelValue(bodyTpl),
+				},
+			},
+		}
+		a2 := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					model.LabelName("instance"): model.LabelValue("two"),
+				},
+				Annotations: model.LabelSet{
+					model.LabelName(ruletypes.AnnotationBodyTemplate): model.LabelValue(bodyTpl),
+				},
+			},
+		}
+		alerts := []*types.Alert{a1, a2}
+
+		cfg := &config.EmailConfig{Headers: map[string]string{"Subject": "subj"}}
+		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+
+		ctx := context.Background()
+		subject, htmlBody, err := n.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "subj", subject)
+		require.Equal(t, "<div><p>line one</p>\n</div><div><p>line two</p>\n</div>", htmlBody)
+	})
+
+	t.Run("custom title template; default body HTML template", func(t *testing.T) {
+		tmpl, err := template.FromGlobs([]string{})
+		require.NoError(t, err)
+		tmpl.ExternalURL, _ = url.Parse("http://am")
+
+		firingAlert := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{},
+				Annotations: model.LabelSet{
+					model.LabelName(ruletypes.AnnotationTitleTemplate): model.LabelValue("fixed from $alert.status"),
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+		alerts := []*types.Alert{firingAlert}
+		cfg := &config.EmailConfig{
+			Headers: map[string]string{},
+			HTML:    "Status: {{ .Status }}",
+		}
+		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+
+		ctx := context.Background()
+		subject, htmlBody, err := n.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "Status: firing", htmlBody)
+		require.Equal(t, "fixed from firing", subject)
+	})
+
+	t.Run("default template without HTML", func(t *testing.T) {
+		cfg := &config.EmailConfig{Headers: map[string]string{"Subject": "the email subject"}}
+		tmpl, err := template.FromGlobs([]string{})
+		require.NoError(t, err)
+		tmpl.ExternalURL, _ = url.Parse("http://am")
+		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+
+		firingAlert := &types.Alert{
+			Alert: model.Alert{
+				Labels:   model.LabelSet{},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+		alerts := []*types.Alert{firingAlert}
+		ctx := context.Background()
+		subject, htmlBody, err := n.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "", htmlBody)
+		require.Equal(t, "the email subject", subject)
+	})
+
+	t.Run("custom title template; custom body template", func(t *testing.T) {
+		// Load the email.signoz.html layout into the notification template
+		// the same way the alertmanager server does via the templates config.
+		tmpl, err := template.FromGlobs([]string{"../../../../templates/alertmanager/*.gotmpl"})
+		require.NoError(t, err)
+		tmpl.ExternalURL, _ = url.Parse("http://am")
+
+		firingAlert := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					model.LabelName("instance"): model.LabelValue("two"),
+				},
+				Annotations: model.LabelSet{
+					model.LabelName(ruletypes.AnnotationTitleTemplate): model.LabelValue("fixed from $alert.status"),
+					model.LabelName(ruletypes.AnnotationBodyTemplate):  model.LabelValue("line $labels.instance"),
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+		alerts := []*types.Alert{firingAlert}
+		cfg := &config.EmailConfig{
+			Headers: map[string]string{"Subject": "subject"},
+			HTML:    "Well, what are you?",
+		}
+
+		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+
+		ctx := context.Background()
+		subject, htmlBody, err := n.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.Contains(t, htmlBody, "<!DOCTYPE html>")
+		require.Contains(t, htmlBody, "<p>line two</p>")
+		require.NotContains(t, htmlBody, "Well, what are you?")
+		require.Equal(t, subject, "fixed from firing")
+		require.NotContains(t, subject, "subject")
+	})
+}
+
 func ptrTo(b bool) *bool {
 	return &b
 }

pkg/alertmanager/alertmanagernotify/googlechat/googlechat.go

@@ -0,0 +1,161 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package googlechat
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	commoncfg "github.com/prometheus/common/config"
+
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+)
+
+const (
+	Integration = "googlechat"
+)
+
+// Notifier implements a Notifier for Google Chat notifications.
+type Notifier struct {
+	config    *alertmanagertypes.GoogleChatReceiverConfig
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
+}
+
+// New returns a new Google Chat notifier. The template is consumed via the
+// templater, so the *template.Template argument is accepted only for signature
+// parity with the other notifiers.
+func New(cfg *alertmanagertypes.GoogleChatReceiverConfig, _ *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+	if cfg == nil {
+		return nil, errors.NewInternalf(errors.CodeInternal, "google chat config is required")
+	}
+	if cfg.WebhookURL == nil {
+		return nil, errors.NewInternalf(errors.CodeInternal, "google chat webhook_url is required")
+	}
+	if err := validateWebhookURL(cfg.WebhookURL.String()); err != nil {
+		return nil, err
+	}
+
+	client, err := notify.NewClientWithTracing(commoncfg.DefaultHTTPClientConfig, Integration, httpOpts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Notifier{
+		config:    cfg,
+		logger:    l,
+		client:    client,
+		retrier:   &notify.Retrier{},
+		templater: templater,
+	}, nil
+}
+
+func validateWebhookURL(rawURL string) error {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid google chat webhook_url: %v", err)
+	}
+	if u.Scheme != "https" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url must use https")
+	}
+	host := strings.ToLower(u.Hostname())
+	if host != "chat.googleapis.com" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url must use chat.googleapis.com")
+	}
+	return nil
+}
+
+// Message represents the payload sent to Google Chat webhook.
+type Message struct {
+	Text string `json:"text"`
+}
+
+// Notify implements the Notifier interface.
+func (n *Notifier) Notify(ctx context.Context, alerts ...*types.Alert) (bool, error) {
+	key, err := notify.ExtractGroupKey(ctx)
+	if err != nil {
+		return false, err
+	}
+	logger := n.logger.With(slog.Any("group_key", key))
+	logger.DebugContext(ctx, "extracted group key")
+
+	cfg := n.config
+
+	// Expand the title/body templates via the shared templater so that
+	// per-alert custom templates supplied through annotations override the
+	// receiver defaults (consistent with the other SigNoz notifiers).
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: cfg.Title,
+		DefaultBodyTemplate:  cfg.Text,
+	}, alerts)
+	if err != nil {
+		return false, errors.NewInternalf(errors.CodeInternal, "failed to render templates: %v", err)
+	}
+
+	// Build the final message: the title followed by each alert's (non-empty)
+	// rendered body. Google Chat receives a single plain-text message.
+	finalText := result.Title
+	bodyParts := make([]string, 0, len(result.Body))
+	for _, body := range result.Body {
+		if body != "" {
+			bodyParts = append(bodyParts, body)
+		}
+	}
+	if len(bodyParts) > 0 {
+		finalText = result.Title + "\n" + strings.Join(bodyParts, "\n")
+	}
+
+	msg := &Message{
+		Text: finalText,
+	}
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(msg); err != nil {
+		return false, err
+	}
+
+	// Add threading support
+	// https://developers.google.com/chat/how-tos/webhooks#start_a_message_thread
+	webhookURL := cfg.WebhookURL.String()
+	u, err := url.Parse(webhookURL)
+	if err != nil {
+		return false, errors.NewInternalf(errors.CodeInternal, "unable to parse googlechat url: %v", err)
+	}
+	q := u.Query()
+	q.Set("threadKey", key.Hash())
+	q.Set("messageReplyOption", "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD")
+	u.RawQuery = q.Encode()
+	webhookURL = u.String()
+
+	resp, err := notify.PostJSON(ctx, n.client, webhookURL, &buf) //nolint:bodyclose
+	if err != nil {
+		if ctx.Err() != nil {
+			err = errors.NewInternalf(errors.CodeInternal, "failed to post JSON to google chat: %v", context.Cause(ctx))
+		}
+		return true, notify.RedactURL(err)
+	}
+	defer notify.Drain(resp)
+
+	shouldRetry, err := n.retrier.Check(resp.StatusCode, resp.Body)
+	if err != nil {
+		return shouldRetry, notify.NewErrorWithReason(notify.GetFailureReasonFromStatusCode(resp.StatusCode), err)
+	}
+
+	return shouldRetry, err
+}

pkg/alertmanager/alertmanagernotify/googlechat/googlechat_test.go

@@ -0,0 +1,196 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package googlechat
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+	"time"
+
+	test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/alertmanager/config"
+	"github.com/prometheus/alertmanager/notify"
+	notifytest "github.com/prometheus/alertmanager/notify/test"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/require"
+)
+
+func newTestTemplater(t *testing.T) alertmanagertypes.Templater {
+	t.Helper()
+	return alertmanagertemplate.New(test.CreateTmpl(t), slog.New(slog.DiscardHandler))
+}
+
+func TestGoogleChatWebhook(t *testing.T) {
+	var payload bytes.Buffer
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		_, _ = io.Copy(&payload, r.Body)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer server.Close()
+
+	notifier := newTestNotifier(t, server, "Alert: {{ .GroupLabels.alertname }}", "{{ range .Alerts -}} Alert: {{ .Labels.alertname }} {{ end }}")
+	retry, err := notifier.Notify(newTestContext(), newTestAlerts("TestAlert")...)
+	require.NoError(t, err)
+	require.False(t, retry)
+	require.Contains(t, payload.String(), `"text"`)
+	require.Contains(t, payload.String(), "Alert: TestAlert")
+}
+
+func TestGoogleChatTemplating(t *testing.T) {
+	var payload bytes.Buffer
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		_, _ = io.Copy(&payload, r.Body)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer server.Close()
+
+	notifier := newTestNotifier(t, server, "Alert: {{ .GroupLabels.alertname }}", "Summary: {{ range .Alerts }}{{ .Annotations.summary }}{{ end }}")
+	retry, err := notifier.Notify(newTestContext(), newTestAlerts("CPU High")...)
+	require.NoError(t, err)
+	require.False(t, retry)
+	require.Contains(t, payload.String(), "CPU High")
+	require.Contains(t, payload.String(), "Summary:")
+}
+
+func TestGoogleChatRetry(t *testing.T) {
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	defer server.Close()
+
+	notifier := newTestNotifier(t, server, "Alert", "Test message")
+	retry, err := notifier.Notify(newTestContext(), newTestAlerts("TestAlert")...)
+	require.Error(t, err)
+	require.True(t, retry)
+}
+
+func TestGoogleChatRetryCodes(t *testing.T) {
+	notifier, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		WebhookURL: secretURLFromString(t, "https://chat.googleapis.com/v1/spaces/test/messages"),
+		Title:      "Alert",
+		Text:       "Test message",
+	}, test.CreateTmpl(t), slog.New(slog.DiscardHandler), newTestTemplater(t))
+	require.NoError(t, err)
+
+	for statusCode, expected := range notifytest.RetryTests(notifytest.DefaultRetryCodes()) {
+		actual, _ := notifier.retrier.Check(statusCode, nil)
+		require.Equal(t, expected, actual, "retry - error on status %d", statusCode)
+	}
+}
+
+func TestGoogleChatWebhookValidation(t *testing.T) {
+	_, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		WebhookURL: secretURLFromString(t, "http://chat.googleapis.com/v1/spaces/test/messages"),
+		Title:      "Alert",
+		Text:       "Test message",
+	}, test.CreateTmpl(t), slog.New(slog.DiscardHandler), newTestTemplater(t))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "webhook_url must use https")
+
+	_, err = New(&alertmanagertypes.GoogleChatReceiverConfig{
+		WebhookURL: secretURLFromString(t, "https://example.com/v1/spaces/test/messages"),
+		Title:      "Alert",
+		Text:       "Test message",
+	}, test.CreateTmpl(t), slog.New(slog.DiscardHandler), newTestTemplater(t))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "webhook_url must use chat.googleapis.com")
+}
+
+func TestGoogleChatRedactedURL(t *testing.T) {
+	secret := "secret-token"
+	urlStr := "https://chat.googleapis.com/v1/spaces/test/messages?token=" + secret
+
+	notifier, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		WebhookURL: secretURLFromString(t, urlStr),
+		Title:      "Alert",
+		Text:       "Test message",
+	}, test.CreateTmpl(t), slog.New(slog.DiscardHandler), newTestTemplater(t))
+	require.NoError(t, err)
+
+	notifier.client = &http.Client{Transport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
+		return nil, errors.New(errors.TypeInternal, errors.CodeInternal, "request failed")
+	})}
+
+	_, err = notifier.Notify(newTestContext(), newTestAlerts("TestAlert")...)
+	require.Error(t, err)
+	require.NotContains(t, err.Error(), secret)
+}
+
+type roundTripperFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+func newTestNotifier(t *testing.T, server *httptest.Server, title, text string) *Notifier {
+	t.Helper()
+
+	webhookURL := "https://chat.googleapis.com/v1/spaces/test/messages"
+
+	notifier, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		WebhookURL: secretURLFromString(t, webhookURL),
+		Title:      title,
+		Text:       text,
+	}, test.CreateTmpl(t), slog.New(slog.DiscardHandler), newTestTemplater(t))
+	require.NoError(t, err)
+	notifier.client = newTestHTTPClient(server)
+
+	return notifier
+}
+
+func newTestHTTPClient(server *httptest.Server) *http.Client {
+	dialer := &net.Dialer{Timeout: 5 * time.Second}
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			return dialer.DialContext(ctx, network, server.Listener.Addr().String())
+		},
+	}
+
+	return &http.Client{Transport: transport}
+}
+
+func secretURLFromString(t *testing.T, rawURL string) *config.SecretURL {
+	t.Helper()
+
+	parsed, err := url.Parse(rawURL)
+	require.NoError(t, err)
+
+	return &config.SecretURL{URL: parsed}
+}
+
+func newTestAlerts(alertname string) []*types.Alert {
+	return []*types.Alert{{
+		Alert: model.Alert{
+			Labels: model.LabelSet{
+				"alertname": model.LabelValue(alertname),
+			},
+			Annotations: model.LabelSet{
+				"summary": model.LabelValue("summary for " + alertname),
+			},
+			StartsAt: time.Now(),
+			EndsAt:   time.Now().Add(time.Minute),
+		},
+	}}
+}
+
+func newTestContext() context.Context {
+	return notify.WithGroupKey(context.Background(), "test-receiver")
+}

pkg/alertmanager/alertmanagernotify/msteamsv2/msteamsv2.go

@@ -15,7 +15,9 @@ import (
 	"slices"
 	"strings"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 
@@ -44,6 +46,7 @@ type Notifier struct {
 	retrier      *notify.Retrier
 	webhookURL   *config.SecretURL
 	postJSONFunc func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error)
+	templater    alertmanagertypes.Templater
 }
 
 // https://learn.microsoft.com/en-us/connectors/teams/?tabs=text1#adaptivecarditemschema
@@ -52,7 +55,7 @@ type Content struct {
 	Type    string   `json:"type"`
 	Version string   `json:"version"`
 	Body    []Body   `json:"body"`
-	Msteams Msteams  `json:"msteams,omitempty"`
+	Msteams Msteams  `json:"msteams,omitzero"`
 	Actions []Action `json:"actions"`
 }
 
@@ -94,7 +97,7 @@ type teamsMessage struct {
 }
 
 // New returns a new notifier that uses the Microsoft Teams Power Platform connector.
-func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -109,6 +112,7 @@ func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *s
 		retrier:      &notify.Retrier{},
 		webhookURL:   c.WebhookURL,
 		postJSONFunc: notify.PostJSON,
+		templater:    templater,
 	}
 
 	return n, nil
@@ -128,25 +132,11 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		return false, err
 	}
 
-	title := tmpl(n.conf.Title)
-	if err != nil {
-		return false, err
-	}
-
 	titleLink := tmpl(n.titleLink)
 	if err != nil {
 		return false, err
 	}
 
-	alerts := types.Alerts(as...)
-	color := colorGrey
-	switch alerts.Status() {
-	case model.AlertFiring:
-		color = colorRed
-	case model.AlertResolved:
-		color = colorGreen
-	}
-
 	var url string
 	if n.conf.WebhookURL != nil {
 		url = n.conf.WebhookURL.String()
@@ -158,6 +148,12 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		url = strings.TrimSpace(string(content))
 	}
 
+	bodyBlocks, err := n.prepareContent(ctx, as)
+	if err != nil {
+		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+		return false, err
+	}
+
 	// A message as referenced in https://learn.microsoft.com/en-us/connectors/teams/?tabs=text1%2Cdotnet#request-body-schema
 	t := teamsMessage{
 		Type: "message",
@@ -169,17 +165,7 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 					Schema:  "http://adaptivecards.io/schemas/adaptive-card.json",
 					Type:    "AdaptiveCard",
 					Version: "1.2",
-					Body: []Body{
-						{
-							Type:   "TextBlock",
-							Text:   title,
-							Weight: "Bolder",
-							Size:   "Medium",
-							Wrap:   true,
-							Style:  "heading",
-							Color:  color,
-						},
-					},
+					Body:    bodyBlocks,
 					Actions: []Action{
 						{
 							Type:  "Action.OpenUrl",
@@ -195,20 +181,6 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		},
 	}
 
-	// add labels and annotations to the body of all alerts
-	for _, alert := range as {
-		t.Attachments[0].Content.Body = append(t.Attachments[0].Content.Body, Body{
-			Type:   "TextBlock",
-			Text:   "Alerts",
-			Weight: "Bolder",
-			Size:   "Medium",
-			Wrap:   true,
-			Color:  color,
-		})
-
-		t.Attachments[0].Content.Body = append(t.Attachments[0].Content.Body, n.createLabelsAndAnnotationsBody(alert)...)
-	}
-
 	var payload bytes.Buffer
 	if err = json.NewEncoder(&payload).Encode(t); err != nil {
 		return false, err
@@ -228,6 +200,75 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	return shouldRetry, err
 }
 
+// prepareContent builds the Adaptive Card body blocks for the notification.
+// The first block is always the title; the remainder depends on whether the
+// alerts carried a custom body template.
+func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) ([]Body, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Title,
+		DefaultBodyTemplate:  n.conf.Text,
+	}, alerts)
+	if err != nil {
+		return nil, err
+	}
+
+	color := colorGrey
+	switch types.Alerts(alerts...).Status() {
+	case model.AlertFiring:
+		color = colorRed
+	case model.AlertResolved:
+		color = colorGreen
+	}
+
+	blocks := []Body{{
+		Type:   "TextBlock",
+		Text:   result.Title,
+		Weight: "Bolder",
+		Size:   "Medium",
+		Wrap:   true,
+		Style:  "heading",
+		Color:  color,
+	}}
+
+	if result.IsDefaultBody {
+		for _, alert := range alerts {
+			blocks = append(blocks, Body{
+				Type:   "TextBlock",
+				Text:   "Alerts",
+				Weight: "Bolder",
+				Size:   "Medium",
+				Wrap:   true,
+				Color:  color,
+			})
+			blocks = append(blocks, n.createLabelsAndAnnotationsBody(alert)...)
+		}
+		return blocks, nil
+	}
+
+	// Custom body path: result.Body is positionally aligned with alerts;
+	// entries for alerts whose template rendered empty are kept as "" so we
+	// can skip them here without shifting the per-alert color index.
+	for i, body := range result.Body {
+		if body == "" || i >= len(alerts) {
+			continue
+		}
+		perAlertColor := colorRed
+		if alerts[i].Resolved() {
+			perAlertColor = colorGreen
+		}
+		blocks = append(blocks, Body{
+			Type:  "TextBlock",
+			Text:  body,
+			Wrap:  true,
+			Color: perAlertColor,
+		})
+	}
+	return blocks, nil
+}
+
 func (*Notifier) createLabelsAndAnnotationsBody(alert *types.Alert) []Body {
 	bodies := []Body{}
 	bodies = append(bodies, Body{
@@ -258,7 +299,8 @@ func (*Notifier) createLabelsAndAnnotationsBody(alert *types.Alert) []Body {
 
 	annotationsFacts := []Fact{}
 	for k, v := range alert.Annotations {
-		if slices.Contains([]string{"summary", "related_logs", "related_traces"}, string(k)) {
+		if slices.Contains([]string{"summary", "related_logs", "related_traces"}, string(k)) ||
+			alertmanagertypes.IsPrivateAnnotation(string(k)) {
 			continue
 		}
 		annotationsFacts = append(annotationsFacts, Fact{Title: string(k), Value: string(v)})

pkg/alertmanager/alertmanagernotify/msteamsv2/msteamsv2_test.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -15,6 +16,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -23,21 +27,28 @@ import (
 	test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
 	"github.com/prometheus/alertmanager/types"
 )
 
+func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
 // This is a test URL that has been modified to not be valid.
 var testWebhookURL, _ = url.Parse("https://example.westeurope.logic.azure.com:443/workflows/xxx/triggers/manual/paths/invoke?api-version=2016-06-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=xxx")
 
 func TestMSTeamsV2Retry(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURL: &config.SecretURL{URL: testWebhookURL},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -64,14 +75,16 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.MSTeamsV2Config{
 					WebhookURL: &config.SecretURL{URL: testWebhookURL},
 					HTTPConfig: &commoncfg.HTTPClientConfig{},
 				},
-				test.CreateTmpl(t),
+				tmpl,
 				`{{ template "msteamsv2.default.titleLink" . }}`,
 				promslog.NewNopLogger(),
+				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -153,7 +166,8 @@ func TestMSTeamsV2Templating(t *testing.T) {
 		t.Run(tc.title, func(t *testing.T) {
 			tc.cfg.WebhookURL = &config.SecretURL{URL: u}
 			tc.cfg.HTTPConfig = &commoncfg.HTTPClientConfig{}
-			pd, err := New(tc.cfg, test.CreateTmpl(t), tc.titleLink, promslog.NewNopLogger())
+			tmpl := test.CreateTmpl(t)
+			pd, err := New(tc.cfg, tmpl, tc.titleLink, promslog.NewNopLogger(), newTestTemplater(tmpl))
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -186,20 +200,124 @@ func TestMSTeamsV2RedactedURL(t *testing.T) {
 	defer fn()
 
 	secret := "secret"
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURL: &config.SecretURL{URL: u},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
 	test.AssertNotifyLeaksNoSecret(ctx, t, notifier, secret)
 }
 
+func TestPrepareContent(t *testing.T) {
+	t.Run("default template - firing alerts", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		notifier, err := New(
+			&config.MSTeamsV2Config{
+				WebhookURL: &config.SecretURL{URL: testWebhookURL},
+				HTTPConfig: &commoncfg.HTTPClientConfig{},
+				Title:      "Alertname: {{ .CommonLabels.alertname }}",
+			},
+			tmpl,
+			`{{ template "msteamsv2.default.titleLink" . }}`,
+			promslog.NewNopLogger(),
+			newTestTemplater(tmpl),
+		)
+		require.NoError(t, err)
+
+		ctx := context.Background()
+		ctx = notify.WithGroupKey(ctx, "1")
+
+		alerts := []*types.Alert{
+			{
+				Alert: model.Alert{
+					Labels: model.LabelSet{"alertname": "test"},
+					// Custom body template
+					Annotations: model.LabelSet{
+						ruletypes.AnnotationBodyTemplate: "Firing alert: $alertname",
+					},
+					StartsAt: time.Now(),
+					EndsAt:   time.Now().Add(time.Hour),
+				},
+			},
+		}
+		blocks, err := notifier.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.NotEmpty(t, blocks)
+		// First block should be the title with color (firing = red)
+		require.Equal(t, "Bolder", blocks[0].Weight)
+		require.Equal(t, colorRed, blocks[0].Color)
+		// verify title text
+		require.Equal(t, "Alertname: test", blocks[0].Text)
+		// verify body text
+		require.Equal(t, "Firing alert: test", blocks[1].Text)
+	})
+
+	t.Run("custom template - per-alert color", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		notifier, err := New(
+			&config.MSTeamsV2Config{
+				WebhookURL: &config.SecretURL{URL: testWebhookURL},
+				HTTPConfig: &commoncfg.HTTPClientConfig{},
+			},
+			tmpl,
+			`{{ template "msteamsv2.default.titleLink" . }}`,
+			promslog.NewNopLogger(),
+			newTestTemplater(tmpl),
+		)
+		require.NoError(t, err)
+
+		ctx := context.Background()
+		ctx = notify.WithGroupKey(ctx, "1")
+
+		alerts := []*types.Alert{
+			{
+				Alert: model.Alert{
+					Labels: model.LabelSet{"alertname": "test1"},
+					Annotations: model.LabelSet{
+						"summary":                         "test",
+						ruletypes.AnnotationTitleTemplate: "Custom Title",
+						ruletypes.AnnotationBodyTemplate:  "custom body $alertname",
+					},
+					StartsAt: time.Now(),
+					EndsAt:   time.Now().Add(time.Hour),
+				},
+			},
+			{
+				Alert: model.Alert{
+					Labels: model.LabelSet{"alertname": "test2"},
+					Annotations: model.LabelSet{
+						"summary":                         "test",
+						ruletypes.AnnotationTitleTemplate: "Custom Title",
+						ruletypes.AnnotationBodyTemplate:  "custom body $alertname",
+					},
+					StartsAt: time.Now().Add(-time.Hour),
+					EndsAt:   time.Now().Add(-time.Minute),
+				},
+			},
+		}
+		blocks, err := notifier.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.NotEmpty(t, blocks)
+		// total 3 blocks: title and 2 body blocks
+		require.True(t, len(blocks) == 3)
+		// First block: title color is overall color of the alerts
+		require.Equal(t, colorRed, blocks[0].Color)
+		// verify title text
+		require.Equal(t, "Custom Title", blocks[0].Text)
+		// Body blocks should have per-alert color
+		require.Equal(t, colorRed, blocks[1].Color)   // firing
+		require.Equal(t, colorGreen, blocks[2].Color) // resolved
+	})
+}
+
 func TestMSTeamsV2ReadingURLFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
@@ -209,14 +327,16 @@ func TestMSTeamsV2ReadingURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n")
 	require.NoError(t, err, "writing to temp file failed")
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURLFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie.go

@@ -15,7 +15,10 @@ import (
 	"os"
 	"strings"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 
@@ -34,25 +37,27 @@ const maxMessageLenRunes = 130
 
 // Notifier implements a Notifier for OpsGenie notifications.
 type Notifier struct {
-	conf    *config.OpsGenieConfig
-	tmpl    *template.Template
-	logger  *slog.Logger
-	client  *http.Client
-	retrier *notify.Retrier
+	conf      *config.OpsGenieConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
 }
 
 // New returns a new OpsGenie notifier.
-func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return &Notifier{
-		conf:    c,
-		tmpl:    t,
-		logger:  l,
-		client:  client,
-		retrier: &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
+		conf:      c,
+		tmpl:      t,
+		logger:    l,
+		client:    client,
+		retrier:   &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
+		templater: templater,
 	}, nil
 }
 
@@ -123,6 +128,55 @@ func safeSplit(s, sep string) []string {
 	return b
 }
 
+// prepareContent expands alert templates and returns the OpsGenie-ready title
+// (truncated to the 130-rune limit) and HTML description. Custom bodies are
+// rendered to HTML and stitched together with <hr> dividers; default bodies
+// are joined with newlines (OpsGenie's legacy plain-text description).
+func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) (string, string, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Message,
+		DefaultBodyTemplate:  n.conf.Description,
+	}, alerts)
+	if err != nil {
+		return "", "", err
+	}
+
+	var description string
+	if result.IsDefaultBody {
+		description = strings.Join(result.Body, "\n")
+	} else {
+		var b strings.Builder
+		first := true
+		for _, part := range result.Body {
+			if part == "" {
+				continue
+			}
+			rendered, renderErr := markdownrenderer.RenderHTML(part)
+			if renderErr != nil {
+				return "", "", renderErr
+			}
+			if !first {
+				b.WriteString("<hr>")
+			}
+			b.WriteString("<div>")
+			b.WriteString(rendered)
+			b.WriteString("</div>")
+			first = false
+		}
+		description = b.String()
+	}
+
+	title, truncated := notify.TruncateInRunes(result.Title, maxMessageLenRunes)
+	if truncated {
+		n.logger.WarnContext(ctx, "Truncated message", slog.Int("max_runes", maxMessageLenRunes))
+	}
+
+	return title, description, nil
+}
+
 // Create requests for a list of alerts.
 func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*http.Request, bool, error) {
 	key, err := notify.ExtractGroupKey(ctx)
@@ -168,9 +222,10 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		}
 		requests = append(requests, req.WithContext(ctx))
 	default:
-		message, truncated := notify.TruncateInRunes(tmpl(n.conf.Message), maxMessageLenRunes)
-		if truncated {
-			logger.WarnContext(ctx, "Truncated message", slog.Any("alert", key), slog.Int("max_runes", maxMessageLenRunes))
+		message, description, err := n.prepareContent(ctx, as)
+		if err != nil {
+			n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+			return nil, false, err
 		}
 
 		createEndpointURL := n.conf.APIURL.Copy()
@@ -209,7 +264,7 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		msg := &opsGenieCreateMessage{
 			Alias:       alias,
 			Message:     message,
-			Description: tmpl(n.conf.Description),
+			Description: description,
 			Details:     details,
 			Source:      tmpl(n.conf.Source),
 			Responders:  responders,

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie_test.go

@@ -8,12 +8,16 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/url"
 	"os"
 	"testing"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -22,16 +26,23 @@ import (
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
 	"github.com/prometheus/alertmanager/notify/test"
+	"github.com/prometheus/alertmanager/template"
 	"github.com/prometheus/alertmanager/types"
 )
 
+func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
 func TestOpsGenieRetry(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -47,14 +58,16 @@ func TestOpsGenieRedactedURL(t *testing.T) {
 	defer fn()
 
 	key := "key"
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			APIURL:     &config.URL{URL: u},
 			APIKey:     config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -72,14 +85,16 @@ func TestGettingOpsGegineApikeyFromFile(t *testing.T) {
 	_, err = f.WriteString(key)
 	require.NoError(t, err, "writing to temp file failed")
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			APIURL:     &config.URL{URL: u},
 			APIKeyFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -202,7 +217,7 @@ func TestOpsGenie(t *testing.T) {
 		},
 	} {
 		t.Run(tc.title, func(t *testing.T) {
-			notifier, err := New(tc.cfg, tmpl, logger)
+			notifier, err := New(tc.cfg, tmpl, logger, newTestTemplater(tmpl))
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -278,7 +293,7 @@ func TestOpsGenieWithUpdate(t *testing.T) {
 		APIURL:       &config.URL{URL: u},
 		HTTPConfig:   &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
 	alert := &types.Alert{
 		Alert: model.Alert{
 			StartsAt: time.Now(),
@@ -321,7 +336,7 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 		APIURL:     &config.URL{URL: u},
 		HTTPConfig: &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
 
 	require.NoError(t, err)
 	requests, _, err := notifierWithUpdate.createRequests(ctx)
@@ -329,6 +344,99 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 	require.Equal(t, "GenieKey my_secret_api_key", requests[0].Header.Get("Authorization"))
 }
 
+func TestPrepareContent(t *testing.T) {
+	t.Run("default template", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		logger := promslog.NewNopLogger()
+
+		notifier := &Notifier{
+			conf: &config.OpsGenieConfig{
+				Message:     `{{ .CommonLabels.Message }}`,
+				Description: `{{ .CommonLabels.Description }}`,
+			},
+			tmpl:      tmpl,
+			logger:    logger,
+			templater: newTestTemplater(tmpl),
+		}
+
+		ctx := context.Background()
+		ctx = notify.WithGroupKey(ctx, "1")
+
+		alert := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					"Message":     "Firing alert: test",
+					"Description": "Check runbook for more details",
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+
+		alerts := []*types.Alert{alert}
+
+		title, desc, prepErr := notifier.prepareContent(ctx, alerts)
+		require.NoError(t, prepErr)
+		require.Equal(t, "Firing alert: test", title)
+		require.Equal(t, "Check runbook for more details", desc)
+	})
+
+	t.Run("custom template", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		logger := promslog.NewNopLogger()
+
+		notifier := &Notifier{
+			conf: &config.OpsGenieConfig{
+				Message:     `{{ .CommonLabels.Message }}`,
+				Description: `{{ .CommonLabels.Description }}`,
+			},
+			tmpl:      tmpl,
+			logger:    logger,
+			templater: newTestTemplater(tmpl),
+		}
+
+		ctx := context.Background()
+		ctx = notify.WithGroupKey(ctx, "1")
+
+		alert1 := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					"service":   "payment",
+					"namespace": "potter-the-harry",
+				},
+				Annotations: model.LabelSet{
+					ruletypes.AnnotationTitleTemplate: "High request throughput for $service",
+					ruletypes.AnnotationBodyTemplate:  "Alert firing in NS: $labels.namespace",
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+		alert2 := &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					"service":   "payment",
+					"namespace": "smart-the-rat",
+				},
+				Annotations: model.LabelSet{
+					ruletypes.AnnotationTitleTemplate: "High request throughput for $service",
+					ruletypes.AnnotationBodyTemplate:  "Alert firing in NS: $labels.namespace",
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		}
+
+		alerts := []*types.Alert{alert1, alert2}
+
+		title, desc, err := notifier.prepareContent(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "High request throughput for payment", title)
+		// Each alert body wrapped in <div>, separated by <hr>
+		require.Equal(t, "<div><p>Alert firing in NS: potter-the-harry</p>\n</div><hr><div><p>Alert firing in NS: smart-the-rat</p>\n</div>", desc)
+	})
+}
+
 func readBody(t *testing.T, r *http.Request) string {
 	t.Helper()
 	body, err := io.ReadAll(r.Body)

pkg/alertmanager/alertmanagernotify/pagerduty/pagerduty.go

@@ -15,7 +15,9 @@ import (
 	"os"
 	"strings"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/alecthomas/units"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
@@ -40,21 +42,22 @@ const (
 
 // Notifier implements a Notifier for PagerDuty notifications.
 type Notifier struct {
-	conf    *config.PagerdutyConfig
-	tmpl    *template.Template
-	logger  *slog.Logger
-	apiV1   string // for tests.
-	client  *http.Client
-	retrier *notify.Retrier
+	conf      *config.PagerdutyConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	apiV1     string // for tests.
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
 }
 
 // New returns a new PagerDuty notifier.
-func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
 	}
-	n := &Notifier{conf: c, tmpl: t, logger: l, client: client}
+	n := &Notifier{conf: c, tmpl: t, logger: l, client: client, templater: templater}
 	if c.ServiceKey != "" || c.ServiceKeyFile != "" {
 		n.apiV1 = "https://events.pagerduty.com/generic/2010-04-15/create_event.json"
 		// Retrying can solve the issue on 403 (rate limiting) and 5xx response codes.
@@ -143,11 +146,12 @@ func (n *Notifier) notifyV1(
 	key notify.Key,
 	data *template.Data,
 	details map[string]any,
+	title string,
 ) (bool, error) {
 	var tmplErr error
 	tmpl := notify.TmplText(n.tmpl, data, &tmplErr)
 
-	description, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV1DescriptionLenRunes)
+	description, truncated := notify.TruncateInRunes(title, maxV1DescriptionLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated description", slog.Any("key", key), slog.Int("max_runes", maxV1DescriptionLenRunes))
 	}
@@ -203,6 +207,7 @@ func (n *Notifier) notifyV2(
 	key notify.Key,
 	data *template.Data,
 	details map[string]any,
+	title string,
 ) (bool, error) {
 	var tmplErr error
 	tmpl := notify.TmplText(n.tmpl, data, &tmplErr)
@@ -211,7 +216,7 @@ func (n *Notifier) notifyV2(
 		n.conf.Severity = "error"
 	}
 
-	summary, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV2SummaryLenRunes)
+	summary, truncated := notify.TruncateInRunes(title, maxV2SummaryLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated summary", slog.Any("key", key), slog.Int("max_runes", maxV2SummaryLenRunes))
 	}
@@ -294,6 +299,22 @@ func (n *Notifier) notifyV2(
 	return retry, err
 }
 
+// prepareTitle expands the notification title. PagerDuty has no body surface
+// we care about — the description/summary field is what users see as the
+// incident headline, so we feed the configured Description as the default
+// title template and ignore any custom body_template entirely.
+func (n *Notifier) prepareTitle(ctx context.Context, alerts []*types.Alert) (string, error) {
+	customTitle, _ := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		DefaultTitleTemplate: n.conf.Description,
+	}, alerts)
+	if err != nil {
+		return "", err
+	}
+	return result.Title, nil
+}
+
 // Notify implements the Notifier interface.
 func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 	key, err := notify.ExtractGroupKey(ctx)
@@ -302,6 +323,12 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	}
 	logger := n.logger.With(slog.Any("group_key", key))
 
+	title, err := n.prepareTitle(ctx, as)
+	if err != nil {
+		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+		return false, err
+	}
+
 	var (
 		alerts    = types.Alerts(as...)
 		data      = notify.GetTemplateData(ctx, n.tmpl, as, logger)
@@ -329,7 +356,7 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	if n.apiV1 != "" {
 		nf = n.notifyV1
 	}
-	retry, err := nf(ctx, eventType, key, data, details)
+	retry, err := nf(ctx, eventType, key, data, details, title)
 	if err != nil {
 		if ctx.Err() != nil {
 			err = errors.WrapInternalf(err, errors.CodeInternal, "failed to notify PagerDuty: %v", context.Cause(ctx))

pkg/alertmanager/alertmanagernotify/pagerduty/pagerduty_test.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -17,7 +18,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -30,14 +34,20 @@ import (
 	"github.com/prometheus/alertmanager/types"
 )
 
+func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
 func TestPagerDutyRetryV1(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -49,13 +59,15 @@ func TestPagerDutyRetryV1(t *testing.T) {
 }
 
 func TestPagerDutyRetryV2(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			RoutingKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -71,13 +83,15 @@ func TestPagerDutyRedactedURLV1(t *testing.T) {
 	defer fn()
 
 	key := "01234567890123456789012345678901"
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -90,14 +104,16 @@ func TestPagerDutyRedactedURLV2(t *testing.T) {
 	defer fn()
 
 	key := "01234567890123456789012345678901"
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			URL:        &config.URL{URL: u},
 			RoutingKey: config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -114,13 +130,15 @@ func TestPagerDutyV1ServiceKeyFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKeyFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -138,14 +156,16 @@ func TestPagerDutyV2RoutingKeyFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			URL:            &config.URL{URL: u},
 			RoutingKeyFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -302,7 +322,8 @@ func TestPagerDutyTemplating(t *testing.T) {
 		t.Run(tc.title, func(t *testing.T) {
 			tc.cfg.URL = &config.URL{URL: u}
 			tc.cfg.HTTPConfig = &commoncfg.HTTPClientConfig{}
-			pd, err := New(tc.cfg, test.CreateTmpl(t), promslog.NewNopLogger())
+			tmpl := test.CreateTmpl(t)
+			pd, err := New(tc.cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
 			require.NoError(t, err)
 			if pd.apiV1 != "" {
 				pd.apiV1 = u.String()
@@ -392,13 +413,15 @@ func TestEventSizeEnforcement(t *testing.T) {
 		Details:    bigDetailsV1,
 	}
 
+	tmpl := test.CreateTmpl(t)
 	notifierV1, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -420,8 +443,9 @@ func TestEventSizeEnforcement(t *testing.T) {
 			RoutingKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -536,7 +560,8 @@ func TestPagerDutyEmptySrcHref(t *testing.T) {
 		Links:      links,
 	}
 
-	pagerDuty, err := New(&pagerDutyConfig, test.CreateTmpl(t), promslog.NewNopLogger())
+	pdTmpl := test.CreateTmpl(t)
+	pagerDuty, err := New(&pagerDutyConfig, pdTmpl, promslog.NewNopLogger(), newTestTemplater(pdTmpl))
 	require.NoError(t, err)
 
 	ctx := context.Background()
@@ -603,7 +628,8 @@ func TestPagerDutyTimeout(t *testing.T) {
 				Timeout:    tt.timeout,
 			}
 
-			pd, err := New(&cfg, test.CreateTmpl(t), promslog.NewNopLogger())
+			tmpl := test.CreateTmpl(t)
+			pd, err := New(&cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -881,3 +907,79 @@ func TestRenderDetails(t *testing.T) {
 		})
 	}
 }
+
+func TestPrepareContent(t *testing.T) {
+	prepareContext := func() context.Context {
+		ctx := context.Background()
+		ctx = notify.WithGroupKey(ctx, "1")
+		ctx = notify.WithReceiverName(ctx, "test-receiver")
+		ctx = notify.WithGroupLabels(ctx, model.LabelSet{"alertname": "HighCPU for Payment service"})
+		return ctx
+	}
+	t.Run("default template uses go text template config for title", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		notifier, err := New(
+			&config.PagerdutyConfig{
+				RoutingKey:  config.Secret("01234567890123456789012345678901"),
+				HTTPConfig:  &commoncfg.HTTPClientConfig{},
+				Description: `{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})`,
+			},
+			tmpl,
+			promslog.NewNopLogger(),
+			newTestTemplater(tmpl),
+		)
+		require.NoError(t, err)
+
+		ctx := prepareContext()
+
+		alerts := []*types.Alert{
+			{
+				Alert: model.Alert{
+					Labels:   model.LabelSet{"alertname": "HighCPU for Payment service"},
+					StartsAt: time.Now(),
+					EndsAt:   time.Now().Add(time.Hour),
+				},
+			},
+		}
+
+		title, err := notifier.prepareTitle(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "HighCPU for Payment service (FIRING)", title)
+	})
+
+	t.Run("custom template uses $variable annotation for title", func(t *testing.T) {
+		tmpl := test.CreateTmpl(t)
+		notifier, err := New(
+			&config.PagerdutyConfig{
+				RoutingKey: config.Secret("01234567890123456789012345678901"),
+				HTTPConfig: &commoncfg.HTTPClientConfig{},
+			},
+			tmpl,
+			promslog.NewNopLogger(),
+			newTestTemplater(tmpl),
+		)
+		require.NoError(t, err)
+
+		ctx := prepareContext()
+
+		alerts := []*types.Alert{
+			{
+				Alert: model.Alert{
+					Labels: model.LabelSet{
+						"alertname": "HighCPU",
+						"service":   "api-server",
+					},
+					Annotations: model.LabelSet{
+						ruletypes.AnnotationTitleTemplate: "$rule.name on $service is in $alert.status state",
+					},
+					StartsAt: time.Now().Add(-time.Hour),
+					EndsAt:   time.Now(),
+				},
+			},
+		}
+
+		title, err := notifier.prepareTitle(ctx, alerts)
+		require.NoError(t, err)
+		require.Equal(t, "HighCPU on api-server is in resolved state", title)
+	})
+}

pkg/alertmanager/alertmanagernotify/receiver.go

@@ -5,6 +5,7 @@ import (
 	"slices"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/email"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/googlechat"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/msteamsv2"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/opsgenie"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/pagerduty"
@@ -24,10 +25,11 @@ var customNotifierIntegrations = []string{
 	opsgenie.Integration,
 	slack.Integration,
 	msteamsv2.Integration,
+	googlechat.Integration,
 }
 
-func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger) ([]notify.Integration, error) {
-	upstreamIntegrations, err := receiver.BuildReceiverIntegrations(nc, tmpl, logger)
+func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {
+	upstreamIntegrations, err := receiver.BuildReceiverIntegrations(*nc.Receiver, tmpl, logger)
 	if err != nil {
 		return nil, err
 	}
@@ -53,23 +55,30 @@ func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Templ
 	}
 
 	for i, c := range nc.WebhookConfigs {
-		add(webhook.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return webhook.New(c, tmpl, l) })
+		add(webhook.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return webhook.New(c, tmpl, l, templater) })
 	}
 	for i, c := range nc.EmailConfigs {
-		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return email.New(c, tmpl, l), nil })
+		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
+			return email.New(c, tmpl, l, templater), nil
+		})
 	}
 	for i, c := range nc.PagerdutyConfigs {
-		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l) })
+		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l, templater) })
 	}
 	for i, c := range nc.OpsGenieConfigs {
-		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l) })
+		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l, templater) })
 	}
 	for i, c := range nc.SlackConfigs {
-		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l) })
+		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l, templater) })
 	}
 	for i, c := range nc.MSTeamsV2Configs {
 		add(msteamsv2.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
-			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l)
+			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l, templater)
+		})
+	}
+	for i, c := range nc.GoogleChatConfigs {
+		add(googlechat.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
+			return googlechat.New(c, tmpl, l, templater)
 		})
 	}
 

pkg/alertmanager/alertmanagernotify/slack/slack.go

@@ -14,7 +14,11 @@ import (
 	"os"
 	"strings"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -25,6 +29,8 @@ import (
 
 const (
 	Integration = "slack"
+	colorRed    = "#FF0000"
+	colorGreen  = "#00FF00"
 )
 
 // https://api.slack.com/reference/messaging/attachments#legacy_fields - 1024, no units given, assuming runes or characters.
@@ -32,17 +38,18 @@ const maxTitleLenRunes = 1024
 
 // Notifier implements a Notifier for Slack notifications.
 type Notifier struct {
-	conf    *config.SlackConfig
-	tmpl    *template.Template
-	logger  *slog.Logger
-	client  *http.Client
-	retrier *notify.Retrier
+	conf      *config.SlackConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
 
 	postJSONFunc func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error)
 }
 
 // New returns a new Slack notification handler.
-func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -54,6 +61,7 @@ func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, httpOpts .
 		logger:       l,
 		client:       client,
 		retrier:      &notify.Retrier{},
+		templater:    templater,
 		postJSONFunc: notify.PostJSON,
 	}, nil
 }
@@ -81,9 +89,10 @@ type attachment struct {
 	Actions    []config.SlackAction `json:"actions,omitempty"`
 	ImageURL   string               `json:"image_url,omitempty"`
 	ThumbURL   string               `json:"thumb_url,omitempty"`
-	Footer     string               `json:"footer"`
+	Footer     string               `json:"footer,omitempty"`
 	Color      string               `json:"color,omitempty"`
 	MrkdwnIn   []string             `json:"mrkdwn_in,omitempty"`
+	Blocks     []any                `json:"blocks,omitempty"`
 }
 
 // Notify implements the Notifier interface.
@@ -100,79 +109,15 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		data     = notify.GetTemplateData(ctx, n.tmpl, as, logger)
 		tmplText = notify.TmplText(n.tmpl, data, &err)
 	)
-	var markdownIn []string
 
-	if len(n.conf.MrkdwnIn) == 0 {
-		markdownIn = []string{"fallback", "pretext", "text"}
-	} else {
-		markdownIn = n.conf.MrkdwnIn
+	attachments, err := n.prepareContent(ctx, as, tmplText)
+	if err != nil {
+		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+		return false, err
 	}
 
-	title, truncated := notify.TruncateInRunes(tmplText(n.conf.Title), maxTitleLenRunes)
-	if truncated {
-		logger.WarnContext(ctx, "Truncated title", slog.Int("max_runes", maxTitleLenRunes))
-	}
-	att := &attachment{
-		Title:      title,
-		TitleLink:  tmplText(n.conf.TitleLink),
-		Pretext:    tmplText(n.conf.Pretext),
-		Text:       tmplText(n.conf.Text),
-		Fallback:   tmplText(n.conf.Fallback),
-		CallbackID: tmplText(n.conf.CallbackID),
-		ImageURL:   tmplText(n.conf.ImageURL),
-		ThumbURL:   tmplText(n.conf.ThumbURL),
-		Footer:     tmplText(n.conf.Footer),
-		Color:      tmplText(n.conf.Color),
-		MrkdwnIn:   markdownIn,
-	}
-
-	numFields := len(n.conf.Fields)
-	if numFields > 0 {
-		fields := make([]config.SlackField, numFields)
-		for index, field := range n.conf.Fields {
-			// Check if short was defined for the field otherwise fallback to the global setting
-			var short bool
-			if field.Short != nil {
-				short = *field.Short
-			} else {
-				short = n.conf.ShortFields
-			}
-
-			// Rebuild the field by executing any templates and setting the new value for short
-			fields[index] = config.SlackField{
-				Title: tmplText(field.Title),
-				Value: tmplText(field.Value),
-				Short: &short,
-			}
-		}
-		att.Fields = fields
-	}
-
-	numActions := len(n.conf.Actions)
-	if numActions > 0 {
-		actions := make([]config.SlackAction, numActions)
-		for index, action := range n.conf.Actions {
-			slackAction := config.SlackAction{
-				Type:  tmplText(action.Type),
-				Text:  tmplText(action.Text),
-				URL:   tmplText(action.URL),
-				Style: tmplText(action.Style),
-				Name:  tmplText(action.Name),
-				Value: tmplText(action.Value),
-			}
-
-			if action.ConfirmField != nil {
-				slackAction.ConfirmField = &config.SlackConfirmationField{
-					Title:       tmplText(action.ConfirmField.Title),
-					Text:        tmplText(action.ConfirmField.Text),
-					OkText:      tmplText(action.ConfirmField.OkText),
-					DismissText: tmplText(action.ConfirmField.DismissText),
-				}
-			}
-
-			actions[index] = slackAction
-		}
-		att.Actions = actions
+	if len(attachments) > 0 {
+		n.addFieldsAndActions(&attachments[0], tmplText)
 	}
 
 	req := &request{
@@ -182,7 +127,7 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		IconURL:     tmplText(n.conf.IconURL),
 		LinkNames:   n.conf.LinkNames,
 		Text:        tmplText(n.conf.MessageText),
-		Attachments: []attachment{*att},
+		Attachments: attachments,
 	}
 	if err != nil {
 		return false, err
@@ -238,6 +183,150 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	return retry, nil
 }
 
+// prepareContent expands alert templates and returns the Slack attachment(s)
+// ready to send. When alerts carry a custom body template, one title-only
+// attachment plus one body attachment per alert is returned so that each alert
+// can get its own firing/resolved color and per-alert action buttons.
+func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert, tmplText func(string) string) ([]attachment, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Title,
+		DefaultBodyTemplate:  n.conf.Text,
+	}, alerts)
+	if err != nil {
+		return nil, err
+	}
+
+	title, truncated := notify.TruncateInRunes(result.Title, maxTitleLenRunes)
+	if truncated {
+		n.logger.WarnContext(ctx, "Truncated title", slog.Int("max_runes", maxTitleLenRunes))
+	}
+
+	if result.IsDefaultBody {
+		var markdownIn []string
+		if len(n.conf.MrkdwnIn) == 0 {
+			markdownIn = []string{"fallback", "pretext", "text"}
+		} else {
+			markdownIn = n.conf.MrkdwnIn
+		}
+		return []attachment{
+			{
+				Title:      title,
+				TitleLink:  tmplText(n.conf.TitleLink),
+				Pretext:    tmplText(n.conf.Pretext),
+				Text:       result.Body[0],
+				Fallback:   tmplText(n.conf.Fallback),
+				CallbackID: tmplText(n.conf.CallbackID),
+				ImageURL:   tmplText(n.conf.ImageURL),
+				ThumbURL:   tmplText(n.conf.ThumbURL),
+				Footer:     tmplText(n.conf.Footer),
+				Color:      tmplText(n.conf.Color),
+				MrkdwnIn:   markdownIn,
+			},
+		}, nil
+	}
+
+	// Custom template path: one title attachment + one attachment per
+	// non-empty alert body. result.Body is positionally aligned with alerts,
+	// so we index alerts[i] directly and skip empty entries.
+	attachments := make([]attachment, 0, 1+len(result.Body))
+	attachments = append(attachments, attachment{
+		Title:     title,
+		TitleLink: tmplText(n.conf.TitleLink),
+	})
+
+	for i, body := range result.Body {
+		if body == "" || i >= len(alerts) {
+			continue
+		}
+
+		// Custom bodies are authored in markdown; render each non-empty body to
+		// Slack's mrkdwn flavour. Default bodies skip this because the Text
+		// template is already channel-ready.
+		rendered, renderErr := markdownrenderer.RenderSlackMrkdwn(body)
+		if renderErr != nil {
+			return nil, renderErr
+		}
+
+		color := colorRed
+		if alerts[i].Resolved() {
+			color = colorGreen
+		}
+		attachments = append(attachments, attachment{
+			Text:     rendered,
+			Color:    color,
+			MrkdwnIn: []string{"text"},
+			Actions:  buildRelatedLinkActions(alerts[i]),
+		})
+	}
+
+	return attachments, nil
+}
+
+// buildRelatedLinkActions returns the "View Related Logs/Traces" action
+// buttons for an alert, or nil when no related-link annotations are present.
+func buildRelatedLinkActions(alert *types.Alert) []config.SlackAction {
+	var actions []config.SlackAction
+	if link := alert.Annotations[ruletypes.AnnotationRelatedLogs]; link != "" {
+		actions = append(actions, config.SlackAction{Type: "button", Text: "View Related Logs", URL: string(link)})
+	}
+	if link := alert.Annotations[ruletypes.AnnotationRelatedTraces]; link != "" {
+		actions = append(actions, config.SlackAction{Type: "button", Text: "View Related Traces", URL: string(link)})
+	}
+	return actions
+}
+
+// addFieldsAndActions populates fields and actions on the attachment from the Slack config.
+func (n *Notifier) addFieldsAndActions(att *attachment, tmplText func(string) string) {
+	numFields := len(n.conf.Fields)
+	if numFields > 0 {
+		fields := make([]config.SlackField, numFields)
+		for index, field := range n.conf.Fields {
+			var short bool
+			if field.Short != nil {
+				short = *field.Short
+			} else {
+				short = n.conf.ShortFields
+			}
+			fields[index] = config.SlackField{
+				Title: tmplText(field.Title),
+				Value: tmplText(field.Value),
+				Short: &short,
+			}
+		}
+		att.Fields = fields
+	}
+
+	numActions := len(n.conf.Actions)
+	if numActions > 0 {
+		actions := make([]config.SlackAction, numActions)
+		for index, action := range n.conf.Actions {
+			slackAction := config.SlackAction{
+				Type:  tmplText(action.Type),
+				Text:  tmplText(action.Text),
+				URL:   tmplText(action.URL),
+				Style: tmplText(action.Style),
+				Name:  tmplText(action.Name),
+				Value: tmplText(action.Value),
+			}
+
+			if action.ConfirmField != nil {
+				slackAction.ConfirmField = &config.SlackConfirmationField{
+					Title:       tmplText(action.ConfirmField.Title),
+					Text:        tmplText(action.ConfirmField.Text),
+					OkText:      tmplText(action.ConfirmField.OkText),
+					DismissText: tmplText(action.ConfirmField.DismissText),
+				}
+			}
+
+			actions[index] = slackAction
+		}
+		att.Actions = actions
+	}
+}
+
 // checkResponseError parses out the error message from Slack API response.
 func checkResponseError(resp *http.Response) (bool, error) {
 	body, err := io.ReadAll(resp.Body)

pkg/alertmanager/alertmanagernotify/slack/slack_test.go

@@ -17,6 +17,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -29,13 +32,19 @@ import (
 	"github.com/prometheus/alertmanager/types"
 )
 
+func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
 func TestSlackRetry(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -49,13 +58,15 @@ func TestSlackRedactedURL(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURL:     &config.SecretURL{URL: u},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -71,13 +82,15 @@ func TestGettingSlackURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String())
 	require.NoError(t, err, "writing to temp file failed")
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURLFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -93,13 +106,15 @@ func TestTrimmingSlackURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n\n")
 	require.NoError(t, err, "writing to temp file failed")
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURLFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -184,6 +199,7 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			apiurl, _ := url.Parse("https://slack.com/post.Message")
+			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.SlackConfig{
 					NotifierConfig: config.NotifierConfig{},
@@ -191,8 +207,9 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 					APIURL:         &config.SecretURL{URL: apiurl},
 					Channel:        "channelname",
 				},
-				test.CreateTmpl(t),
+				tmpl,
 				promslog.NewNopLogger(),
+				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -242,6 +259,7 @@ func TestSlackTimeout(t *testing.T) {
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			u, _ := url.Parse("https://slack.com/post.Message")
+			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.SlackConfig{
 					NotifierConfig: config.NotifierConfig{},
@@ -250,8 +268,9 @@ func TestSlackTimeout(t *testing.T) {
 					Channel:        "channelname",
 					Timeout:        tt.timeout,
 				},
-				test.CreateTmpl(t),
+				tmpl,
 				promslog.NewNopLogger(),
+				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 			notifier.postJSONFunc = func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error) {
@@ -282,6 +301,225 @@ func TestSlackTimeout(t *testing.T) {
 	}
 }
 
+// setupTestContext creates a context with group key, receiver name, and group labels
+// required by the notification processor.
+func setupTestContext() context.Context {
+	ctx := context.Background()
+	ctx = notify.WithGroupKey(ctx, "test-group")
+	ctx = notify.WithReceiverName(ctx, "slack")
+	ctx = notify.WithGroupLabels(ctx, model.LabelSet{
+		"alertname": "TestAlert",
+		"severity":  "critical",
+	})
+	return ctx
+}
+
+func TestPrepareContent(t *testing.T) {
+	t.Run("default template uses go text template config for title and body", func(t *testing.T) {
+		// When alerts have no custom annotation templates (title_template / body_template),
+		tmpl := test.CreateTmpl(t)
+		templater := newTestTemplater(tmpl)
+		notifier := &Notifier{
+			conf: &config.SlackConfig{
+				Title:     `{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})`,
+				Text:      `{{ range .Alerts }}Alert: {{ .Labels.alertname }} - severity {{ .Labels.severity }}{{ end }}`,
+				Color:     `{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}`,
+				TitleLink: "https://alertmanager.signoz.com",
+			},
+			tmpl:      tmpl,
+			logger:    slog.New(slog.DiscardHandler),
+			templater: templater,
+		}
+
+		ctx := setupTestContext()
+		alerts := []*types.Alert{
+			{Alert: model.Alert{
+				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			}},
+		}
+
+		// Build tmplText the same way Notify does
+		var err error
+		data := notify.GetTemplateData(ctx, tmpl, alerts, slog.New(slog.DiscardHandler))
+		tmplText := notify.TmplText(tmpl, data, &err)
+
+		atts, attErr := notifier.prepareContent(ctx, alerts, tmplText)
+		require.NoError(t, attErr)
+		require.NoError(t, err)
+		require.Len(t, atts, 1)
+
+		require.Equal(t, "HighCPU (FIRING)", atts[0].Title)
+		require.Equal(t, "Alert: HighCPU - severity critical", atts[0].Text)
+		// Color is templated — firing alert should be "danger"
+		require.Equal(t, "danger", atts[0].Color)
+		// No BlockKit blocks for default template
+		require.Nil(t, atts[0].Blocks)
+		// Default markdownIn when config has none
+		require.Equal(t, []string{"fallback", "pretext", "text"}, atts[0].MrkdwnIn)
+	})
+
+	t.Run("custom template produces 1+N attachments with per-alert color", func(t *testing.T) {
+		// When alerts carry custom $variable annotation templates (title_template / body_template)
+		tmpl := test.CreateTmpl(t)
+		templater := newTestTemplater(tmpl)
+		notifier := &Notifier{
+			conf: &config.SlackConfig{
+				Title:     "default title fallback",
+				Text:      "default text fallback",
+				TitleLink: "https://alertmanager.signoz.com",
+			},
+			tmpl:      tmpl,
+			logger:    slog.New(slog.DiscardHandler),
+			templater: templater,
+		}
+		tmplText := func(s string) string { return s }
+
+		bodyTemplate := `## $rule.name
+
+**Service:** *$labels.service*
+**Instance:** *$labels.instance*
+**Region:** *$labels.region*
+**Method:** *$labels.http_method*
+
+---
+
+| Metric | Value |
+|--------|-------|
+| **Current** | *$value* |
+| **Threshold** | *$threshold.value* |
+
+**Status:** $alert.status | **Severity:** $labels.severity`
+		titleTemplate := "[$alert.status] $rule.name — $labels.service"
+
+		ctx := setupTestContext()
+		firingAlert := &types.Alert{
+			Alert: model.Alert{
+				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical", "service": "api-server", "instance": "i-0abc123", "region": "us-east-1", "http_method": "GET"},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+				Annotations: model.LabelSet{
+					ruletypes.AnnotationTitleTemplate: model.LabelValue(titleTemplate),
+					ruletypes.AnnotationBodyTemplate:  model.LabelValue(bodyTemplate),
+					"value":                           "100",
+					"threshold.value":                 "200",
+				},
+			},
+		}
+		resolvedAlert := &types.Alert{
+			Alert: model.Alert{
+				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical", "service": "api-server", "instance": "i-0abc123", "region": "us-east-1", "http_method": "GET"},
+				StartsAt: time.Now().Add(-2 * time.Hour),
+				EndsAt:   time.Now().Add(-time.Hour),
+				Annotations: model.LabelSet{
+					ruletypes.AnnotationTitleTemplate: model.LabelValue(titleTemplate),
+					ruletypes.AnnotationBodyTemplate:  model.LabelValue(bodyTemplate),
+					"value":                           "50",
+					"threshold.value":                 "200",
+				},
+			},
+		}
+
+		atts, err := notifier.prepareContent(ctx, []*types.Alert{firingAlert, resolvedAlert}, tmplText)
+		require.NoError(t, err)
+
+		// 1 title attachment + 2 body attachments (one per alert)
+		require.Len(t, atts, 3)
+
+		// First attachment: title-only, no color, no blocks
+		require.Equal(t, "[firing] HighCPU — api-server", atts[0].Title)
+		require.Empty(t, atts[0].Color)
+		require.Nil(t, atts[0].Blocks)
+		require.Equal(t, "https://alertmanager.signoz.com", atts[0].TitleLink)
+
+		expectedFiringBody := "*HighCPU*\n\n" +
+			"*Service:* _api-server_\n*Instance:* _i-0abc123_\n*Region:* _us-east-1_\n*Method:* _GET_\n\n" +
+			"---\n\n" +
+			"```\nMetric    | Value\n----------|------\nCurrent   | 100  \nThreshold | 200  \n```\n\n" +
+			"*Status:* firing | *Severity:* critical\n\n"
+
+		expectedResolvedBody := "*HighCPU*\n\n" +
+			"*Service:* _api-server_\n*Instance:* _i-0abc123_\n*Region:* _us-east-1_\n*Method:* _GET_\n\n" +
+			"---\n\n" +
+			"```\nMetric    | Value\n----------|------\nCurrent   | 50   \nThreshold | 200  \n```\n\n" +
+			"*Status:* resolved | *Severity:* critical\n\n"
+
+		// Second attachment: firing alert body rendered as slack mrkdwn text, red color
+		require.Nil(t, atts[1].Blocks)
+		require.Equal(t, "#FF0000", atts[1].Color)
+		require.Equal(t, []string{"text"}, atts[1].MrkdwnIn)
+		require.Equal(t, expectedFiringBody, atts[1].Text)
+
+		// Third attachment: resolved alert body rendered as slack mrkdwn text, green color
+		require.Nil(t, atts[2].Blocks)
+		require.Equal(t, "#00FF00", atts[2].Color)
+		require.Equal(t, []string{"text"}, atts[2].MrkdwnIn)
+		require.Equal(t, expectedResolvedBody, atts[2].Text)
+	})
+
+	t.Run("default template with fields and actions", func(t *testing.T) {
+		// Verifies that addFieldsAndActions (called from Notify after prepareContent)
+		// correctly populates fields and actions on the attachment from config.
+		tmpl := test.CreateTmpl(t)
+		templater := newTestTemplater(tmpl)
+		short := true
+		notifier := &Notifier{
+			conf: &config.SlackConfig{
+				Title: `{{ .CommonLabels.alertname }}`,
+				Text:  "alert text",
+				Color: "warning",
+				Fields: []*config.SlackField{
+					{Title: "Severity", Value: "critical", Short: &short},
+					{Title: "Service", Value: "api-server", Short: &short},
+				},
+				Actions: []*config.SlackAction{
+					{Type: "button", Text: "View Alert", URL: "https://alertmanager.signoz.com"},
+				},
+				TitleLink: "https://alertmanager.signoz.com",
+			},
+			tmpl:      tmpl,
+			logger:    slog.New(slog.DiscardHandler),
+			templater: templater,
+		}
+		tmplText := func(s string) string { return s }
+
+		ctx := setupTestContext()
+		alerts := []*types.Alert{
+			{Alert: model.Alert{
+				Labels:   model.LabelSet{ruletypes.LabelAlertName: "TestAlert"},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			}},
+		}
+		atts, err := notifier.prepareContent(ctx, alerts, tmplText)
+		require.NoError(t, err)
+		require.Len(t, atts, 1)
+
+		// prepareContent does not populate fields/actions — that's done by
+		// addFieldsAndActions which is called from Notify.
+		require.Nil(t, atts[0].Fields)
+		require.Nil(t, atts[0].Actions)
+
+		// Simulate what Notify does after prepareContent
+		notifier.addFieldsAndActions(&atts[0], tmplText)
+
+		// Verify fields
+		require.Len(t, atts[0].Fields, 2)
+		require.Equal(t, "Severity", atts[0].Fields[0].Title)
+		require.Equal(t, "critical", atts[0].Fields[0].Value)
+		require.True(t, *atts[0].Fields[0].Short)
+		require.Equal(t, "Service", atts[0].Fields[1].Title)
+		require.Equal(t, "api-server", atts[0].Fields[1].Value)
+
+		// Verify actions
+		require.Len(t, atts[0].Actions, 1)
+		require.Equal(t, "button", atts[0].Actions[0].Type)
+		require.Equal(t, "View Alert", atts[0].Actions[0].Text)
+		require.Equal(t, "https://alertmanager.signoz.com", atts[0].Actions[0].URL)
+	})
+}
+
 func TestSlackMessageField(t *testing.T) {
 	// 1. Setup a fake Slack server
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -329,7 +567,7 @@ func TestSlackMessageField(t *testing.T) {
 	tmpl.ExternalURL = u
 
 	logger := slog.New(slog.DiscardHandler)
-	notifier, err := New(conf, tmpl, logger)
+	notifier, err := New(conf, tmpl, logger, newTestTemplater(tmpl))
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/alertmanager/alertmanagernotify/webhook/webhook.go

@@ -14,6 +14,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -28,15 +29,16 @@ const (
 
 // Notifier implements a Notifier for generic webhooks.
 type Notifier struct {
-	conf    *config.WebhookConfig
-	tmpl    *template.Template
-	logger  *slog.Logger
-	client  *http.Client
-	retrier *notify.Retrier
+	conf      *config.WebhookConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
 }
 
 // New returns a new Webhook.
-func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -48,7 +50,8 @@ func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, httpO
 		client: client,
 		// Webhooks are assumed to respond with 2xx response codes on a successful
 		// request and 5xx response codes are assumed to be recoverable.
-		retrier: &notify.Retrier{},
+		retrier:   &notify.Retrier{},
+		templater: templater,
 	}, nil
 }
 

pkg/alertmanager/alertmanagernotify/webhook/webhook_test.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -20,6 +21,7 @@ import (
 	"github.com/prometheus/common/promslog"
 	"github.com/stretchr/testify/require"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
 	"github.com/prometheus/alertmanager/notify/test"
@@ -27,13 +29,15 @@ import (
 )
 
 func TestWebhookRetry(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.WebhookConfig{
 			URL:        config.SecretTemplateURL("http://example.com"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	if err != nil {
 		require.NoError(t, err)
@@ -96,13 +100,16 @@ func TestWebhookRedactedURL(t *testing.T) {
 	defer fn()
 
 	secret := "secret"
+	tmpl := test.CreateTmpl(t)
+	templater := alertmanagertemplate.New(tmpl, slog.Default())
 	notifier, err := New(
 		&config.WebhookConfig{
 			URL:        config.SecretTemplateURL(u.String()),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		templater,
 	)
 	require.NoError(t, err)
 
@@ -118,13 +125,15 @@ func TestWebhookReadingURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n")
 	require.NoError(t, err, "writing to temp file failed")
 
+	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.WebhookConfig{
 			URLFile:    f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		test.CreateTmpl(t),
+		tmpl,
 		promslog.NewNopLogger(),
+		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	require.NoError(t, err)
 
@@ -178,13 +187,15 @@ func TestWebhookURLTemplating(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			calledURL = "" // Reset for each test
 
+			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.WebhookConfig{
 					URL:        config.SecretTemplateURL(tc.url),
 					HTTPConfig: &commoncfg.HTTPClientConfig{},
 				},
-				test.CreateTmpl(t),
+				tmpl,
 				promslog.NewNopLogger(),
+				alertmanagertemplate.New(tmpl, slog.Default()),
 			)
 			require.NoError(t, err)
 

pkg/alertmanager/alertmanagerserver/config.go

@@ -28,6 +28,13 @@ type Config struct {
 
 	// Configuration for the notification log.
 	NFLog NFLogConfig `mapstructure:"nflog"`
+
+	// Templates is the list of globs from which SigNoz's alertmanager notification
+	// templates are loaded (e.g. the email.signoz.html layout). This mirrors the
+	// upstream alertmanager `templates` config option (https://github.com/prometheus/alertmanager/blob/3b06b97af4d146e141af92885a185891eb79a5b0/config/config.go#L412).
+	// The upstream default templates (default.tmpl, email.tmpl) are always loaded
+	// from the embedded alertmanager assets, so only SigNoz's own templates are listed here.
+	Templates []string `mapstructure:"templates"`
 }
 
 type AlertsConfig struct {
@@ -100,5 +107,6 @@ func NewConfig() Config {
 			MaintenanceInterval: 15 * time.Minute,
 			Retention:           120 * time.Hour,
 		},
+		Templates: []string{"/root/templates/alertmanager/*.gotmpl"},
 	}
 }

pkg/alertmanager/alertmanagerserver/server.go

@@ -2,6 +2,8 @@ package alertmanagerserver
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"log/slog"
 	"strings"
 	"sync"
@@ -10,6 +12,7 @@ import (
 	"github.com/prometheus/alertmanager/types"
 	"golang.org/x/sync/errgroup"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/prometheus/alertmanager/dispatch"
 	"github.com/prometheus/alertmanager/featurecontrol"
 	"github.com/prometheus/alertmanager/inhibit"
@@ -23,8 +26,8 @@ import (
 	"github.com/prometheus/common/model"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 )
 
@@ -65,6 +68,7 @@ type Server struct {
 	muter               *MaintenanceMuter
 	marker              *types.MemMarker
 	tmpl                *template.Template
+	templater           alertmanagertypes.Templater
 	wg                  sync.WaitGroup
 	stopc               chan struct{}
 	notificationManager nfmanager.NotificationManager
@@ -240,15 +244,25 @@ func (server *Server) PutAlerts(ctx context.Context, postableAlerts alertmanager
 
 func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertmanagertypes.Config) error {
 	config := alertmanagerConfig.AlertmanagerConfig()
+	jsun, kerr := json.Marshal(config)
+	fmt.Println("yo config here", string(jsun), kerr)
 
 	var err error
-	server.tmpl, err = alertmanagertypes.FromGlobs(config.Templates)
+	// Load SigNoz's alertmanager notification templates from the configured
+	// globs. The upstream default templates (default.tmpl, email.tmpl) are
+	// always loaded from the embedded alertmanager assets inside FromGlobs, so
+	// only SigNoz's own templates (e.g. the email.signoz.html layout) are listed
+	// here. The upstream config.Templates field is not used: SigNoz never
+	// populates it (there is no per-org template configuration).
+	server.tmpl, err = alertmanagertypes.FromGlobs(server.srvConfig.Templates)
 	if err != nil {
 		return err
 	}
 
 	server.tmpl.ExternalURL = server.srvConfig.ExternalURL
 
+	server.templater = alertmanagertemplate.New(server.tmpl, server.logger)
+
 	// Build the routing tree and record which receivers are used.
 	routes := dispatch.NewRoute(config.Route, nil)
 	activeReceivers := make(map[string]struct{})
@@ -265,7 +279,11 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 			server.logger.InfoContext(ctx, "skipping creation of receiver not referenced by any route", slog.String("receiver", rcv.Name))
 			continue
 		}
-		integrations, err := alertmanagernotify.NewReceiverIntegrations(rcv, server.tmpl, server.logger)
+		extendedRcv, err := alertmanagerConfig.GetReceiver(rcv.Name)
+		if err != nil {
+			return err
+		}
+		integrations, err := alertmanagernotify.NewReceiverIntegrations(extendedRcv, server.tmpl, server.logger, server.templater)
 		if err != nil {
 			return err
 		}
@@ -340,9 +358,9 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 	return nil
 }
 
-func (server *Server) TestReceiver(ctx context.Context, receiver alertmanagertypes.Receiver) error {
-	testAlert := alertmanagertypes.NewTestAlert(receiver, time.Now(), time.Now())
-	return alertmanagertypes.TestReceiver(ctx, receiver, alertmanagernotify.NewReceiverIntegrations, server.alertmanagerConfig, server.tmpl, server.logger, testAlert.Labels, testAlert)
+func (server *Server) TestReceiver(ctx context.Context, receiver *alertmanagertypes.Receiver) error {
+	testAlert := alertmanagertypes.NewTestAlert(*receiver.Receiver, time.Now(), time.Now())
+	return alertmanagertypes.TestReceiver(ctx, receiver, alertmanagernotify.NewReceiverIntegrations, server.alertmanagerConfig, server.tmpl, server.logger, server.templater, testAlert.Labels, testAlert)
 }
 
 func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmanagertypes.PostableAlert][]string, config *alertmanagertypes.NotificationConfig) error {
@@ -410,7 +428,7 @@ func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmana
 			receiverName := receiverName
 
 			g.Go(func() error {
-				receiver, err := server.alertmanagerConfig.GetReceiver(receiverName)
+				baseReceiver, err := server.alertmanagerConfig.GetReceiver(receiverName)
 				if err != nil {
 					mu.Lock()
 					errs = append(errs, errors.WrapInternalf(err, errors.CodeInternal, "failed to get receiver %q", receiverName))
@@ -420,11 +438,12 @@ func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmana
 
 				err = alertmanagertypes.TestReceiver(
 					gCtx,
-					receiver,
+					baseReceiver,
 					alertmanagernotify.NewReceiverIntegrations,
 					server.alertmanagerConfig,
 					server.tmpl,
 					server.logger,
+					server.templater,
 					group.groupLabels,
 					group.alerts...,
 				)

pkg/alertmanager/alertmanagerserver/server_test.go

@@ -75,12 +75,14 @@ func TestServerTestReceiverTypeWebhook(t *testing.T) {
 	webhookURL, err := url.Parse("http://" + webhookListener.Addr().String() + "/webhook")
 	require.NoError(t, err)
 
-	err = server.TestReceiver(context.Background(), alertmanagertypes.Receiver{
-		Name: "test-receiver",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL(webhookURL.String()),
+	err = server.TestReceiver(context.Background(), &alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "test-receiver",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL(webhookURL.String()),
+				},
 			},
 		},
 	})
@@ -101,12 +103,14 @@ func TestServerPutAlerts(t *testing.T) {
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
 	require.NoError(t, err)
 
-	require.NoError(t, amConfig.CreateReceiver(alertmanagertypes.Receiver{
-		Name: "test-receiver",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL("http://localhost/test-receiver"),
+	require.NoError(t, amConfig.CreateReceiver(&alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "test-receiver",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL("http://localhost/test-receiver"),
+				},
 			},
 		},
 	}))
@@ -181,22 +185,26 @@ func TestServerTestAlert(t *testing.T) {
 	webhook2URL, err := url.Parse("http://" + webhook2Listener.Addr().String() + "/webhook")
 	require.NoError(t, err)
 
-	require.NoError(t, amConfig.CreateReceiver(alertmanagertypes.Receiver{
-		Name: "receiver-1",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL(webhook1URL.String()),
+	require.NoError(t, amConfig.CreateReceiver(&alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "receiver-1",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL(webhook1URL.String()),
+				},
 			},
 		},
 	}))
 
-	require.NoError(t, amConfig.CreateReceiver(alertmanagertypes.Receiver{
-		Name: "receiver-2",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL(webhook2URL.String()),
+	require.NoError(t, amConfig.CreateReceiver(&alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "receiver-2",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL(webhook2URL.String()),
+				},
 			},
 		},
 	}))
@@ -273,22 +281,26 @@ func TestServerTestAlertContinuesOnFailure(t *testing.T) {
 	webhookURL, err := url.Parse("http://" + webhookListener.Addr().String() + "/webhook")
 	require.NoError(t, err)
 
-	require.NoError(t, amConfig.CreateReceiver(alertmanagertypes.Receiver{
-		Name: "working-receiver",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL(webhookURL.String()),
+	require.NoError(t, amConfig.CreateReceiver(&alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "working-receiver",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL(webhookURL.String()),
+				},
 			},
 		},
 	}))
 
-	require.NoError(t, amConfig.CreateReceiver(alertmanagertypes.Receiver{
-		Name: "failing-receiver",
-		WebhookConfigs: []*config.WebhookConfig{
-			{
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				URL:        config.SecretTemplateURL("http://localhost:1/webhook"),
+	require.NoError(t, amConfig.CreateReceiver(&alertmanagertypes.Receiver{
+		Receiver: &config.Receiver{
+			Name: "failing-receiver",
+			WebhookConfigs: []*config.WebhookConfig{
+				{
+					HTTPConfig: &commoncfg.HTTPClientConfig{},
+					URL:        config.SecretTemplateURL("http://localhost:1/webhook"),
+				},
 			},
 		},
 	}))

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go

@@ -15,13 +15,6 @@ import (
 	"github.com/prometheus/common/model"
 )
 
-// Templater expands user-authored title and body templates against a group
-// of alerts and returns channel-ready strings along with the aggregate data
-// a caller might reuse (e.g. to render an email layout around the body).
-type Templater interface {
-	Expand(ctx context.Context, req alertmanagertypes.ExpandRequest, alerts []*types.Alert) (*alertmanagertypes.ExpandResult, error)
-}
-
 type templater struct {
 	tmpl   *template.Template
 	logger *slog.Logger
@@ -29,7 +22,7 @@ type templater struct {
 
 // New returns a Templater bound to the given Prometheus alertmanager
 // template and logger.
-func New(tmpl *template.Template, logger *slog.Logger) Templater {
+func New(tmpl *template.Template, logger *slog.Logger) alertmanagertypes.Templater {
 	return &templater{tmpl: tmpl, logger: logger}
 }
 
@@ -137,6 +130,9 @@ func (at *templater) expandTitle(
 }
 
 // expandBody expands the body template for each individual alert. Returns nil if the template is empty.
+// Non-nil results are positionally aligned with ntd.Alerts: sb[i] corresponds to alerts[i], and
+// entries for alerts whose template expands to empty are kept as "" so callers can index per-alert
+// metadata (related links, firing/resolved color) by the same index.
 func (at *templater) expandBody(
 	bodyTemplate string,
 	ntd *alertmanagertypes.NotificationTemplateData,
@@ -144,7 +140,7 @@ func (at *templater) expandBody(
 	if bodyTemplate == "" {
 		return nil, nil, nil
 	}
-	var sb []string
+	sb := make([]string, len(ntd.Alerts))
 	missingVars := make(map[string]bool)
 	for i := range ntd.Alerts {
 		processRes, err := preProcessTemplateAndData(bodyTemplate, &ntd.Alerts[i])
@@ -155,13 +151,10 @@ func (at *templater) expandBody(
 		if err != nil {
 			return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom body template: %s", err.Error())
 		}
-		// add unknown variables and templated text to the result
 		for k := range processRes.UnknownVars {
 			missingVars[k] = true
 		}
-		if strings.TrimSpace(part) != "" {
-			sb = append(sb, strings.TrimSpace(part))
-		}
+		sb[i] = strings.TrimSpace(part)
 	}
 	return sb, missingVars, nil
 }
@@ -189,17 +182,20 @@ func (at *templater) buildNotificationTemplateData(
 		externalURL = at.tmpl.ExternalURL.String()
 	}
 
-	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
+	// Raw (including private `_*`) kv first so buildRuleInfo can read the
+	// private rule annotations. The filtered copies are what ends up
+	// on the template-visible surfaces.
+	rawCommonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
 	commonLabels := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
 
 	// aggregate labels and annotations from all alerts
 	labels := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
 	annotations := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
 
-	// Strip private annotations from surfaces visible to templates or
-	// notifications; the structured fields on AlertInfo/RuleInfo already hold
-	// anything a template needs from them.
-	commonAnnotations = alertmanagertypes.FilterPublicAnnotations(commonAnnotations)
+	// Strip private annotations from template-visible surfaces; the structured
+	// fields on AlertInfo/RuleInfo already hold anything a template needs from
+	// them.
+	commonAnnotations := alertmanagertypes.FilterPublicAnnotations(rawCommonAnnotations)
 	annotations = alertmanagertypes.FilterPublicAnnotations(annotations)
 
 	// build the alert data slice
@@ -233,7 +229,7 @@ func (at *templater) buildNotificationTemplateData(
 			TotalFiring:   firing,
 			TotalResolved: resolved,
 		},
-		Rule:              buildRuleInfo(commonLabels, commonAnnotations),
+		Rule:              buildRuleInfo(commonLabels, rawCommonAnnotations),
 		GroupLabels:       gl,
 		CommonLabels:      commonLabels,
 		CommonAnnotations: commonAnnotations,

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate_test.go

@@ -19,7 +19,7 @@ import (
 
 // testSetup returns an AlertTemplater and a context pre-populated with group key,
 // receiver name, and group labels for use in tests.
-func testSetup(t *testing.T) (Templater, context.Context) {
+func testSetup(t *testing.T) (alertmanagertypes.Templater, context.Context) {
 	t.Helper()
 	tmpl := test.CreateTmpl(t)
 	ctx := context.Background()

pkg/alertmanager/alertmanagertest/alertmanager.go

@@ -110,7 +110,7 @@ func (_c *MockAlertmanager_Collect_Call) RunAndReturn(run func(context1 context.
 }
 
 // CreateChannel provides a mock function for the type MockAlertmanager
-func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string, v alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
+func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string, v *alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
 	ret := _mock.Called(context1, s, v)
 
 	if len(ret) == 0 {
@@ -119,17 +119,17 @@ func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string,
 
 	var r0 *alertmanagertypes.Channel
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)); ok {
 		return returnFunc(context1, s, v)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) *alertmanagertypes.Channel); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.Receiver) *alertmanagertypes.Channel); ok {
 		r0 = returnFunc(context1, s, v)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*alertmanagertypes.Channel)
 		}
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *alertmanagertypes.Receiver) error); ok {
 		r1 = returnFunc(context1, s, v)
 	} else {
 		r1 = ret.Error(1)
@@ -145,12 +145,12 @@ type MockAlertmanager_CreateChannel_Call struct {
 // CreateChannel is a helper method to define mock.On call
 //   - context1 context.Context
 //   - s string
-//   - v alertmanagertypes.Receiver
+//   - v *alertmanagertypes.Receiver
 func (_e *MockAlertmanager_Expecter) CreateChannel(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_CreateChannel_Call {
 	return &MockAlertmanager_CreateChannel_Call{Call: _e.mock.On("CreateChannel", context1, s, v)}
 }
 
-func (_c *MockAlertmanager_CreateChannel_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_CreateChannel_Call {
+func (_c *MockAlertmanager_CreateChannel_Call) Run(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver)) *MockAlertmanager_CreateChannel_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -160,9 +160,9 @@ func (_c *MockAlertmanager_CreateChannel_Call) Run(run func(context1 context.Con
 		if args[1] != nil {
 			arg1 = args[1].(string)
 		}
-		var arg2 alertmanagertypes.Receiver
+		var arg2 *alertmanagertypes.Receiver
 		if args[2] != nil {
-			arg2 = args[2].(alertmanagertypes.Receiver)
+			arg2 = args[2].(*alertmanagertypes.Receiver)
 		}
 		run(
 			arg0,
@@ -178,7 +178,7 @@ func (_c *MockAlertmanager_CreateChannel_Call) Return(channel *alertmanagertypes
 	return _c
 }
 
-func (_c *MockAlertmanager_CreateChannel_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)) *MockAlertmanager_CreateChannel_Call {
+func (_c *MockAlertmanager_CreateChannel_Call) RunAndReturn(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)) *MockAlertmanager_CreateChannel_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -1579,7 +1579,7 @@ func (_c *MockAlertmanager_TestAlert_Call) RunAndReturn(run func(ctx context.Con
 }
 
 // TestReceiver provides a mock function for the type MockAlertmanager
-func (_mock *MockAlertmanager) TestReceiver(context1 context.Context, s string, v alertmanagertypes.Receiver) error {
+func (_mock *MockAlertmanager) TestReceiver(context1 context.Context, s string, v *alertmanagertypes.Receiver) error {
 	ret := _mock.Called(context1, s, v)
 
 	if len(ret) == 0 {
@@ -1587,7 +1587,7 @@ func (_mock *MockAlertmanager) TestReceiver(context1 context.Context, s string,
 	}
 
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.Receiver) error); ok {
 		r0 = returnFunc(context1, s, v)
 	} else {
 		r0 = ret.Error(0)
@@ -1603,12 +1603,12 @@ type MockAlertmanager_TestReceiver_Call struct {
 // TestReceiver is a helper method to define mock.On call
 //   - context1 context.Context
 //   - s string
-//   - v alertmanagertypes.Receiver
+//   - v *alertmanagertypes.Receiver
 func (_e *MockAlertmanager_Expecter) TestReceiver(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_TestReceiver_Call {
 	return &MockAlertmanager_TestReceiver_Call{Call: _e.mock.On("TestReceiver", context1, s, v)}
 }
 
-func (_c *MockAlertmanager_TestReceiver_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_TestReceiver_Call {
+func (_c *MockAlertmanager_TestReceiver_Call) Run(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver)) *MockAlertmanager_TestReceiver_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -1618,9 +1618,9 @@ func (_c *MockAlertmanager_TestReceiver_Call) Run(run func(context1 context.Cont
 		if args[1] != nil {
 			arg1 = args[1].(string)
 		}
-		var arg2 alertmanagertypes.Receiver
+		var arg2 *alertmanagertypes.Receiver
 		if args[2] != nil {
-			arg2 = args[2].(alertmanagertypes.Receiver)
+			arg2 = args[2].(*alertmanagertypes.Receiver)
 		}
 		run(
 			arg0,
@@ -1636,7 +1636,7 @@ func (_c *MockAlertmanager_TestReceiver_Call) Return(err error) *MockAlertmanage
 	return _c
 }
 
-func (_c *MockAlertmanager_TestReceiver_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) error) *MockAlertmanager_TestReceiver_Call {
+func (_c *MockAlertmanager_TestReceiver_Call) RunAndReturn(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver) error) *MockAlertmanager_TestReceiver_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -1705,7 +1705,7 @@ func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) RunAndReturn(run
 }
 
 // UpdateChannelByReceiverAndID provides a mock function for the type MockAlertmanager
-func (_mock *MockAlertmanager) UpdateChannelByReceiverAndID(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error {
+func (_mock *MockAlertmanager) UpdateChannelByReceiverAndID(context1 context.Context, s string, v *alertmanagertypes.Receiver, uUID valuer.UUID) error {
 	ret := _mock.Called(context1, s, v, uUID)
 
 	if len(ret) == 0 {
@@ -1713,7 +1713,7 @@ func (_mock *MockAlertmanager) UpdateChannelByReceiverAndID(context1 context.Con
 	}
 
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver, valuer.UUID) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.Receiver, valuer.UUID) error); ok {
 		r0 = returnFunc(context1, s, v, uUID)
 	} else {
 		r0 = ret.Error(0)
@@ -1729,13 +1729,13 @@ type MockAlertmanager_UpdateChannelByReceiverAndID_Call struct {
 // UpdateChannelByReceiverAndID is a helper method to define mock.On call
 //   - context1 context.Context
 //   - s string
-//   - v alertmanagertypes.Receiver
+//   - v *alertmanagertypes.Receiver
 //   - uUID valuer.UUID
 func (_e *MockAlertmanager_Expecter) UpdateChannelByReceiverAndID(context1 interface{}, s interface{}, v interface{}, uUID interface{}) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
 	return &MockAlertmanager_UpdateChannelByReceiverAndID_Call{Call: _e.mock.On("UpdateChannelByReceiverAndID", context1, s, v, uUID)}
 }
 
-func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID)) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
+func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Run(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver, uUID valuer.UUID)) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -1745,9 +1745,9 @@ func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Run(run func(conte
 		if args[1] != nil {
 			arg1 = args[1].(string)
 		}
-		var arg2 alertmanagertypes.Receiver
+		var arg2 *alertmanagertypes.Receiver
 		if args[2] != nil {
-			arg2 = args[2].(alertmanagertypes.Receiver)
+			arg2 = args[2].(*alertmanagertypes.Receiver)
 		}
 		var arg3 valuer.UUID
 		if args[3] != nil {
@@ -1768,7 +1768,7 @@ func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Return(err error)
 	return _c
 }
 
-func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
+func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) RunAndReturn(run func(context1 context.Context, s string, v *alertmanagertypes.Receiver, uUID valuer.UUID) error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
 	_c.Call.Return(run)
 	return _c
 }

pkg/alertmanager/service.go

@@ -138,7 +138,7 @@ func (service *Service) PutAlerts(ctx context.Context, orgID string, alerts aler
 	return server.PutAlerts(ctx, alerts)
 }
 
-func (service *Service) TestReceiver(ctx context.Context, orgID string, receiver alertmanagertypes.Receiver) error {
+func (service *Service) TestReceiver(ctx context.Context, orgID string, receiver *alertmanagertypes.Receiver) error {
 	service.serversMtx.RLock()
 	defer service.serversMtx.RUnlock()
 

pkg/alertmanager/signozalertmanager/provider.go

@@ -110,7 +110,7 @@ func (provider *provider) PutAlerts(ctx context.Context, orgID string, alerts al
 	return provider.service.PutAlerts(ctx, orgID, alerts)
 }
 
-func (provider *provider) TestReceiver(ctx context.Context, orgID string, receiver alertmanagertypes.Receiver) error {
+func (provider *provider) TestReceiver(ctx context.Context, orgID string, receiver *alertmanagertypes.Receiver) error {
 	return provider.service.TestReceiver(ctx, orgID, receiver)
 }
 
@@ -151,7 +151,7 @@ func (provider *provider) GetChannelByID(ctx context.Context, orgID string, chan
 	return provider.configStore.GetChannelByID(ctx, orgID, channelID)
 }
 
-func (provider *provider) UpdateChannelByReceiverAndID(ctx context.Context, orgID string, receiver alertmanagertypes.Receiver, id valuer.UUID) error {
+func (provider *provider) UpdateChannelByReceiverAndID(ctx context.Context, orgID string, receiver *alertmanagertypes.Receiver, id valuer.UUID) error {
 	channel, err := provider.configStore.GetChannelByID(ctx, orgID, id)
 	if err != nil {
 		return err
@@ -210,7 +210,7 @@ func (provider *provider) DeleteChannelByID(ctx context.Context, orgID string, c
 	}))
 }
 
-func (provider *provider) CreateChannel(ctx context.Context, orgID string, receiver alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
+func (provider *provider) CreateChannel(ctx context.Context, orgID string, receiver *alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
 	config, err := provider.configStore.Get(ctx, orgID)
 	if err != nil {
 		return nil, err

pkg/emailing/config.go

@@ -65,7 +65,7 @@ func newConfig() factory.Config {
 	return &Config{
 		Enabled: false,
 		Templates: Templates{
-			Directory: "/root/templates",
+			Directory: "/root/templates/email",
 			Format: Format{
 				Header: Header{
 					Enabled: false,

pkg/flagger/registry.go

@@ -3,14 +3,15 @@ package flagger
 import "github.com/SigNoz/signoz/pkg/types/featuretypes"
 
 var (
-	FeatureUseSpanMetrics    = featuretypes.MustNewName("use_span_metrics")
-	FeatureKafkaSpanEval     = featuretypes.MustNewName("kafka_span_eval")
-	FeatureHideRootUser      = featuretypes.MustNewName("hide_root_user")
-	FeatureGetMetersFromZeus = featuretypes.MustNewName("get_meters_from_zeus")
-	FeaturePutMetersInZeus   = featuretypes.MustNewName("put_meters_in_zeus")
-	FeatureUseMeterReporter  = featuretypes.MustNewName("use_meter_reporter")
-	FeatureUseJSONBody            = featuretypes.MustNewName("use_json_body")
-	FeatureUseFineGrainedAuthz    = featuretypes.MustNewName("use_fine_grained_authz")
+	FeatureUseSpanMetrics      = featuretypes.MustNewName("use_span_metrics")
+	FeatureKafkaSpanEval       = featuretypes.MustNewName("kafka_span_eval")
+	FeatureHideRootUser        = featuretypes.MustNewName("hide_root_user")
+	FeatureGetMetersFromZeus   = featuretypes.MustNewName("get_meters_from_zeus")
+	FeaturePutMetersInZeus     = featuretypes.MustNewName("put_meters_in_zeus")
+	FeatureUseMeterReporter    = featuretypes.MustNewName("use_meter_reporter")
+	FeatureUseJSONBody         = featuretypes.MustNewName("use_json_body")
+	FeatureUseFineGrainedAuthz = featuretypes.MustNewName("use_fine_grained_authz")
+	FeatureUseDashboardV2      = featuretypes.MustNewName("use_dashboard_v2")
 )
 
 func MustNewRegistry() featuretypes.Registry {
@@ -79,6 +80,14 @@ func MustNewRegistry() featuretypes.Registry {
 			DefaultVariant: featuretypes.MustNewName("disabled"),
 			Variants:       featuretypes.NewBooleanVariants(),
 		},
+		&featuretypes.Feature{
+			Name:           FeatureUseDashboardV2,
+			Kind:           featuretypes.KindBoolean,
+			Stage:          featuretypes.StageExperimental,
+			Description:    "Controls whether dashboard v2 is enabled",
+			DefaultVariant: featuretypes.MustNewName("disabled"),
+			Variants:       featuretypes.NewBooleanVariants(),
+		},
 	)
 	if err != nil {
 		panic(err)

pkg/query-service/app/http_handler.go

@@ -1770,6 +1770,15 @@ func (aH *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 		Route:      "",
 	})
 
+	useDashboardV2 := aH.Signoz.Flagger.BooleanOrEmpty(r.Context(), flagger.FeatureUseDashboardV2, evalCtx)
+	featureSet = append(featureSet, &licensetypes.Feature{
+		Name:       valuer.NewString(flagger.FeatureUseDashboardV2.String()),
+		Active:     useDashboardV2,
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	})
+
 	if constants.IsDotMetricsEnabled {
 		for idx, feature := range featureSet {
 			if feature.Name == licensetypes.DotMetricsEnabled {

pkg/query-service/rules/threshold_rule.go

@@ -352,13 +352,13 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 			link := r.prepareLinksToTraces(ctx, ts, smpl.Metric)
 			if link != "" && r.hostFromSource() != "" {
 				r.logger.InfoContext(ctx, "adding traces link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/traces-explorer?%s", r.hostFromSource(), link)))
-				annotations = append(annotations, ruletypes.Label{Name: "related_traces", Value: fmt.Sprintf("%s/traces-explorer?%s", r.hostFromSource(), link)})
+				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedTraces, Value: fmt.Sprintf("%s/traces-explorer?%s", r.hostFromSource(), link)})
 			}
 		case ruletypes.AlertTypeLogs:
 			link := r.prepareLinksToLogs(ctx, ts, smpl.Metric)
 			if link != "" && r.hostFromSource() != "" {
 				r.logger.InfoContext(ctx, "adding logs link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/logs/logs-explorer?%s", r.hostFromSource(), link)))
-				annotations = append(annotations, ruletypes.Label{Name: "related_logs", Value: fmt.Sprintf("%s/logs/logs-explorer?%s", r.hostFromSource(), link)})
+				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedLogs, Value: fmt.Sprintf("%s/logs/logs-explorer?%s", r.hostFromSource(), link)})
 			}
 		}
 

pkg/query-service/rules/threshold_rule_test.go

@@ -869,7 +869,7 @@ func TestThresholdRuleTracesLink(t *testing.T) {
 			assert.Equal(t, c.expectAlerts, alertsFound, "case %d", idx)
 			for _, item := range rule.Active {
 				for name, value := range item.Annotations.Map() {
-					if name == "related_traces" {
+					if name == ruletypes.AnnotationRelatedTraces {
 						assert.NotEmpty(t, value, "case %d", idx)
 						assert.Contains(t, value, "GET")
 					}
@@ -986,7 +986,7 @@ func TestThresholdRuleLogsLink(t *testing.T) {
 			assert.Equal(t, c.expectAlerts, alertsFound, "case %d", idx)
 			for _, item := range rule.Active {
 				for name, value := range item.Annotations.Map() {
-					if name == "related_logs" {
+					if name == ruletypes.AnnotationRelatedLogs {
 						assert.NotEmpty(t, value, "case %d", idx)
 						assert.Contains(t, value, "testcontainer")
 					}

pkg/ruler/signozruler/handler.go

@@ -29,23 +29,15 @@ func (handler *handler) ListRules(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
 	rules, err := handler.ruler.ListRuleStates(ctx)
 	if err != nil {
 		render.Error(rw, err)
 		return
 	}
 
-	schedules, _ := handler.ruler.MaintenanceStore().ListPlannedMaintenance(ctx, claims.OrgID)
-
 	view := make([]*ruletypes.Rule, 0, len(rules.Rules))
 	for _, rule := range rules.Rules {
-		view = append(view, ruletypes.NewRule(rule, schedules))
+		view = append(view, ruletypes.NewRule(rule))
 	}
 
 	render.Success(rw, http.StatusOK, view)
@@ -55,12 +47,6 @@ func (handler *handler) GetRuleByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
 	id, err := valuer.NewUUID(mux.Vars(req)["id"])
 	if err != nil {
 		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
@@ -73,9 +59,7 @@ func (handler *handler) GetRuleByID(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	schedules, _ := handler.ruler.MaintenanceStore().ListPlannedMaintenance(ctx, claims.OrgID)
-
-	render.Success(rw, http.StatusOK, ruletypes.NewRule(rule, schedules))
+	render.Success(rw, http.StatusOK, ruletypes.NewRule(rule))
 }
 
 func (handler *handler) CreateRule(rw http.ResponseWriter, req *http.Request) {
@@ -95,7 +79,7 @@ func (handler *handler) CreateRule(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	render.Success(rw, http.StatusCreated, ruletypes.NewRule(rule, nil))
+	render.Success(rw, http.StatusCreated, ruletypes.NewRule(rule))
 }
 
 func (handler *handler) UpdateRuleByID(rw http.ResponseWriter, req *http.Request) {
@@ -166,7 +150,7 @@ func (handler *handler) PatchRuleByID(rw http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	render.Success(rw, http.StatusOK, ruletypes.NewRule(rule, nil))
+	render.Success(rw, http.StatusOK, ruletypes.NewRule(rule))
 }
 
 func (handler *handler) TestRule(rw http.ResponseWriter, req *http.Request) {

pkg/sqlmigration/014_add_alertmanager.go

@@ -269,7 +269,7 @@ func (migration *addAlertmanager) msTeamsChannelToMSTeamsV2Channel(c *alertmanag
 	return nil
 }
 
-func (migration *addAlertmanager) msTeamsReceiverToMSTeamsV2Receiver(receiver alertmanagertypes.Receiver) alertmanagertypes.Receiver {
+func (migration *addAlertmanager) msTeamsReceiverToMSTeamsV2Receiver(receiver *alertmanagertypes.Receiver) *alertmanagertypes.Receiver {
 	if receiver.MSTeamsConfigs == nil {
 		return receiver
 	}

pkg/types/alertmanagertypes/alert.go

@@ -13,6 +13,7 @@ import (
 	v2 "github.com/prometheus/alertmanager/api/v2"
 	"github.com/prometheus/alertmanager/api/v2/models"
 	"github.com/prometheus/alertmanager/api/v2/restapi/operations/alert"
+	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/dispatch"
 	"github.com/prometheus/alertmanager/matcher/compat"
 	"github.com/prometheus/alertmanager/pkg/labels"
@@ -134,7 +135,7 @@ func NewAlertsFromPostableAlerts(ctx context.Context, postableAlerts PostableAle
 	return validAlerts, errs
 }
 
-func NewTestAlert(receiver Receiver, startsAt time.Time, updatedAt time.Time) *Alert {
+func NewTestAlert(receiver config.Receiver, startsAt time.Time, updatedAt time.Time) *Alert {
 	return &Alert{
 		Alert: model.Alert{
 			StartsAt: startsAt,

pkg/types/alertmanagertypes/channel.go

@@ -10,7 +10,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/prometheus/alertmanager/config"
 	"github.com/swaggest/jsonschema-go"
 	"github.com/uptrace/bun"
 )
@@ -56,7 +55,7 @@ type Channel struct {
 
 // NewChannelFromReceiver creates a new Channel from a Receiver.
 // It can return nil if the receiver is the default receiver.
-func NewChannelFromReceiver(receiver config.Receiver, orgID string) (*Channel, error) {
+func NewChannelFromReceiver(receiver *Receiver, orgID string) (*Channel, error) {
 	if receiver.Name == DefaultReceiverName {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeAlertmanagerChannelInvalid, "cannot use %s name as a channel name", receiver.Name)
 	}
@@ -74,11 +73,34 @@ func NewChannelFromReceiver(receiver config.Receiver, orgID string) (*Channel, e
 		OrgID: orgID,
 	}
 
-	// Use reflection to examine receiver struct fields
-	receiverType := reflect.TypeOf(receiver)
-	receiverVal := reflect.ValueOf(receiver)
+	// The embedded *config.Receiver marshals inline, so this single Marshal emits
+	// both the upstream notifier configs and any SigNoz-native ones (e.g.
+	// googlechat_configs) — no separate merge step is required.
+	data, err := json.Marshal(receiver)
+	if err != nil {
+		return nil, err
+	}
+	channel.Data = string(data)
+
+	channel.Type = receiverChannelType(receiver)
+	if channel.Type == "" {
+		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeAlertmanagerChannelInvalid, "channel '%s' must have at least one notification configuration (e.g., email_configs, webhook_configs, slack_configs)", receiver.Name)
+	}
+
+	return &channel, nil
+}
+
+// receiverChannelType derives the channel.Type discriminator from the configured
+// notifier. SigNoz-native notifiers are checked first; upstream notifiers are
+// derived by reflecting over config.Receiver's *_configs fields.
+func receiverChannelType(receiver *Receiver) string {
+	if len(receiver.GoogleChatConfigs) > 0 {
+		return channelTypeGoogleChat
+	}
+
+	receiverType := reflect.TypeOf(*receiver.Receiver)
+	receiverVal := reflect.ValueOf(*receiver.Receiver)
 
-	// Iterate through fields looking for *Config fields
 	for i := 0; i < receiverType.NumField(); i++ {
 		field := receiverType.Field(i)
 		fieldVal := receiverVal.Field(i)
@@ -100,25 +122,10 @@ func NewChannelFromReceiver(receiver config.Receiver, orgID string) (*Channel, e
 			continue
 		}
 
-		channelType := matches[1]
-
-		// Marshal config data to JSON
-		configData, err := json.Marshal(receiver)
-		if err != nil {
-			continue
-		}
-
-		channel.Type = channelType
-		channel.Data = string(configData)
-		break
+		return matches[1]
 	}
 
-	// If we were unable to find the channel type, return an error
-	if channel.Type == "" {
-		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeAlertmanagerChannelInvalid, "channel '%s' must have at least one notification configuration (e.g., email_configs, webhook_configs, slack_configs)", receiver.Name)
-	}
-
-	return &channel, nil
+	return ""
 }
 
 func NewConfigFromChannels(globalConfig GlobalConfig, routeConfig RouteConfig, channels Channels, orgID string) (*Config, error) {
@@ -182,7 +189,7 @@ func NewStatsFromChannels(channels Channels) map[string]any {
 	return stats
 }
 
-func (c *Channel) Update(receiver Receiver) error {
+func (c *Channel) Update(receiver *Receiver) error {
 	channel, err := NewChannelFromReceiver(receiver, c.OrgID)
 	if err != nil {
 		return err
@@ -192,6 +199,7 @@ func (c *Channel) Update(receiver Receiver) error {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeAlertmanagerChannelNameMismatch, "cannot update channel name")
 	}
 
+	c.Type = channel.Type
 	c.Data = channel.Data
 	c.UpdatedAt = time.Now()
 

pkg/types/alertmanagertypes/channel_test.go

@@ -240,29 +240,25 @@ func TestNewConfigFromChannels(t *testing.T) {
 func TestNewChannelFromReceiver(t *testing.T) {
 	testCases := []struct {
 		name     string
-		receiver config.Receiver
+		receiver *Receiver
 		expected *Channel
 		pass     bool
 	}{
 		{
-			name: "InvalidReceiver_OnlyName",
-			receiver: config.Receiver{
-				Name: "test-receiver",
-			},
+			name:     "InvalidReceiver_OnlyName",
+			receiver: &Receiver{Receiver: &config.Receiver{Name: "test-receiver"}},
 			expected: nil,
 			pass:     false,
 		},
 		{
-			name: "InvalidReceiver_DefaultReceiver",
-			receiver: config.Receiver{
-				Name: DefaultReceiverName,
-			},
+			name:     "InvalidReceiver_DefaultReceiver",
+			receiver: &Receiver{Receiver: &config.Receiver{Name: DefaultReceiverName}},
 			expected: nil,
 			pass:     false,
 		},
 		{
 			name: "ValidReceiver_Slack",
-			receiver: config.Receiver{
+			receiver: &Receiver{Receiver: &config.Receiver{
 				Name: "test-receiver",
 				SlackConfigs: []*config.SlackConfig{
 					{
@@ -273,7 +269,7 @@ func TestNewChannelFromReceiver(t *testing.T) {
 						},
 					},
 				},
-			},
+			}},
 			expected: &Channel{
 				Name: "test-receiver",
 				Type: "slack",
@@ -281,6 +277,25 @@ func TestNewChannelFromReceiver(t *testing.T) {
 			},
 			pass: true,
 		},
+		{
+			name: "ValidReceiver_GoogleChat",
+			receiver: &Receiver{Receiver: &config.Receiver{
+				Name: "googlechat-receiver",
+			}, GoogleChatConfigs: []*GoogleChatReceiverConfig{
+				{
+					WebhookURL:        &config.SecretURL{URL: &url.URL{Scheme: "https", Host: "chat.googleapis.com", Path: "/v1/spaces/test/messages"}},
+					Title:             "Alert",
+					Text:              "Body",
+					SendResolvedValue: true,
+				},
+			}},
+			expected: &Channel{
+				Name: "googlechat-receiver",
+				Type: "googlechat",
+				Data: `{"name":"googlechat-receiver","googlechat_configs":[{"webhook_url":"https://chat.googleapis.com/v1/spaces/test/messages","title":"Alert","text":"Body","send_resolved":true}]}`,
+			},
+			pass: true,
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -294,7 +309,7 @@ func TestNewChannelFromReceiver(t *testing.T) {
 			assert.NoError(t, err)
 			assert.Equal(t, testCase.expected.Name, channel.Name)
 			assert.Equal(t, testCase.expected.Type, channel.Type)
-			assert.Equal(t, testCase.expected.Data, channel.Data)
+			assert.JSONEq(t, testCase.expected.Data, channel.Data)
 		})
 	}
 

pkg/types/alertmanagertypes/config.go

@@ -59,12 +59,41 @@ type Config struct {
 
 	// storeableConfig is the representation of the config in the store
 	storeableConfig *StoreableConfig
+
+	// customConfigs holds the SigNoz-native notifier configs (which the upstream
+	// config.Receiver cannot carry) keyed by receiver name. The upstream base of
+	// each receiver lives in alertmanagerConfig.Receivers; GetReceiver merges the
+	// two and newRawFromConfig serializes them together.
+	customConfigs map[string]customReceiverConfigs
+}
+
+// customReceiverConfigs are the SigNoz-native notifier configs for one receiver.
+type customReceiverConfigs struct {
+	GoogleChat []*GoogleChatReceiverConfig
+}
+
+func (c customReceiverConfigs) isEmpty() bool {
+	return len(c.GoogleChat) == 0
+}
+
+// storedConfig is the serialization unit persisted to StoreableConfig.Config.
+// Embedding *config.Config emits every upstream field (global, route,
+// inhibit_rules, templates, ...); the outer Receivers field shadows the embedded
+// config.Config.Receivers (both marshal to the JSON key "receivers", and the
+// shallower outer field dominates per encoding/json's visibility rules), so the
+// receivers are emitted as the extended *Receiver — carrying native configs —
+// without any post-marshal patching.
+type storedConfig struct {
+	*config.Config
+	Receivers []*Receiver `json:"receivers"`
 }
 
 func NewConfig(c *config.Config, orgID string) *Config {
-	raw := string(newRawFromConfig(c))
+	customConfigs := make(map[string]customReceiverConfigs)
+	raw := string(newRawFromConfig(c, customConfigs))
 	return &Config{
 		alertmanagerConfig: c,
+		customConfigs:      customConfigs,
 		storeableConfig: &StoreableConfig{
 			Identifiable: types.Identifiable{
 				ID: valuer.GenerateUUID(),
@@ -81,13 +110,14 @@ func NewConfig(c *config.Config, orgID string) *Config {
 }
 
 func NewConfigFromStoreableConfig(sc *StoreableConfig) (*Config, error) {
-	alertmanagerConfig, err := newConfigFromString(sc.Config)
+	alertmanagerConfig, customConfigs, err := newConfigFromString(sc.Config)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Config{
 		alertmanagerConfig: alertmanagerConfig,
+		customConfigs:      customConfigs,
 		storeableConfig:    sc,
 	}, nil
 }
@@ -113,32 +143,45 @@ func NewDefaultConfig(globalConfig GlobalConfig, routeConfig RouteConfig, orgID
 	}, orgID), nil
 }
 
-func newConfigFromString(s string) (*config.Config, error) {
-	config := new(config.Config)
-	err := json.Unmarshal([]byte(s), config)
-	if err != nil {
-		return nil, err
+func newConfigFromString(s string) (*config.Config, map[string]customReceiverConfigs, error) {
+	stored := storedConfig{Config: new(config.Config)}
+	if err := json.Unmarshal([]byte(s), &stored); err != nil {
+		return nil, nil, err
 	}
 
-	for i, receiver := range config.Receivers {
-		bytes, err := json.Marshal(receiver)
-		if err != nil {
-			return nil, err
-		}
+	amConfig := stored.Config
+	amConfig.Receivers = make([]config.Receiver, len(stored.Receivers))
+	customConfigs := make(map[string]customReceiverConfigs)
 
-		receiver, err := NewReceiver(string(bytes))
+	// Re-run each receiver through NewReceiver so upstream defaults are applied
+	// (mirrors the create path) and native configs are split off via the embed.
+	for i, rcv := range stored.Receivers {
+		rcvJSON, err := json.Marshal(rcv)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
+		}
+		parsed, err := NewReceiver(string(rcvJSON))
+		if err != nil {
+			return nil, nil, err
+		}
+		amConfig.Receivers[i] = *parsed.Receiver
+		if custom := customConfigsOf(parsed); !custom.isEmpty() {
+			customConfigs[parsed.Name] = custom
 		}
-
-		config.Receivers[i] = receiver
 	}
 
-	return config, nil
+	return amConfig, customConfigs, nil
 }
 
-func newRawFromConfig(c *config.Config) []byte {
-	b, err := json.Marshal(c)
+func newRawFromConfig(c *config.Config, customConfigs map[string]customReceiverConfigs) []byte {
+	receivers := make([]*Receiver, len(c.Receivers))
+	for i := range c.Receivers {
+		base := c.Receivers[i]
+		custom := customConfigs[base.Name]
+		receivers[i] = &Receiver{Receiver: &base, GoogleChatConfigs: custom.GoogleChat}
+	}
+
+	b, err := json.Marshal(storedConfig{Config: c, Receivers: receivers})
 	if err != nil {
 		// Taking inspiration from the upstream. This is never expected to happen.
 		return []byte(fmt.Sprintf("<error creating config string: %s>", err))
@@ -147,10 +190,25 @@ func newRawFromConfig(c *config.Config) []byte {
 	return b
 }
 
+// customConfigsOf extracts the SigNoz-native configs carried on a Receiver.
+func customConfigsOf(receiver *Receiver) customReceiverConfigs {
+	return customReceiverConfigs{GoogleChat: receiver.GoogleChatConfigs}
+}
+
 func newConfigHash(s string) [16]byte {
 	return md5.Sum([]byte(s))
 }
 
+// flush re-serializes the config into the storeable representation and refreshes
+// its hash and timestamp. Call it after every mutation of alertmanagerConfig or
+// customConfigs.
+func (c *Config) flush() {
+	raw := string(newRawFromConfig(c.alertmanagerConfig, c.customConfigs))
+	c.storeableConfig.Config = raw
+	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(raw))
+	c.storeableConfig.UpdatedAt = time.Now()
+}
+
 func (c *Config) CopyWithReset() (*Config, error) {
 	newConfig, err := NewDefaultConfig(
 		*c.alertmanagerConfig.Global,
@@ -179,9 +237,7 @@ func (c *Config) SetGlobalConfig(globalConfig GlobalConfig) error {
 	globalConfig.SMTPRequireTLS = smtpRequireTLS
 
 	c.alertmanagerConfig.Global = &globalConfig
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
@@ -193,9 +249,7 @@ func (c *Config) SetRouteConfig(routeConfig RouteConfig) error {
 	}
 	c.alertmanagerConfig.Route = route
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
@@ -207,9 +261,7 @@ func (c *Config) AddInhibitRules(rules []config.InhibitRule) error {
 
 	c.alertmanagerConfig.InhibitRules = append(c.alertmanagerConfig.InhibitRules, rules...)
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
@@ -222,7 +274,7 @@ func (c *Config) StoreableConfig() *StoreableConfig {
 	return c.storeableConfig
 }
 
-func (c *Config) CreateReceiver(receiver config.Receiver) error {
+func (c *Config) CreateReceiver(receiver *Receiver) error {
 	// check that receiver name is not already used
 	for _, existingReceiver := range c.alertmanagerConfig.Receivers {
 		if existingReceiver.Name == receiver.Name {
@@ -230,39 +282,45 @@ func (c *Config) CreateReceiver(receiver config.Receiver) error {
 		}
 	}
 
-	route, err := NewRouteFromReceiver(receiver)
+	route, err := NewRouteFromReceiver(receiver.Receiver)
 	if err != nil {
 		return err
 	}
 
 	c.alertmanagerConfig.Route.Routes = append(c.alertmanagerConfig.Route.Routes, route)
-	c.alertmanagerConfig.Receivers = append(c.alertmanagerConfig.Receivers, receiver)
+	c.alertmanagerConfig.Receivers = append(c.alertmanagerConfig.Receivers, *receiver.Receiver)
+	c.setCustomConfigs(receiver)
 
 	if err := c.alertmanagerConfig.UnmarshalYAML(func(i interface{}) error { return nil }); err != nil {
 		return err
 	}
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 	return nil
 }
 
-func (c *Config) GetReceiver(name string) (Receiver, error) {
-	for _, receiver := range c.alertmanagerConfig.Receivers {
-		if receiver.Name == name {
-			return receiver, nil
+func (c *Config) GetReceiver(name string) (*Receiver, error) {
+	for i := range c.alertmanagerConfig.Receivers {
+		if c.alertmanagerConfig.Receivers[i].Name == name {
+			// Copy the base out of the slice to avoid handing callers an aliased
+			// element (the slice may later be appended to / reallocated).
+			base := c.alertmanagerConfig.Receivers[i]
+			return &Receiver{
+				Receiver:          &base,
+				GoogleChatConfigs: c.customConfigs[name].GoogleChat,
+			}, nil
 		}
 	}
 
-	return Receiver{}, errors.Newf(errors.TypeNotFound, ErrCodeAlertmanagerChannelNotFound, "channel with name %q not found", name)
+	return nil, errors.Newf(errors.TypeNotFound, ErrCodeAlertmanagerChannelNotFound, "channel with name %q not found", name)
 }
 
-func (c *Config) UpdateReceiver(receiver config.Receiver) error {
+func (c *Config) UpdateReceiver(receiver *Receiver) error {
 	// find and update receiver
 	for i, existingReceiver := range c.alertmanagerConfig.Receivers {
 		if existingReceiver.Name == receiver.Name {
-			c.alertmanagerConfig.Receivers[i] = receiver
+			c.alertmanagerConfig.Receivers[i] = *receiver.Receiver
+			c.setCustomConfigs(receiver)
 			break
 		}
 	}
@@ -271,13 +329,20 @@ func (c *Config) UpdateReceiver(receiver config.Receiver) error {
 		return err
 	}
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
 
+// setCustomConfigs records (or clears) the SigNoz-native configs for a receiver.
+func (c *Config) setCustomConfigs(receiver *Receiver) {
+	if custom := customConfigsOf(receiver); !custom.isEmpty() {
+		c.customConfigs[receiver.Name] = custom
+	} else {
+		delete(c.customConfigs, receiver.Name)
+	}
+}
+
 func (c *Config) DeleteReceiver(name string) error {
 	if name == "" {
 		return errors.New(errors.TypeInvalidInput, ErrCodeAlertmanagerConfigInvalid, "delete receiver requires the receiver name")
@@ -298,9 +363,9 @@ func (c *Config) DeleteReceiver(name string) error {
 		}
 	}
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	delete(c.customConfigs, name)
+
+	c.flush()
 
 	return nil
 }
@@ -318,9 +383,7 @@ func (c *Config) CreateRuleIDMatcher(ruleID string, receiverNames []string) erro
 		}
 	}
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
@@ -339,9 +402,7 @@ func (c *Config) DeleteRuleIDInhibitor(ruleID string) error {
 		}
 	}
 	c.alertmanagerConfig.InhibitRules = filteredRules
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }
@@ -362,9 +423,7 @@ func (c *Config) DeleteRuleIDMatcher(ruleID string) error {
 		}
 	}
 
-	c.storeableConfig.Config = string(newRawFromConfig(c.alertmanagerConfig))
-	c.storeableConfig.Hash = fmt.Sprintf("%x", newConfigHash(c.storeableConfig.Config))
-	c.storeableConfig.UpdatedAt = time.Now()
+	c.flush()
 
 	return nil
 }

pkg/types/alertmanagertypes/config_test.go

@@ -108,7 +108,8 @@ func TestCreateRuleIDMatcher(t *testing.T) {
 			require.NoError(t, err)
 
 			for _, receiver := range tc.receivers {
-				err := cfg.CreateReceiver(receiver)
+				receiver := receiver
+				err := cfg.CreateReceiver(&Receiver{Receiver: &receiver})
 				require.NoError(t, err)
 			}
 
@@ -203,7 +204,8 @@ func TestDeleteRuleIDMatcher(t *testing.T) {
 			require.NoError(t, err)
 
 			for _, receiver := range tc.receivers {
-				err := cfg.CreateReceiver(receiver)
+				receiver := receiver
+				err := cfg.CreateReceiver(&Receiver{Receiver: &receiver})
 				require.NoError(t, err)
 			}
 
@@ -329,3 +331,78 @@ func TestSetGlobalConfigPreservesSMTPRequireTLS(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigPreservesCustomReceiverConfigs(t *testing.T) {
+	webhookURL, err := url.Parse("https://chat.googleapis.com/v1/spaces/test/messages")
+	require.NoError(t, err)
+
+	cfg, err := NewDefaultConfig(
+		GlobalConfig{SMTPSmarthost: config.HostPort{Host: "localhost", Port: "25"}, SMTPFrom: "test@example.com"},
+		RouteConfig{GroupInterval: time.Minute, GroupWait: time.Minute, RepeatInterval: time.Minute},
+		"1",
+	)
+	require.NoError(t, err)
+
+	receiver := &Receiver{
+		Receiver: &config.Receiver{Name: "googlechat-receiver"},
+		GoogleChatConfigs: []*GoogleChatReceiverConfig{
+			{
+				WebhookURL:        &config.SecretURL{URL: webhookURL},
+				Title:             "Alert",
+				Text:              "Body",
+				SendResolvedValue: true,
+			},
+		},
+	}
+
+	err = cfg.CreateReceiver(receiver)
+	require.NoError(t, err)
+
+	assertCustomConfigInStoreable(t, cfg.StoreableConfig().Config, "googlechat-receiver", "Alert")
+
+	reloaded, err := NewConfigFromStoreableConfig(cfg.StoreableConfig())
+	require.NoError(t, err)
+
+	reloadedReceiver, err := reloaded.GetReceiver("googlechat-receiver")
+	require.NoError(t, err)
+	require.Len(t, reloadedReceiver.GoogleChatConfigs, 1)
+	assert.Equal(t, "Alert", reloadedReceiver.GoogleChatConfigs[0].Title)
+
+	receiver.GoogleChatConfigs[0].Title = "Updated"
+	err = cfg.UpdateReceiver(receiver)
+	require.NoError(t, err)
+
+	assertCustomConfigInStoreable(t, cfg.StoreableConfig().Config, "googlechat-receiver", "Updated")
+}
+
+func assertCustomConfigInStoreable(t *testing.T, rawConfig string, receiverName string, expectedTitle string) {
+	t.Helper()
+
+	var configData map[string]any
+	err := json.Unmarshal([]byte(rawConfig), &configData)
+	require.NoError(t, err)
+
+	receiversRaw, ok := configData["receivers"].([]interface{})
+	require.True(t, ok)
+
+	var receiverMap map[string]any
+	for _, receiver := range receiversRaw {
+		receiverData, ok := receiver.(map[string]any)
+		if !ok {
+			continue
+		}
+		if receiverData["name"] == receiverName {
+			receiverMap = receiverData
+			break
+		}
+	}
+	require.NotNil(t, receiverMap)
+
+	configsRaw, ok := receiverMap["googlechat_configs"].([]interface{})
+	require.True(t, ok)
+	require.NotEmpty(t, configsRaw)
+
+	configEntry, ok := configsRaw[0].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, expectedTitle, configEntry["title"])
+}

pkg/types/alertmanagertypes/googlechat.go

@@ -0,0 +1,25 @@
+package alertmanagertypes
+
+import "github.com/prometheus/alertmanager/config"
+
+// channelTypeGoogleChat is the channel.Type discriminator for Google Chat
+// receivers. Unlike the upstream notifier types (slack, webhook, ...), Google
+// Chat is a SigNoz-native notifier, so it is not derivable by reflecting over
+// config.Receiver's fields.
+const channelTypeGoogleChat = "googlechat"
+
+// GoogleChatReceiverConfig is a SigNoz-native notifier config that upstream
+// alertmanager does not know about. It is carried on Receiver alongside the
+// embedded *config.Receiver and round-trips through JSON via that embed's
+// struct tags — no separate registry or marshalling is required.
+type GoogleChatReceiverConfig struct {
+	WebhookURL        *config.SecretURL `json:"webhook_url" yaml:"webhook_url"`
+	Title             string            `json:"title" yaml:"title"`
+	Text              string            `json:"text" yaml:"text"`
+	SendResolvedValue bool              `json:"send_resolved" yaml:"send_resolved"`
+}
+
+// SendResolved implements notify.ResolvedSender.
+func (c *GoogleChatReceiverConfig) SendResolved() bool {
+	return c != nil && c.SendResolvedValue
+}

pkg/types/alertmanagertypes/matcher_test.go

@@ -22,7 +22,7 @@ func TestAddRuleIDToRoute(t *testing.T) {
 		{
 			name: "Simple",
 			route: func() *config.Route {
-				route, err := NewRouteFromReceiver(Receiver{Name: "test"})
+				route, err := NewRouteFromReceiver(&config.Receiver{Name: "test"})
 				require.NoError(t, err)
 
 				return route
@@ -33,7 +33,7 @@ func TestAddRuleIDToRoute(t *testing.T) {
 		{
 			name: "AlreadyExists",
 			route: func() *config.Route {
-				route, err := NewRouteFromReceiver(Receiver{Name: "test"})
+				route, err := NewRouteFromReceiver(&config.Receiver{Name: "test"})
 				require.NoError(t, err)
 
 				err = addRuleIDToRoute(route, "1")
@@ -84,7 +84,7 @@ func TestRemoveRuleIDFromRoute(t *testing.T) {
 		{
 			name: "Simple",
 			route: func() *config.Route {
-				route, err := NewRouteFromReceiver(Receiver{Name: "test"})
+				route, err := NewRouteFromReceiver(&config.Receiver{Name: "test"})
 				require.NoError(t, err)
 
 				err = addRuleIDToRoute(route, "1")
@@ -98,7 +98,7 @@ func TestRemoveRuleIDFromRoute(t *testing.T) {
 		{
 			name: "DoesNotExist",
 			route: func() *config.Route {
-				route, err := NewRouteFromReceiver(Receiver{Name: "test"})
+				route, err := NewRouteFromReceiver(&config.Receiver{Name: "test"})
 				require.NoError(t, err)
 
 				return route
@@ -109,7 +109,7 @@ func TestRemoveRuleIDFromRoute(t *testing.T) {
 		{
 			name: "DeleteMatcher",
 			route: func() *config.Route {
-				route, err := NewRouteFromReceiver(Receiver{Name: "test"})
+				route, err := NewRouteFromReceiver(&config.Receiver{Name: "test"})
 				require.NoError(t, err)
 
 				return route

pkg/types/alertmanagertypes/notification.go

@@ -0,0 +1,20 @@
+package alertmanagertypes
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+)
+
+// Templater expands user-authored title and body templates against a group
+// of alerts. Implemented by pkg/alertmanager/alertmanagertemplate.
+type Templater interface {
+	Expand(ctx context.Context, req ExpandRequest, alerts []*types.Alert) (*ExpandResult, error)
+}
+
+// ReceiverIntegrationsFunc constructs the notify.Integration list for a
+// configured receiver.
+type ReceiverIntegrationsFunc = func(nc *Receiver, tmpl *template.Template, logger *slog.Logger, templater Templater) ([]notify.Integration, error)

pkg/types/alertmanagertypes/receiver.go

@@ -17,41 +17,61 @@ import (
 	"github.com/prometheus/alertmanager/config"
 )
 
-type (
-	// Receiver is the type for the receiver configuration.
-	Receiver                 = config.Receiver
-	ReceiverIntegrationsFunc = func(nc Receiver, tmpl *template.Template, logger *slog.Logger) ([]notify.Integration, error)
-)
-
-// Creates a new receiver from a string. The input is initialized with the default values from the upstream alertmanager.
-// The only default value which is missed is `send_resolved` (as it is a bool) which if not set in the input will always be set to `false`.
-func NewReceiver(input string) (Receiver, error) {
-	receiver := Receiver{}
-	err := json.Unmarshal([]byte(input), &receiver)
-	if err != nil {
-		return Receiver{}, err
-	}
-
-	// We marshal and unmarshal the receiver to ensure that the receiver is
-	// initialized with defaults from the upstream alertmanager.
-	bytes, err := yaml.Marshal(receiver)
-	if err != nil {
-		return Receiver{}, err
-	}
-
-	receiverWithDefaults := Receiver{}
-	if err := yaml.Unmarshal(bytes, &receiverWithDefaults); err != nil {
-		return Receiver{}, err
-	}
-
-	if err := receiverWithDefaults.UnmarshalYAML(func(i interface{}) error { return nil }); err != nil {
-		return Receiver{}, err
-	}
-
-	return receiverWithDefaults, nil
+// Receiver extends the upstream alertmanager config.Receiver with SigNoz-native
+// notifier configs (e.g. Google Chat) that upstream does not know about.
+//
+// The embedded *config.Receiver carries every upstream notifier field; the
+// SigNoz-native configs are declared alongside it. Because config.Receiver has
+// no custom (Un)MarshalJSON, encoding/json marshals the embed inline, so
+// json.Marshal and json.Unmarshal of a *Receiver round-trip both the upstream
+// and the native configs in a single pass — no side maps or field allow-lists
+// are needed. To add another native channel, add a field here and a loop in
+// alertmanagernotify.NewReceiverIntegrations.
+type Receiver struct {
+	*config.Receiver
+	GoogleChatConfigs []*GoogleChatReceiverConfig `json:"googlechat_configs,omitempty" yaml:"googlechat_configs,omitempty"`
 }
 
-func TestReceiver(ctx context.Context, receiver Receiver, receiverIntegrationsFunc ReceiverIntegrationsFunc, config *Config, tmpl *template.Template, logger *slog.Logger, lSet model.LabelSet, alert ...*Alert) error {
+// NewReceiver builds a Receiver from its JSON representation, applying the
+// upstream alertmanager defaults to the base receiver. The only default missed
+// is `send_resolved` (a bool) which, if absent from the input, stays false.
+func NewReceiver(input string) (*Receiver, error) {
+	receiver := &Receiver{Receiver: &config.Receiver{}}
+	if err := json.Unmarshal([]byte(input), receiver); err != nil {
+		return nil, err
+	}
+
+	// Round-trip the base receiver through YAML so the upstream defaults are
+	// applied via each notifier config's UnmarshalYAML (mirrors upstream
+	// alertmanager). The native configs on the embed are unaffected.
+	withDefaults, err := defaultedBaseReceiver(receiver.Receiver)
+	if err != nil {
+		return nil, err
+	}
+	receiver.Receiver = withDefaults
+
+	return receiver, nil
+}
+
+func defaultedBaseReceiver(base *config.Receiver) (*config.Receiver, error) {
+	bytes, err := yaml.Marshal(base)
+	if err != nil {
+		return nil, err
+	}
+
+	withDefaults := &config.Receiver{}
+	if err := yaml.Unmarshal(bytes, withDefaults); err != nil {
+		return nil, err
+	}
+
+	if err := withDefaults.UnmarshalYAML(func(i interface{}) error { return nil }); err != nil {
+		return nil, err
+	}
+
+	return withDefaults, nil
+}
+
+func TestReceiver(ctx context.Context, receiver *Receiver, receiverIntegrationsFunc ReceiverIntegrationsFunc, config *Config, tmpl *template.Template, logger *slog.Logger, templater Templater, lSet model.LabelSet, alert ...*Alert) error {
 	ctx = notify.WithGroupKey(ctx, fmt.Sprintf("%s-%s-%d", receiver.Name, lSet.Fingerprint(), time.Now().Unix()))
 	ctx = notify.WithGroupLabels(ctx, lSet)
 	ctx = notify.WithReceiverName(ctx, receiver.Name)
@@ -68,12 +88,12 @@ func TestReceiver(ctx context.Context, receiver Receiver, receiverIntegrationsFu
 		return err
 	}
 
-	receiver, err = testConfig.GetReceiver(receiver.Name)
+	defaultedReceiver, err := testConfig.GetReceiver(receiver.Name)
 	if err != nil {
 		return err
 	}
 
-	integrations, err := receiverIntegrationsFunc(receiver, tmpl, logger)
+	integrations, err := receiverIntegrationsFunc(defaultedReceiver, tmpl, logger, templater)
 	if err != nil {
 		return err
 	}

pkg/types/alertmanagertypes/receiver_test.go

@@ -21,6 +21,12 @@ func TestNewReceiver(t *testing.T) {
 			expected: `{"name":"telegram","telegram_configs":[{"send_resolved":false,"token":"1234567890","chat":12345,"message":"{{ template \"telegram.default.message\" . }}","parse_mode":"HTML"}]}`,
 			pass:     true,
 		},
+		{
+			name:     "GoogleChatConfig",
+			input:    `{"name":"googlechat","googlechat_configs":[{"send_resolved":true,"webhook_url":"https://chat.googleapis.com/v1/spaces/test/messages","title":"Alert","text":"Body"}]}`,
+			expected: `{"name":"googlechat","googlechat_configs":[{"webhook_url":"https://chat.googleapis.com/v1/spaces/test/messages","title":"Alert","text":"Body","send_resolved":true}]}`,
+			pass:     true,
+		},
 	}
 
 	for _, tc := range testCases {
@@ -31,7 +37,7 @@ func TestNewReceiver(t *testing.T) {
 
 				bytes, err := json.Marshal(receiver)
 				require.NoError(t, err)
-				assert.Equal(t, tc.expected, string(bytes))
+				assert.JSONEq(t, tc.expected, string(bytes))
 				return
 			}
 

pkg/types/alertmanagertypes/route.go

@@ -28,7 +28,7 @@ func NewRouteFromRouteConfig(route *config.Route, cfg RouteConfig) (*config.Rout
 	return route, nil
 }
 
-func NewRouteFromReceiver(receiver Receiver) (*config.Route, error) {
+func NewRouteFromReceiver(receiver *config.Receiver) (*config.Route, error) {
 	route := &config.Route{Receiver: receiver.Name, Continue: true, Matchers: config.Matchers{noRuleIDMatcher}}
 	if err := route.UnmarshalYAML(func(i interface{}) error { return nil }); err != nil {
 		return nil, err

pkg/types/ruletypes/api_params.go

@@ -642,114 +642,23 @@ func (g *GettableRule) MarshalJSON() ([]byte, error) {
 	}
 }
 
-// ActiveMuteInfo holds the currently active mute window for an alert rule.
-type ActiveMuteInfo struct {
-	ID                 string     `json:"id"`
-	Name               string     `json:"name"`
-	Description        string     `json:"description,omitempty"`
-	EffectiveStartTime *time.Time `json:"effectiveStartTime,omitempty"`
-	EffectiveEndTime   *time.Time `json:"effectiveEndTime,omitempty"`
-}
-
-// findActiveMuteForRule returns the active mute window for a rule, if any.
-// Scope expressions are intentionally skipped here because we operate at the
-// rule level (no alert labels available), matching the frontend's behaviour.
-func findActiveMuteForRule(ruleID string, schedules []*alertmanagertypes.PlannedMaintenance) *ActiveMuteInfo {
-	if len(schedules) == 0 || ruleID == "" {
-		return nil
-	}
-	now := time.Now()
-
-	type candidate struct {
-		m   *alertmanagertypes.PlannedMaintenance
-		end *time.Time
-	}
-
-	var candidates []candidate
-	for _, m := range schedules {
-		if m.Schedule == nil {
-			continue
-		}
-		// Empty RuleIDs means the window applies to all rules.
-		if len(m.RuleIDs) > 0 {
-			found := false
-			for _, id := range m.RuleIDs {
-				if id == ruleID {
-					found = true
-					break
-				}
-			}
-			if !found {
-				continue
-			}
-		}
-		if !m.IsActive(now) {
-			continue
-		}
-		var end *time.Time
-		if m.Schedule.Recurrence != nil {
-			end = m.Schedule.Recurrence.EndTime
-		} else if !m.Schedule.EndTime.IsZero() {
-			t := m.Schedule.EndTime
-			end = &t
-		}
-		candidates = append(candidates, candidate{m: m, end: end})
-	}
-
-	if len(candidates) == 0 {
-		return nil
-	}
-
-	// Sort by soonest end so the most specific window wins; nil (forever) sorts last.
-	slices.SortFunc(candidates, func(a, b candidate) int {
-		if a.end == nil && b.end == nil {
-			return 0
-		}
-		if a.end == nil {
-			return 1
-		}
-		if b.end == nil {
-			return -1
-		}
-		return a.end.Compare(*b.end)
-	})
-
-	w := candidates[0]
-	info := &ActiveMuteInfo{
-		ID:          w.m.ID.StringValue(),
-		Name:        w.m.Name,
-		Description: w.m.Description,
-	}
-	if w.m.Schedule.Recurrence != nil {
-		t := w.m.Schedule.Recurrence.StartTime
-		info.EffectiveStartTime = &t
-	} else if !w.m.Schedule.StartTime.IsZero() {
-		t := w.m.Schedule.StartTime
-		info.EffectiveStartTime = &t
-	}
-	info.EffectiveEndTime = w.end
-	return info
-}
-
 // Rule is the v2 API read model for an alerting rule. It aligns audit fields
 // with the canonical types.TimeAuditable / types.UserAuditable shape used by
 // PlannedMaintenance and other entities. v1 handlers keep serializing
 // GettableRule directly for back-compat with existing SDK / Terraform clients.
 type Rule struct {
-	Id         string          `json:"id" required:"true"`
-	State      AlertState      `json:"state" required:"true"`
-	ActiveMute *ActiveMuteInfo `json:"activeMute,omitempty"`
+	Id    string     `json:"id" required:"true"`
+	State AlertState `json:"state" required:"true"`
 	PostableRule
 	types.TimeAuditable
 	types.UserAuditable
 }
 
-func NewRule(g *GettableRule, schedules []*alertmanagertypes.PlannedMaintenance) *Rule {
+func NewRule(g *GettableRule) *Rule {
 	r := &Rule{
 		Id:           g.Id,
 		State:        g.State,
 		PostableRule: g.PostableRule,
-		ActiveMute:   findActiveMuteForRule(g.Id, schedules),
 	}
 	r.CreatedAt = g.CreatedAt
 	r.UpdatedAt = g.UpdatedAt

pkg/types/ruletypes/compare.go

@@ -77,6 +77,28 @@ func (c CompareOperator) Normalize() CompareOperator {
 	}
 }
 
+// Literal returns the canonical literal (string) form of the operator.
+func (c CompareOperator) Literal() string {
+	switch c.Normalize() {
+	case ValueIsAbove:
+		return ValueIsAboveLiteral.StringValue()
+	case ValueIsBelow:
+		return ValueIsBelowLiteral.StringValue()
+	case ValueIsEq:
+		return ValueIsEqLiteral.StringValue()
+	case ValueIsNotEq:
+		return ValueIsNotEqLiteral.StringValue()
+	case ValueAboveOrEq:
+		return ValueAboveOrEqLiteral.StringValue()
+	case ValueBelowOrEq:
+		return ValueBelowOrEqLiteral.StringValue()
+	case ValueOutsideBounds:
+		return ValueOutsideBoundsLiteral.StringValue()
+	default:
+		return c.StringValue()
+	}
+}
+
 func (c CompareOperator) Validate() error {
 	switch c {
 	case ValueIsAbove,

pkg/types/ruletypes/match.go

@@ -56,6 +56,24 @@ func (m MatchType) Normalize() MatchType {
 	}
 }
 
+// Literal returns the canonical literal (string) form of the match type.
+func (m MatchType) Literal() string {
+	switch m.Normalize() {
+	case AtleastOnce:
+		return AtleastOnceLiteral.StringValue()
+	case AllTheTimes:
+		return AllTheTimesLiteral.StringValue()
+	case OnAverage:
+		return OnAverageLiteral.StringValue()
+	case InTotal:
+		return InTotalLiteral.StringValue()
+	case Last:
+		return LastLiteral.StringValue()
+	default:
+		return m.StringValue()
+	}
+}
+
 func (m MatchType) Validate() error {
 	switch m {
 	case

pkg/types/ruletypes/result_types.go

@@ -24,6 +24,10 @@ type Sample struct {
 	RecoveryTarget *float64
 
 	TargetUnit string
+
+	// CompareOperator and MatchType carry the threshold evaluation context
+	CompareOperator CompareOperator
+	MatchType       MatchType
 }
 
 func (s Sample) String() string {

pkg/types/ruletypes/threshold.go

@@ -188,6 +188,8 @@ func (r BasicRuleThresholds) Eval(s *qbtypes.TimeSeries, unit string, evalData E
 				smpl.RecoveryTarget = threshold.RecoveryTarget
 			}
 			smpl.TargetUnit = threshold.TargetUnit
+			smpl.CompareOperator = threshold.CompareOperator
+			smpl.MatchType = threshold.MatchType
 			resultVector = append(resultVector, smpl)
 			continue
 		} else if evalData.SendUnmatched {
@@ -197,10 +199,12 @@ func (r BasicRuleThresholds) Eval(s *qbtypes.TimeSeries, unit string, evalData E
 			}
 			// prepare the sample with the first point of the series
 			smpl := Sample{
-				Point:      Point{T: series.Values[0].Timestamp, V: series.Values[0].Value},
-				Metric:     PrepareSampleLabelsForRule(series.Labels, threshold.Name),
-				Target:     *threshold.TargetValue,
-				TargetUnit: threshold.TargetUnit,
+				Point:           Point{T: series.Values[0].Timestamp, V: series.Values[0].Value},
+				Metric:          PrepareSampleLabelsForRule(series.Labels, threshold.Name),
+				Target:          *threshold.TargetValue,
+				TargetUnit:      threshold.TargetUnit,
+				CompareOperator: threshold.CompareOperator,
+				MatchType:       threshold.MatchType,
 			}
 			if threshold.RecoveryTarget != nil {
 				smpl.RecoveryTarget = threshold.RecoveryTarget
@@ -222,6 +226,8 @@ func (r BasicRuleThresholds) Eval(s *qbtypes.TimeSeries, unit string, evalData E
 				smpl.Target = *threshold.TargetValue
 				smpl.RecoveryTarget = threshold.RecoveryTarget
 				smpl.TargetUnit = threshold.TargetUnit
+				smpl.CompareOperator = threshold.CompareOperator
+				smpl.MatchType = threshold.MatchType
 				// IsRecovering to notify that metrics is in recovery stage
 				smpl.IsRecovering = true
 				resultVector = append(resultVector, smpl)

templates/alertmanager/email.gotmpl

@@ -0,0 +1,122 @@
+{{ define "email.signoz.html" }}
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <title>{{.Title}}</title>
+  <style>
+    code {
+      background: #f0f0f0;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+      font-size: 13px;
+    }
+    pre {
+      background: #f0f0f0;
+      padding: 12px 16px;
+      border-radius: 6px;
+      font-size: 13px;
+      overflow-x: auto;
+      white-space: pre;
+    }
+    pre code {
+      background: none;
+      padding: 0;
+      border-radius: 0;
+      font-size: inherit;
+    }
+    table:not([role="presentation"]) {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 14px;
+    }
+    table:not([role="presentation"]) th {
+      font-weight: 600;
+      text-align: left;
+      padding: 8px 12px;
+      border-bottom: 2px solid #d0d0d0;
+    }
+    table:not([role="presentation"]) td {
+      padding: 8px 12px;
+      border-bottom: 1px solid #e8e8e8;
+    }
+    table:not([role="presentation"]) tr:last-child td {
+      border-bottom: none;
+    }
+  </style>
+</head>
+
+<body style="margin:0;padding:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif;line-height:1.6;color:#333;background:#fff">
+  <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0" style="background:#fff">
+    <tr>
+      <td align="center" style="padding:0">
+        <table role="presentation" width="600" cellspacing="0" cellpadding="0" border="0" style="max-width:600px;width:100%;border:1px solid #e2e2e2;border-radius:12px;overflow:hidden">
+
+          <tr>
+            <td align="center" style="padding:20px 20px 12px">
+              <h2 style="margin:0 0 8px;font-size:20px;color:#333">{{.Title}}</h2>
+              <p style="margin:0;font-size:14px;color:#666">
+                Status: <strong>{{.Alert.Status}}</strong>
+                {{if .Alert.TotalFiring}} | Firing: <strong style="color:#e53e3e">{{.Alert.TotalFiring}}</strong>{{end}}
+                {{if .Alert.TotalResolved}} | Resolved: <strong style="color:#38a169">{{.Alert.TotalResolved}}</strong>{{end}}
+              </p>
+            </td>
+          </tr>
+
+          <tr>
+            <td style="padding:0 20px">
+              <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0">
+                <tr><td style="border-top:1px solid #e2e2e2;font-size:0;line-height:0" height="1">&nbsp;</td></tr>
+              </table>
+            </td>
+          </tr>
+
+          {{range .Bodies}}
+          <tr>
+            <td style="padding:8px 20px">
+              <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0">
+                <tr>
+                  <td style="padding:16px;background:#fafafa;border:1px solid #e8e8e8;border-radius:6px">
+                    {{.}}
+                  </td>
+                </tr>
+              </table>
+            </td>
+          </tr>
+          {{end}}
+
+          {{if .NotificationTemplateData.ExternalURL}}
+          <tr>
+            <td style="padding:16px 20px">
+              <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0">
+                <tr>
+                  <td align="center">
+                    <a href="{{.NotificationTemplateData.ExternalURL}}" target="_blank" style="display:inline-block;padding:12px 32px;font-size:14px;font-weight:600;color:#fff;background:#4E74F8;text-decoration:none;border-radius:4px">
+                      View in SigNoz
+                    </a>
+                  </td>
+                </tr>
+              </table>
+            </td>
+          </tr>
+          {{end}}
+
+          <tr>
+            <td align="center" style="padding:8px 16px 16px">
+              <p style="margin:0;font-size:12px;color:#999;line-height:1.5">
+                Sent by SigNoz AlertManager
+              </p>
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+  </table>
+</body>
+
+</html>
+{{ end }}