feat(alerts): return activeMute in rule API responses

Backend computes the active mute window per rule (joining with planned
maintenance schedules) in ListRules and GetRuleByID, so the frontend no
longer needs a separate downtime-schedules fetch to determine mute state.

- Add ActiveMuteInfo struct to Rule (id, name, description,
  effectiveStartTime, effectiveEndTime); computed by findActiveMuteForRule
- Handlers for ListRules/GetRuleByID now fetch MaintenanceStore schedules
  and pass them to NewRule
- Regenerate OpenAPI spec and frontend types (RuletypesActiveMuteInfoDTO)
- useActiveMute: drop useListDowntimeSchedules, read activeMute from
  useGetRuleByID (cache-hit on detail page; one request on list page)
- useMuteAlertRule: also invalidate rule queries after muting so activeMute
  refreshes without a separate schedules refetch
- ListAlert: remove useListDowntimeSchedules + findActiveMuteForRule,
  read record.activeMute.effectiveEndTime directly

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

cmd/community/Dockerfile

@@ -11,7 +11,7 @@ RUN apk update && \
 
 
 COPY ./target/${OS}-${TARGETARCH}/signoz-community /root/signoz
-COPY ./templates /root/templates
+COPY ./templates/email /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 /root/templates
+COPY ./templates/email /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 /root/templates
+COPY ./templates/email /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 /root/templates
+COPY ./templates/email /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 /root/templates
+COPY ./templates/email /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 /root/templates
+COPY ./templates/email /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,11 +182,6 @@ 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

@@ -5109,6 +5109,23 @@ 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:
@@ -5359,6 +5376,8 @@ components:
       type: object
     RuletypesRule:
       properties:
+        activeMute:
+          $ref: '#/components/schemas/RuletypesActiveMuteInfo'
         alert:
           type: string
         alertType:

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -535,7 +535,7 @@ func (module *module) getOrCreateAPIKey(ctx context.Context, orgID valuer.UUID,
 func (module *module) provisionDashboards(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, provider cloudintegrationtypes.CloudProviderType, service *cloudintegrationtypes.CloudIntegrationService, serviceDefinition *cloudintegrationtypes.ServiceDefinition) error {
 	// TODO: DB calls are in for loop, can be optimized later.
 	for _, dashboard := range serviceDefinition.Assets.Dashboards {
-		slug := cloudintegrationtypes.CloudIntegrationDashboardSlug(provider, service.Type, dashboard.ID)
+		slug := cloudintegrationtypes.IntegrationDashboardSlug(provider, service.Type, dashboard.ID)
 
 		existing, err := module.store.GetIntegrationDashboardBySlug(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slug)
 		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
@@ -562,7 +562,7 @@ func (module *module) provisionDashboards(ctx context.Context, orgID valuer.UUID
 // deprovisionDashboards deletes all dashboard and integration_dashboard rows for the given service.
 // make sure to call this within a transaction.
 func (module *module) deprovisionDashboards(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, serviceID cloudintegrationtypes.ServiceID) error {
-	slugPrefix := cloudintegrationtypes.CloudIntegrationDashboardSlugPrefix(provider, serviceID)
+	slugPrefix := cloudintegrationtypes.IntegrationDashboardSlugPrefix(provider, serviceID)
 	rows, err := module.store.ListIntegrationDashboardsBySlugPrefix(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slugPrefix)
 	if err != nil {
 		return err
@@ -588,7 +588,7 @@ func (module *module) deprovisionDashboards(ctx context.Context, orgID valuer.UU
 // TODO: remove this hack and send idiomatic response to client.
 func (module *module) enrichDashboardIDs(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, serviceID cloudintegrationtypes.ServiceID, serviceDefinition *cloudintegrationtypes.ServiceDefinition) error {
 	for i, d := range serviceDefinition.Assets.Dashboards {
-		slug := cloudintegrationtypes.CloudIntegrationDashboardSlug(provider, serviceID, d.ID)
+		slug := cloudintegrationtypes.IntegrationDashboardSlug(provider, serviceID, d.ID)
 		row, err := module.store.GetIntegrationDashboardBySlug(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slug)
 		if err != nil {
 			if errors.Ast(err, errors.TypeNotFound) {

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

@@ -9,6 +9,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
@@ -23,6 +24,7 @@ type APIHandlerOptions struct {
 	DataConnector                 interfaces.Reader
 	UsageManager                  *usage.Manager
 	IntegrationsController        *integrations.Controller
+	CloudIntegrationsController   *cloudintegrations.Controller
 	LogsParsingPipelineController *logparsingpipeline.LogParsingPipelineController
 	GatewayUrl                    string
 	// Querier Influx Interval
@@ -40,6 +42,7 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
 		IntegrationsController:        opts.IntegrationsController,
+		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		FluxInterval:                  opts.FluxInterval,
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
@@ -88,6 +91,17 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 }
 
+func (ah *APIHandler) RegisterCloudIntegrationsRoutes(router *mux.Router, am *middleware.AuthZ) {
+
+	ah.APIHandler.RegisterCloudIntegrationsRoutes(router, am)
+
+	router.HandleFunc(
+		"/api/v1/cloud-integrations/{cloudProvider}/accounts/generate-connection-params",
+		am.EditAccess(ah.CloudIntegrationsGenerateConnectionParams),
+	).Methods(http.MethodGet)
+
+}
+
 func (ah *APIHandler) getVersion(w http.ResponseWriter, r *http.Request) {
 	versionResponse := basemodel.GetVersionResponse{
 		Version:        version.Info.Version(),

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

@@ -89,15 +89,6 @@ 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 {

ee/query-service/app/server.go

@@ -30,6 +30,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/app/opamp"
@@ -85,13 +86,20 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	// initiate opamp
 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)
 
-	integrationsController, err := integrations.NewController(signoz.SQLStore, signoz.Modules.Dashboard)
+	integrationsController, err := integrations.NewController(signoz.SQLStore)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't create integrations controller: %w", err,
 		)
 	}
 
+	cloudIntegrationsController, err := cloudintegrations.NewController(signoz.SQLStore)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"couldn't create cloud provider integrations controller: %w", err,
+		)
+	}
+
 	// ingestion pipelines manager
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
 		signoz.SQLStore,
@@ -126,6 +134,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		DataConnector:                 reader,
 		UsageManager:                  usageManager,
 		IntegrationsController:        integrationsController,
+		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
 		FluxInterval:                  config.Querier.FluxInterval,
 		GatewayUrl:                    config.Gateway.URL.String(),
@@ -191,6 +200,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterRoutes(r, am)
 	apiHandler.RegisterLogsRoutes(r, am)
 	apiHandler.RegisterIntegrationRoutes(r, am)
+	apiHandler.RegisterCloudIntegrationsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV3Routes(r, am)
 	apiHandler.RegisterInfraMetricsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV4Routes(r, am)

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

@@ -6082,6 +6082,31 @@ 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',
@@ -6406,6 +6431,7 @@ 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,6 +10,9 @@ 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,5 +11,4 @@ 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__/CreateAlertChannelNormalUser.test.tsx

@@ -1,3 +1,4 @@
+import { SIGNOZ_UPGRADE_PLAN_URL } from 'constants/app';
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
 import {
@@ -312,6 +313,16 @@ 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' }),

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -43,6 +43,7 @@ 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';
@@ -276,7 +277,14 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 					onEditHandler(record, { newTab: isModifierKeyPressed(e) });
 				};
 
-				return <Typography.Link onClick={onClickHandler}>{value}</Typography.Link>;
+				const muteEndTime = record.activeMute?.effectiveEndTime ?? undefined;
+
+				return (
+					<span className="alert-list-name-cell">
+						<Typography.Link onClick={onClickHandler}>{value}</Typography.Link>
+						<MutedBadge muteEndTime={muteEndTime} />
+					</span>
+				);
 			},
 			sortOrder: sortedInfo.columnKey === 'name' ? sortedInfo.order : null,
 		},

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

@@ -0,0 +1,20 @@
+.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

@@ -0,0 +1,46 @@
+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,20 +81,6 @@
 		}
 	}
 
-	.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,7 +8,6 @@ import {
 	FormInstance,
 	Input,
 	Modal,
-	Radio,
 	Select,
 	SelectProps,
 	Spin,
@@ -72,14 +71,11 @@ 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;
@@ -133,12 +129,6 @@ 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();
 
@@ -152,12 +142,9 @@ export function PlannedDowntimeForm(
 	const saveHandler = useCallback(
 		async (values: PlannedDowntimeFormData) => {
 			const data: AlertmanagertypesPostablePlannedMaintenanceDTO = {
-				alertIds:
-					values.alertRuleScope === 'all'
-						? []
-						: (values.alertRules
-								.map((alert) => alert.value)
-								.filter((alert) => alert !== undefined) as string[]),
+				alertIds: values.alertRules
+					.map((alert) => alert.value)
+					.filter((alert) => alert !== undefined) as string[],
 				name: values.name,
 				scope: values.scope,
 				schedule: {
@@ -278,13 +265,12 @@ 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, ''),
-			alertRuleScope:
-				isEditMode && initialAlertIds.length === 0 ? 'all' : 'specific',
-			alertRules: getAlertOptionsFromIds(initialAlertIds, alertOptions),
+			alertRules: getAlertOptionsFromIds(
+				initialValues.alertIds || [],
+				alertOptions,
+			),
 			startTime: startTime ? dayjs(startTime).tz(schedule.timezone) : null,
 			endTime: endTime ? dayjs(endTime).tz(schedule.timezone) : null,
 			recurrence: {
@@ -301,7 +287,6 @@ export function PlannedDowntimeForm(
 
 	useEffect(() => {
 		setSelectedTags(formattedInitialValues.alertRules);
-		setAlertRuleScope(formattedInitialValues.alertRuleScope);
 		form.setFieldsValue({ ...formattedInitialValues });
 	}, [form, formattedInitialValues, initialValues]);
 
@@ -364,7 +349,6 @@ 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"
@@ -464,76 +448,49 @@ export function PlannedDowntimeForm(
 					<div className="scheduleTimeInfoText">{endTimeText}</div>
 				)}
 				<div>
-					<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>
+					<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>
 					</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/pages/AlertDetails/AlertHeader/ActionButtons/ActionButtons.styles.scss

@@ -12,6 +12,20 @@
 		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,7 +1,6 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, 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 {
@@ -17,6 +16,13 @@ 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';
@@ -123,19 +129,77 @@ function AlertActionButtons({
 	// eslint-disable-next-line react-hooks/exhaustive-deps
 	useEffect(() => (): void => setAlertRuleState(undefined), []);
 
-	const toggleAlertRule = useCallback(() => {
-		setIsAlertRuleDisabled((prev) => !prev);
-		handleAlertStateToggle();
-	}, [handleAlertStateToggle]);
+	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;
 
 	return (
 		<>
 			<div className="alert-action-buttons">
-				<Tooltip title={isAlertRuleDisabled ? 'Enable alert' : 'Disable alert'}>
-					{isAlertRuleDisabled !== undefined && (
-						<Switch onChange={toggleAlertRule} value={!isAlertRuleDisabled} />
-					)}
-				</Tooltip>
+				{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>
+				)}
+
 				<CopyToClipboard textToCopy={window.location.href} />
 
 				<Divider type="vertical" />
@@ -152,6 +216,14 @@ 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,3 +1,13 @@
+.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,6 +12,9 @@ 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';
 
@@ -43,6 +46,13 @@ 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">
@@ -67,14 +77,23 @@ function AlertHeader({ alertDetails }: AlertHeaderProps): JSX.Element {
 	);
 
 	return (
-		<div className="alert-info">
-			{isV2Alert ? <CreateAlertV2Header /> : CreateAlertV1Header}
-			<div className="alert-info__action-buttons">
-				<AlertActionButtons
-					alertDetails={alertDetails}
-					ruleId={alertDetails?.id || ''}
-				/>
+		<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>
+			{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

@@ -0,0 +1,102 @@
+.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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,193 @@
+.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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1,115 @@
+.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

@@ -0,0 +1,247 @@
+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

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,98 @@
+.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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,92 @@
+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/TraceDetailsV3/SpanDetailsPanel/DockModeSwitcher.tsx

@@ -1,77 +0,0 @@
-import { ReactNode } from 'react';
-import { Dock, PanelBottom, PanelRight } from '@signozhq/icons';
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/ui/toggle-group';
-import {
-	TooltipContent,
-	TooltipProvider,
-	TooltipRoot,
-	TooltipTrigger,
-} from '@signozhq/ui/tooltip';
-
-import { SpanDetailVariant } from './constants';
-
-interface DockOption {
-	value: SpanDetailVariant;
-	icon: ReactNode;
-	tooltip: string;
-}
-
-const DOCK_OPTIONS: DockOption[] = [
-	{
-		value: SpanDetailVariant.DIALOG,
-		icon: <Dock size={14} />,
-		tooltip: 'Open as floating panel',
-	},
-	{
-		value: SpanDetailVariant.DOCKED,
-		icon: <PanelBottom size={14} />,
-		tooltip: 'Dock at the bottom',
-	},
-	{
-		value: SpanDetailVariant.DOCKED_RIGHT,
-		icon: <PanelRight size={14} />,
-		tooltip: 'Dock on the right',
-	},
-];
-
-interface DockModeSwitcherProps {
-	value: SpanDetailVariant;
-	onChange: (value: SpanDetailVariant) => void;
-	tooltipClassName?: string;
-}
-
-function DockModeSwitcher({
-	value,
-	onChange,
-	tooltipClassName,
-}: DockModeSwitcherProps): JSX.Element {
-	return (
-		<TooltipProvider>
-			<ToggleGroup
-				type="single"
-				value={value}
-				onChange={(v): void => {
-					if (v) {
-						onChange(v as SpanDetailVariant);
-					}
-				}}
-				size="sm"
-			>
-				{DOCK_OPTIONS.map((option) => (
-					<TooltipRoot key={option.value}>
-						<TooltipTrigger asChild>
-							<span>
-								<ToggleGroupItem value={option.value}>{option.icon}</ToggleGroupItem>
-							</span>
-						</TooltipTrigger>
-						<TooltipContent className={tooltipClassName}>
-							{option.tooltip}
-						</TooltipContent>
-					</TooltipRoot>
-				))}
-			</ToggleGroup>
-		</TooltipProvider>
-	);
-}
-
-export default DockModeSwitcher;

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

@@ -3,10 +3,6 @@
 	display: flex;
 	flex-direction: column;
 	overflow: hidden;
-
-	:global(.details-header) {
-		height: 39px;
-	}
 }
 
 .body {

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

@@ -1,16 +1,25 @@
 import { useCallback, useMemo } from 'react';
+import { Button } from '@signozhq/ui/button';
 import {
 	TabsContent,
 	TabsList,
 	TabsRoot,
 	TabsTrigger,
 } from '@signozhq/ui/tabs';
+import {
+	TooltipRoot,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from '@signozhq/ui/tooltip';
 import {
 	Bookmark,
 	CalendarClock,
 	ChartColumnBig,
+	Dock,
 	Link2,
 	List,
+	PanelBottom,
 	ScrollText,
 	Timer,
 } from '@signozhq/icons';
@@ -52,7 +61,6 @@ import {
 	SpanDetailVariant,
 	VISIBLE_ACTIONS,
 } from './constants';
-import DockModeSwitcher from './DockModeSwitcher';
 import { useSpanAttributeActions } from './hooks/useSpanAttributeActions';
 import { useTracePinnedFields } from './hooks/useTracePinnedFields';
 import {
@@ -484,14 +492,31 @@ function SpanDetailsPanel({
 		];
 
 		if (onVariantChange) {
+			const isDocked = variant === SpanDetailVariant.DOCKED;
 			actions.push({
-				key: 'dock-mode',
+				key: 'dock-toggle',
 				component: (
-					<DockModeSwitcher
-						value={variant}
-						onChange={onVariantChange}
-						tooltipClassName={styles.dockToggleTooltip}
-					/>
+					<TooltipProvider>
+						<TooltipRoot>
+							<TooltipTrigger asChild>
+								<Button
+									variant="ghost"
+									size="icon"
+									color="secondary"
+									onClick={(): void =>
+										onVariantChange(
+											isDocked ? SpanDetailVariant.DIALOG : SpanDetailVariant.DOCKED,
+										)
+									}
+								>
+									{isDocked ? <Dock size={14} /> : <PanelBottom size={14} />}
+								</Button>
+							</TooltipTrigger>
+							<TooltipContent className={styles.dockToggleTooltip}>
+								{isDocked ? 'Open as floating panel' : 'Dock at the bottom'}
+							</TooltipContent>
+						</TooltipRoot>
+					</TooltipProvider>
 				),
 			});
 		}
@@ -528,10 +553,7 @@ function SpanDetailsPanel({
 		</>
 	);
 
-	if (
-		variant === SpanDetailVariant.DOCKED ||
-		variant === SpanDetailVariant.DOCKED_RIGHT
-	) {
+	if (variant === SpanDetailVariant.DOCKED) {
 		return <div className={styles.root}>{content}</div>;
 	}
 

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

@@ -22,7 +22,6 @@ export enum SpanDetailVariant {
 	DRAWER = 'drawer',
 	DIALOG = 'dialog',
 	DOCKED = 'docked',
-	DOCKED_RIGHT = 'right',
 }
 
 export const KEY_ATTRIBUTE_KEYS: Record<string, string[]> = {

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

@@ -4,28 +4,13 @@
 	flex-direction: column;
 }
 
-.layoutRow {
-	display: flex;
-	flex: 1;
-	min-height: 0;
-	overflow: hidden;
-}
-
 .content {
 	display: flex;
 	flex-direction: column;
 	flex: 1;
-	min-width: 0;
 	overflow: hidden;
 }
 
-.rightDock {
-	display: flex;
-	flex-direction: column;
-	border-left: 1px solid var(--l2-border);
-	min-width: 0;
-}
-
 // Shared Ant Collapse chrome reset for both the flamegraph and waterfall
 // collapse panels.
 .flameCollapse,

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

@@ -893,7 +893,7 @@ function Success(props: ISuccessProps): JSX.Element {
 					/>
 					{/* Left panel - table with horizontal scroll */}
 					<ResizableBox
-						handle="right"
+						direction="horizontal"
 						defaultWidth={DEFAULT_SIDEBAR_WIDTH}
 						minWidth={MIN_SIDEBAR_WIDTH}
 						maxWidth={MAX_SIDEBAR_WIDTH}

frontend/src/pages/TraceDetailsV3/index.tsx

@@ -242,13 +242,9 @@ function TraceDetailsV3(): JSX.Element {
 		() =>
 			(getLocalStorageKey(
 				LOCALSTORAGE.TRACE_DETAILS_SPAN_DETAILS_POSITION,
-			) as SpanDetailVariant) || SpanDetailVariant.DOCKED_RIGHT,
+			) as SpanDetailVariant) || SpanDetailVariant.DIALOG,
 	);
 
-	const RIGHT_DOCK_MIN = 480;
-	const RIGHT_DOCK_MAX = 720;
-	const [rightDockWidth, setRightDockWidth] = useState(RIGHT_DOCK_MIN);
-
 	const handleVariantChange = useCallback(
 		(newVariant: SpanDetailVariant): void => {
 			setLocalStorageKey(
@@ -295,9 +291,7 @@ function TraceDetailsV3(): JSX.Element {
 		(!!errorFetchingTraceData || !traceData?.payload?.spans?.length);
 
 	const isDocked = spanDetailVariant === SpanDetailVariant.DOCKED;
-	const isRightDocked = spanDetailVariant === SpanDetailVariant.DOCKED_RIGHT;
 	const isWaterfallDocked = panelState.isOpen && isDocked;
-	const showRightDock = panelState.isOpen && isRightDocked;
 
 	const waterfallChildren = (
 		<ResizableBox
@@ -338,118 +332,94 @@ function TraceDetailsV3(): JSX.Element {
 					<NoData />
 				) : (
 					<>
-						<div className={styles.layoutRow}>
-							<div className={styles.content}>
-								<Collapse
-									// @ts-expect-error motion is passed through to rc-collapse to disable animation
-									motion={false}
-									activeKey={activeKeys.filter((k) => k === 'flame')}
-									onChange={(): void => handleCollapseChange('flame')}
-									size="small"
-									className={styles.flameCollapse}
-									items={[
-										{
-											key: 'flame',
-											label: (
-												<div className={styles.collapseLabel}>
-													<span className={styles.collapseTitle}>
-														Flame Graph
-														{traceData?.payload?.totalSpansCount &&
-															traceData.payload.totalSpansCount > FLAMEGRAPH_SPAN_LIMIT && (
-																<WarningPopover
-																	message="The total span count exceeds the visualization limit. Displaying a sampled subset of spans in flamegraph."
-																	placement="bottomLeft"
-																/>
-															)}
-													</span>
-													{traceData?.payload?.totalSpansCount ? (
-														<span className={styles.collapseCount}>
-															<span className={styles.collapseCountItem}>
-																<ChartNoAxesGantt size={13} />
-																Spans: {traceData.payload.totalSpansCount}
-															</span>
-															<span
-																className={cx(styles.collapseCountItem, {
-																	[styles.hasErrors]: traceData.payload.totalErrorSpansCount > 0,
-																})}
-															>
-																<TriangleAlert size={13} />
-																Errors: {traceData.payload.totalErrorSpansCount ?? 0}
-															</span>
+						<div className={styles.content}>
+							<Collapse
+								// @ts-expect-error motion is passed through to rc-collapse to disable animation
+								motion={false}
+								activeKey={activeKeys.filter((k) => k === 'flame')}
+								onChange={(): void => handleCollapseChange('flame')}
+								size="small"
+								className={styles.flameCollapse}
+								items={[
+									{
+										key: 'flame',
+										label: (
+											<div className={styles.collapseLabel}>
+												<span className={styles.collapseTitle}>
+													Flame Graph
+													{traceData?.payload?.totalSpansCount &&
+														traceData.payload.totalSpansCount > FLAMEGRAPH_SPAN_LIMIT && (
+															<WarningPopover
+																message="The total span count exceeds the visualization limit. Displaying a sampled subset of spans in flamegraph."
+																placement="bottomLeft"
+															/>
+														)}
+												</span>
+												{traceData?.payload?.totalSpansCount ? (
+													<span className={styles.collapseCount}>
+														<span className={styles.collapseCountItem}>
+															<ChartNoAxesGantt size={13} />
+															Spans: {traceData.payload.totalSpansCount}
 														</span>
-													) : null}
-												</div>
-											),
-											children: (
-												<ResizableBox defaultHeight={300} minHeight={100} maxHeight={400}>
-													<TraceFlamegraph
-														filteredSpanIds={filteredSpanIds}
-														isFilterActive={isFilterActive}
-														selectedSpan={selectedSpan}
-														totalSpansCount={totalSpansCount}
-													/>
-												</ResizableBox>
-											),
-										},
-									]}
-								/>
+														<span
+															className={cx(styles.collapseCountItem, {
+																[styles.hasErrors]: traceData.payload.totalErrorSpansCount > 0,
+															})}
+														>
+															<TriangleAlert size={13} />
+															Errors: {traceData.payload.totalErrorSpansCount ?? 0}
+														</span>
+													</span>
+												) : null}
+											</div>
+										),
+										children: (
+											<ResizableBox defaultHeight={300} minHeight={100} maxHeight={400}>
+												<TraceFlamegraph
+													filteredSpanIds={filteredSpanIds}
+													isFilterActive={isFilterActive}
+													selectedSpan={selectedSpan}
+													totalSpansCount={totalSpansCount}
+												/>
+											</ResizableBox>
+										),
+									},
+								]}
+							/>
 
-								<Collapse
-									// @ts-expect-error motion is passed through to rc-collapse to disable animation
-									motion={false}
-									activeKey={activeKeys.filter((k) => k === 'waterfall')}
-									onChange={(): void => handleCollapseChange('waterfall')}
-									size="small"
-									className={cx(styles.waterfallCollapse, {
-										[styles.isDocked]: isWaterfallDocked,
-									})}
-									items={[
-										{
-											key: 'waterfall',
-											label: 'Waterfall',
-											children: activeKeys.includes('waterfall')
-												? waterfallChildren
-												: null,
-										},
-									]}
-								/>
+							<Collapse
+								// @ts-expect-error motion is passed through to rc-collapse to disable animation
+								motion={false}
+								activeKey={activeKeys.filter((k) => k === 'waterfall')}
+								onChange={(): void => handleCollapseChange('waterfall')}
+								size="small"
+								className={cx(styles.waterfallCollapse, {
+									[styles.isDocked]: isWaterfallDocked,
+								})}
+								items={[
+									{
+										key: 'waterfall',
+										label: 'Waterfall',
+										children: activeKeys.includes('waterfall') ? waterfallChildren : null,
+									},
+								]}
+							/>
 
-								{panelState.isOpen && isDocked && (
-									<div className={styles.dockedSpanDetails}>
-										<SpanDetailsPanel
-											panelState={panelState}
-											selectedSpan={selectedSpan}
-											variant={SpanDetailVariant.DOCKED}
-											onVariantChange={handleVariantChange}
-											traceStartTime={traceData?.payload?.startTimestampMillis}
-											traceEndTime={traceData?.payload?.endTimestampMillis}
-										/>
-									</div>
-								)}
-							</div>
-
-							{showRightDock && (
-								<ResizableBox
-									handle="left"
-									defaultWidth={rightDockWidth}
-									minWidth={RIGHT_DOCK_MIN}
-									maxWidth={RIGHT_DOCK_MAX}
-									onResize={setRightDockWidth}
-									className={styles.rightDock}
-								>
+							{panelState.isOpen && isDocked && (
+								<div className={styles.dockedSpanDetails}>
 									<SpanDetailsPanel
 										panelState={panelState}
 										selectedSpan={selectedSpan}
-										variant={SpanDetailVariant.DOCKED_RIGHT}
+										variant={SpanDetailVariant.DOCKED}
 										onVariantChange={handleVariantChange}
 										traceStartTime={traceData?.payload?.startTimestampMillis}
 										traceEndTime={traceData?.payload?.endTimestampMillis}
 									/>
-								</ResizableBox>
+								</div>
 							)}
 						</div>
 
-						{panelState.isOpen && spanDetailVariant === SpanDetailVariant.DIALOG && (
+						{panelState.isOpen && !isDocked && (
 							<SpanDetailsPanel
 								panelState={panelState}
 								selectedSpan={selectedSpan}

frontend/src/periscope/components/ResizableBox/ResizableBox.styles.scss

@@ -23,36 +23,20 @@
 			background: var(--primary);
 		}
 
-		&--top,
-		&--bottom {
+		&--vertical {
+			bottom: 0;
 			left: 0;
 			right: 0;
 			height: 1px;
 			cursor: row-resize;
 		}
 
-		&--left,
-		&--right {
+		&--horizontal {
+			right: 0;
 			top: 0;
 			bottom: 0;
 			width: 1px;
 			cursor: col-resize;
 		}
-
-		&--top {
-			top: 0;
-		}
-
-		&--bottom {
-			bottom: 0;
-		}
-
-		&--left {
-			left: 0;
-		}
-
-		&--right {
-			right: 0;
-		}
 	}
 }

frontend/src/periscope/components/ResizableBox/ResizableBox.tsx

@@ -2,15 +2,9 @@ import { useCallback, useRef, useState } from 'react';
 
 import './ResizableBox.styles.scss';
 
-export type ResizableBoxHandle = 'top' | 'right' | 'bottom' | 'left';
-
 export interface ResizableBoxProps {
 	children: React.ReactNode;
-	// Which edge the resize handle sits on. The edge determines the axis:
-	// 'top'/'bottom' → vertical resize (height), 'left'/'right' → horizontal
-	// resize (width). Dragging the handle away from the content grows the box;
-	// dragging it toward the content shrinks it.
-	handle?: ResizableBoxHandle;
+	direction?: 'vertical' | 'horizontal';
 	defaultHeight?: number;
 	minHeight?: number;
 	maxHeight?: number;
@@ -24,7 +18,7 @@ export interface ResizableBoxProps {
 
 function ResizableBox({
 	children,
-	handle = 'bottom',
+	direction = 'vertical',
 	defaultHeight = 200,
 	minHeight = 50,
 	maxHeight = Infinity,
@@ -35,8 +29,7 @@ function ResizableBox({
 	disabled = false,
 	className,
 }: ResizableBoxProps): JSX.Element {
-	const isHorizontal = handle === 'left' || handle === 'right';
-	const isStartHandle = handle === 'top' || handle === 'left';
+	const isHorizontal = direction === 'horizontal';
 	const [size, setSize] = useState(isHorizontal ? defaultWidth : defaultHeight);
 	const containerRef = useRef<HTMLDivElement>(null);
 
@@ -47,13 +40,10 @@ function ResizableBox({
 			const startSize = size;
 			const min = isHorizontal ? minWidth : minHeight;
 			const max = isHorizontal ? maxWidth : maxHeight;
-			// Start-edge handle: pointer moving away from content (negative delta)
-			// grows the box, so invert the sign.
-			const deltaSign = isStartHandle ? -1 : 1;
 
 			const onMouseMove = (moveEvent: MouseEvent): void => {
 				const currentPos = isHorizontal ? moveEvent.clientX : moveEvent.clientY;
-				const delta = (currentPos - startPos) * deltaSign;
+				const delta = currentPos - startPos;
 				const newSize = Math.min(max, Math.max(min, startSize + delta));
 				setSize(newSize);
 				onResize?.(newSize);
@@ -71,16 +61,7 @@ function ResizableBox({
 			document.addEventListener('mousemove', onMouseMove);
 			document.addEventListener('mouseup', onMouseUp);
 		},
-		[
-			size,
-			isHorizontal,
-			isStartHandle,
-			minWidth,
-			maxWidth,
-			minHeight,
-			maxHeight,
-			onResize,
-		],
+		[size, isHorizontal, minWidth, maxWidth, minHeight, maxHeight, onResize],
 	);
 
 	const containerStyle = disabled
@@ -88,7 +69,7 @@ function ResizableBox({
 		: isHorizontal
 			? { width: size }
 			: { height: size };
-	const handleClass = `resizable-box__handle resizable-box__handle--${handle}`;
+	const handleClass = `resizable-box__handle resizable-box__handle--${direction}`;
 
 	return (
 		<div

pkg/alertmanager/alertmanagernotify/email/email.go

@@ -23,13 +23,7 @@ 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"
@@ -40,39 +34,20 @@ 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
-	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
+	conf     *config.EmailConfig
+	tmpl     *template.Template
+	logger   *slog.Logger
+	hostname string
 }
 
 var errNoAuthUsernameConfigured = errors.NewInternalf(errors.CodeInternal, "no auth username configured")
 
-// 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 {
+// New returns a new Email notifier.
+func New(c *config.EmailConfig, t *template.Template, l *slog.Logger) *Email {
 	if _, ok := c.Headers["Subject"]; !ok {
 		c.Headers["Subject"] = config.DefaultEmailSubject
 	}
@@ -88,7 +63,7 @@ func New(c *config.EmailConfig, t *template.Template, l *slog.Logger, templater
 	if err != nil {
 		h = "localhost.localdomain"
 	}
-	return &Email{conf: c, tmpl: t, logger: l, hostname: h, templater: templater}
+	return &Email{conf: c, tmpl: t, logger: l, hostname: h}
 }
 
 // auth resolves a string of authentication mechanisms.
@@ -224,9 +199,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 && !errors.Is(err, errNoAuthUsernameConfigured) {
+		if err != nil && err != errNoAuthUsernameConfigured {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "find auth mechanism")
-		} else if errors.Is(err, errNoAuthUsernameConfigured) {
+		} else if err == errNoAuthUsernameConfigured {
 			n.logger.DebugContext(ctx, "no auth username configured. Attempting to send email without authenticating")
 		}
 		if auth != nil {
@@ -270,16 +245,6 @@ 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 {
@@ -297,10 +262,6 @@ 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)
@@ -375,7 +336,7 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		}
 	}
 
-	if htmlBody != "" {
+	if len(n.conf.HTML) > 0 {
 		// Html template
 		// Preferred alternative placed last per section 5.1.4 of RFC 2046
 		// https://www.ietf.org/rfc/rfc2046.txt
@@ -386,8 +347,12 @@ 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(htmlBody))
+		_, err = qw.Write([]byte(body))
 		if err != nil {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "write HTML part")
 		}
@@ -416,124 +381,6 @@ 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,7 +8,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
@@ -18,10 +17,7 @@ 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"
@@ -46,11 +42,6 @@ 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 {
@@ -171,7 +162,7 @@ func notifyEmailWithContext(ctx context.Context, t *testing.T, cfg *config.Email
 		return nil, false, err
 	}
 
-	email := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+	email := New(cfg, tmpl, promslog.NewNopLogger())
 
 	retry, err := email.Notify(ctx, firingAlert)
 	if err != nil {
@@ -715,7 +706,7 @@ func TestEmailRejected(t *testing.T) {
 	tmpl, firingAlert, err := prepare(cfg)
 	require.NoError(t, err)
 
-	e := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+	e := New(cfg, tmpl, promslog.NewNopLogger())
 
 	// Send the alert to mock SMTP server.
 	retry, err := e.Notify(context.Background(), firingAlert)
@@ -1039,135 +1030,6 @@ 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/msteamsv2/msteamsv2.go

@@ -15,9 +15,7 @@ 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"
 
@@ -46,7 +44,6 @@ 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
@@ -55,7 +52,7 @@ type Content struct {
 	Type    string   `json:"type"`
 	Version string   `json:"version"`
 	Body    []Body   `json:"body"`
-	Msteams Msteams  `json:"msteams,omitzero"`
+	Msteams Msteams  `json:"msteams,omitempty"`
 	Actions []Action `json:"actions"`
 }
 
@@ -97,7 +94,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, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -112,7 +109,6 @@ 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
@@ -132,11 +128,25 @@ 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()
@@ -148,12 +158,6 @@ 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",
@@ -165,7 +169,17 @@ 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:    bodyBlocks,
+					Body: []Body{
+						{
+							Type:   "TextBlock",
+							Text:   title,
+							Weight: "Bolder",
+							Size:   "Medium",
+							Wrap:   true,
+							Style:  "heading",
+							Color:  color,
+						},
+					},
 					Actions: []Action{
 						{
 							Type:  "Action.OpenUrl",
@@ -181,6 +195,20 @@ 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
@@ -200,75 +228,6 @@ 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{
@@ -299,8 +258,7 @@ 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)) ||
-			alertmanagertypes.IsPrivateAnnotation(string(k)) {
+		if slices.Contains([]string{"summary", "related_logs", "related_traces"}, string(k)) {
 			continue
 		}
 		annotationsFacts = append(annotationsFacts, Fact{Title: string(k), Value: string(v)})

pkg/alertmanager/alertmanagernotify/msteamsv2/msteamsv2_test.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -16,9 +15,6 @@ 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"
@@ -27,28 +23,21 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -75,16 +64,14 @@ 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{},
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				`{{ template "msteamsv2.default.titleLink" . }}`,
 				promslog.NewNopLogger(),
-				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -166,8 +153,7 @@ 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{}
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(tc.cfg, tmpl, tc.titleLink, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(tc.cfg, test.CreateTmpl(t), tc.titleLink, promslog.NewNopLogger())
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -200,124 +186,20 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ 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()
@@ -327,16 +209,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie.go

@@ -15,10 +15,7 @@ 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"
 
@@ -37,27 +34,25 @@ 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
-	templater alertmanagertypes.Templater
+	conf    *config.OpsGenieConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new OpsGenie notifier.
-func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, 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}},
-		templater: templater,
+		conf:    c,
+		tmpl:    t,
+		logger:  l,
+		client:  client,
+		retrier: &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
 	}, nil
 }
 
@@ -128,55 +123,6 @@ 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)
@@ -222,10 +168,9 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		}
 		requests = append(requests, req.WithContext(ctx))
 	default:
-		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
+		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))
 		}
 
 		createEndpointURL := n.conf.APIURL.Copy()
@@ -264,7 +209,7 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		msg := &opsGenieCreateMessage{
 			Alias:       alias,
 			Message:     message,
-			Description: description,
+			Description: tmpl(n.conf.Description),
 			Details:     details,
 			Source:      tmpl(n.conf.Source),
 			Responders:  responders,

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie_test.go

@@ -8,16 +8,12 @@ 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"
@@ -26,23 +22,16 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -58,16 +47,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -85,16 +72,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -217,7 +202,7 @@ func TestOpsGenie(t *testing.T) {
 		},
 	} {
 		t.Run(tc.title, func(t *testing.T) {
-			notifier, err := New(tc.cfg, tmpl, logger, newTestTemplater(tmpl))
+			notifier, err := New(tc.cfg, tmpl, logger)
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -293,7 +278,7 @@ func TestOpsGenieWithUpdate(t *testing.T) {
 		APIURL:       &config.URL{URL: u},
 		HTTPConfig:   &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
 	alert := &types.Alert{
 		Alert: model.Alert{
 			StartsAt: time.Now(),
@@ -336,7 +321,7 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 		APIURL:     &config.URL{URL: u},
 		HTTPConfig: &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
 
 	require.NoError(t, err)
 	requests, _, err := notifierWithUpdate.createRequests(ctx)
@@ -344,99 +329,6 @@ 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,9 +15,7 @@ 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"
@@ -42,22 +40,21 @@ 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
-	templater alertmanagertypes.Templater
+	conf    *config.PagerdutyConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	apiV1   string // for tests.
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new PagerDuty notifier.
-func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, 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, templater: templater}
+	n := &Notifier{conf: c, tmpl: t, logger: l, client: client}
 	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.
@@ -146,12 +143,11 @@ 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(title, maxV1DescriptionLenRunes)
+	description, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV1DescriptionLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated description", slog.Any("key", key), slog.Int("max_runes", maxV1DescriptionLenRunes))
 	}
@@ -207,7 +203,6 @@ 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)
@@ -216,7 +211,7 @@ func (n *Notifier) notifyV2(
 		n.conf.Severity = "error"
 	}
 
-	summary, truncated := notify.TruncateInRunes(title, maxV2SummaryLenRunes)
+	summary, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV2SummaryLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated summary", slog.Any("key", key), slog.Int("max_runes", maxV2SummaryLenRunes))
 	}
@@ -299,22 +294,6 @@ 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)
@@ -323,12 +302,6 @@ 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)
@@ -356,7 +329,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, title)
+	retry, err := nf(ctx, eventType, key, data, details)
 	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,7 +9,6 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -18,10 +17,7 @@ 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"
@@ -34,20 +30,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -59,15 +49,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -83,15 +71,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -104,16 +90,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -130,15 +114,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -156,16 +138,14 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -322,8 +302,7 @@ 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{}
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(tc.cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(tc.cfg, test.CreateTmpl(t), promslog.NewNopLogger())
 			require.NoError(t, err)
 			if pd.apiV1 != "" {
 				pd.apiV1 = u.String()
@@ -413,15 +392,13 @@ func TestEventSizeEnforcement(t *testing.T) {
 		Details:    bigDetailsV1,
 	}
 
-	tmpl := test.CreateTmpl(t)
 	notifierV1, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -443,9 +420,8 @@ func TestEventSizeEnforcement(t *testing.T) {
 			RoutingKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -560,8 +536,7 @@ func TestPagerDutyEmptySrcHref(t *testing.T) {
 		Links:      links,
 	}
 
-	pdTmpl := test.CreateTmpl(t)
-	pagerDuty, err := New(&pagerDutyConfig, pdTmpl, promslog.NewNopLogger(), newTestTemplater(pdTmpl))
+	pagerDuty, err := New(&pagerDutyConfig, test.CreateTmpl(t), promslog.NewNopLogger())
 	require.NoError(t, err)
 
 	ctx := context.Background()
@@ -628,8 +603,7 @@ func TestPagerDutyTimeout(t *testing.T) {
 				Timeout:    tt.timeout,
 			}
 
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(&cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(&cfg, test.CreateTmpl(t), promslog.NewNopLogger())
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -907,79 +881,3 @@ 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

@@ -26,7 +26,7 @@ var customNotifierIntegrations = []string{
 	msteamsv2.Integration,
 }
 
-func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {
+func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger) ([]notify.Integration, error) {
 	upstreamIntegrations, err := receiver.BuildReceiverIntegrations(nc, tmpl, logger)
 	if err != nil {
 		return nil, err
@@ -53,25 +53,23 @@ 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, templater) })
+		add(webhook.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return webhook.New(c, tmpl, l) })
 	}
 	for i, c := range nc.EmailConfigs {
-		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
-			return email.New(c, tmpl, l, templater), nil
-		})
+		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return email.New(c, tmpl, l), 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, templater) })
+		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l) })
 	}
 	for i, c := range nc.OpsGenieConfigs {
-		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l, templater) })
+		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l) })
 	}
 	for i, c := range nc.SlackConfigs {
-		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l, templater) })
+		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l) })
 	}
 	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, templater)
+			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l)
 		})
 	}
 

pkg/alertmanager/alertmanagernotify/slack/slack.go

@@ -14,11 +14,7 @@ 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"
@@ -29,8 +25,6 @@ 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.
@@ -38,18 +32,17 @@ 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
-	templater alertmanagertypes.Templater
+	conf    *config.SlackConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 
 	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, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -61,7 +54,6 @@ func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, templater
 		logger:       l,
 		client:       client,
 		retrier:      &notify.Retrier{},
-		templater:    templater,
 		postJSONFunc: notify.PostJSON,
 	}, nil
 }
@@ -89,10 +81,9 @@ 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,omitempty"`
+	Footer     string               `json:"footer"`
 	Color      string               `json:"color,omitempty"`
 	MrkdwnIn   []string             `json:"mrkdwn_in,omitempty"`
-	Blocks     []any                `json:"blocks,omitempty"`
 }
 
 // Notify implements the Notifier interface.
@@ -109,15 +100,79 @@ 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
 
-	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
+	if len(n.conf.MrkdwnIn) == 0 {
+		markdownIn = []string{"fallback", "pretext", "text"}
+	} else {
+		markdownIn = n.conf.MrkdwnIn
 	}
 
-	if len(attachments) > 0 {
-		n.addFieldsAndActions(&attachments[0], tmplText)
+	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
 	}
 
 	req := &request{
@@ -127,7 +182,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: attachments,
+		Attachments: []attachment{*att},
 	}
 	if err != nil {
 		return false, err
@@ -183,150 +238,6 @@ 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,9 +17,6 @@ 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"
@@ -32,19 +29,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -58,15 +49,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -82,15 +71,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -106,15 +93,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -199,7 +184,6 @@ 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{},
@@ -207,9 +191,8 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 					APIURL:         &config.SecretURL{URL: apiurl},
 					Channel:        "channelname",
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				promslog.NewNopLogger(),
-				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -259,7 +242,6 @@ 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{},
@@ -268,9 +250,8 @@ func TestSlackTimeout(t *testing.T) {
 					Channel:        "channelname",
 					Timeout:        tt.timeout,
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				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) {
@@ -301,225 +282,6 @@ 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) {
@@ -567,7 +329,7 @@ func TestSlackMessageField(t *testing.T) {
 	tmpl.ExternalURL = u
 
 	logger := slog.New(slog.DiscardHandler)
-	notifier, err := New(conf, tmpl, logger, newTestTemplater(tmpl))
+	notifier, err := New(conf, tmpl, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/alertmanager/alertmanagernotify/webhook/webhook.go

@@ -14,7 +14,6 @@ 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"
@@ -29,16 +28,15 @@ 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
-	templater alertmanagertypes.Templater
+	conf    *config.WebhookConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new Webhook.
-func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -50,8 +48,7 @@ func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, templ
 		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{},
-		templater: templater,
+		retrier: &notify.Retrier{},
 	}, nil
 }
 

pkg/alertmanager/alertmanagernotify/webhook/webhook_test.go

@@ -9,7 +9,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -21,7 +20,6 @@ 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"
@@ -29,15 +27,13 @@ import (
 )
 
 func TestWebhookRetry(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.WebhookConfig{
 			URL:        config.SecretTemplateURL("http://example.com"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	if err != nil {
 		require.NoError(t, err)
@@ -100,16 +96,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		templater,
 	)
 	require.NoError(t, err)
 
@@ -125,15 +118,13 @@ 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{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	require.NoError(t, err)
 
@@ -187,15 +178,13 @@ 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{},
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				promslog.NewNopLogger(),
-				alertmanagertemplate.New(tmpl, slog.Default()),
 			)
 			require.NoError(t, err)
 

pkg/alertmanager/alertmanagerserver/config.go

@@ -28,13 +28,6 @@ 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 {
@@ -107,6 +100,5 @@ func NewConfig() Config {
 			MaintenanceInterval: 15 * time.Minute,
 			Retention:           120 * time.Hour,
 		},
-		Templates: []string{"/root/templates/alertmanager/*.gotmpl"},
 	}
 }

pkg/alertmanager/alertmanagerserver/server.go

@@ -10,7 +10,6 @@ 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"
@@ -24,8 +23,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"
 )
 
@@ -66,7 +65,6 @@ type Server struct {
 	muter               *MaintenanceMuter
 	marker              *types.MemMarker
 	tmpl                *template.Template
-	templater           alertmanagertypes.Templater
 	wg                  sync.WaitGroup
 	stopc               chan struct{}
 	notificationManager nfmanager.NotificationManager
@@ -244,21 +242,13 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 	config := alertmanagerConfig.AlertmanagerConfig()
 
 	var err error
-	// 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)
+	server.tmpl, err = alertmanagertypes.FromGlobs(config.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{})
@@ -275,7 +265,7 @@ 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, server.templater)
+		integrations, err := alertmanagernotify.NewReceiverIntegrations(rcv, server.tmpl, server.logger)
 		if err != nil {
 			return err
 		}
@@ -352,7 +342,7 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 
 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, server.templater, testAlert.Labels, testAlert)
+	return alertmanagertypes.TestReceiver(ctx, receiver, alertmanagernotify.NewReceiverIntegrations, server.alertmanagerConfig, server.tmpl, server.logger, testAlert.Labels, testAlert)
 }
 
 func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmanagertypes.PostableAlert][]string, config *alertmanagertypes.NotificationConfig) error {
@@ -435,7 +425,6 @@ func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmana
 					server.alertmanagerConfig,
 					server.tmpl,
 					server.logger,
-					server.templater,
 					group.groupLabels,
 					group.alerts...,
 				)

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go

@@ -15,6 +15,13 @@ 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
@@ -22,7 +29,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) alertmanagertypes.Templater {
+func New(tmpl *template.Template, logger *slog.Logger) Templater {
 	return &templater{tmpl: tmpl, logger: logger}
 }
 
@@ -130,9 +137,6 @@ 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,
@@ -140,7 +144,7 @@ func (at *templater) expandBody(
 	if bodyTemplate == "" {
 		return nil, nil, nil
 	}
-	sb := make([]string, len(ntd.Alerts))
+	var sb []string
 	missingVars := make(map[string]bool)
 	for i := range ntd.Alerts {
 		processRes, err := preProcessTemplateAndData(bodyTemplate, &ntd.Alerts[i])
@@ -151,10 +155,13 @@ 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
 		}
-		sb[i] = strings.TrimSpace(part)
+		if strings.TrimSpace(part) != "" {
+			sb = append(sb, strings.TrimSpace(part))
+		}
 	}
 	return sb, missingVars, nil
 }
@@ -182,20 +189,17 @@ func (at *templater) buildNotificationTemplateData(
 		externalURL = at.tmpl.ExternalURL.String()
 	}
 
-	// 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 })
+	commonAnnotations := 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 template-visible surfaces; the structured
-	// fields on AlertInfo/RuleInfo already hold anything a template needs from
-	// them.
-	commonAnnotations := alertmanagertypes.FilterPublicAnnotations(rawCommonAnnotations)
+	// 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)
 	annotations = alertmanagertypes.FilterPublicAnnotations(annotations)
 
 	// build the alert data slice
@@ -229,7 +233,7 @@ func (at *templater) buildNotificationTemplateData(
 			TotalFiring:   firing,
 			TotalResolved: resolved,
 		},
-		Rule:              buildRuleInfo(commonLabels, rawCommonAnnotations),
+		Rule:              buildRuleInfo(commonLabels, commonAnnotations),
 		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) (alertmanagertypes.Templater, context.Context) {
+func testSetup(t *testing.T) (Templater, context.Context) {
 	t.Helper()
 	tmpl := test.CreateTmpl(t)
 	ctx := context.Background()

pkg/emailing/config.go

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

pkg/flagger/registry.go

@@ -3,15 +3,14 @@ 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")
-	FeatureUseDashboardV2      = featuretypes.MustNewName("use_dashboard_v2")
+	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")
 )
 
 func MustNewRegistry() featuretypes.Registry {
@@ -80,14 +79,6 @@ 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/modules/user/impluser/setter.go

@@ -3,6 +3,7 @@ package impluser
 import (
 	"context"
 	"log/slog"
+	"slices"
 	"strings"
 	"time"
 
@@ -20,6 +21,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/types/emailtypes"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -369,6 +371,10 @@ func (module *setter) DeleteUser(ctx context.Context, orgID valuer.UUID, id stri
 		return errors.WithAdditionalf(err, "cannot delete already deleted user")
 	}
 
+	if slices.Contains(integrationtypes.AllIntegrationUserEmails, integrationtypes.IntegrationUserEmail(user.Email.String())) {
+		return errors.New(errors.TypeForbidden, errors.CodeForbidden, "integration user cannot be deleted")
+	}
+
 	deleter, err := module.store.GetUser(ctx, valuer.MustNewUUID(deletedBy))
 	if err != nil {
 		return err

pkg/query-service/app/cloudintegrations/Readme.md

@@ -0,0 +1,5 @@
+# SigNoz Cloud Integrations
+
+Cloud integrations are unlike the rest of SigNoz integrations.
+They have a different UX and so require a different API.
+They will also be limited in number and are not expected to have community contributed implementations

pkg/query-service/app/cloudintegrations/accountsRepo.go

@@ -0,0 +1,220 @@
+package cloudintegrations
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type cloudProviderAccountsRepository interface {
+	listConnected(ctx context.Context, orgId string, provider string) ([]integrationtypes.CloudIntegration, *model.ApiError)
+
+	get(ctx context.Context, orgId string, provider string, id string) (*integrationtypes.CloudIntegration, *model.ApiError)
+
+	getConnectedCloudAccount(ctx context.Context, orgId string, provider string, accountID string) (*integrationtypes.CloudIntegration, *model.ApiError)
+
+	// Insert an account or update it by (cloudProvider, id)
+	// for specified non-empty fields
+	upsert(
+		ctx context.Context,
+		orgId string,
+		provider string,
+		id *string,
+		config *integrationtypes.AccountConfig,
+		accountId *string,
+		agentReport *integrationtypes.AgentReport,
+		removedAt *time.Time,
+	) (*integrationtypes.CloudIntegration, *model.ApiError)
+}
+
+func newCloudProviderAccountsRepository(store sqlstore.SQLStore) (
+	*cloudProviderAccountsSQLRepository, error,
+) {
+	return &cloudProviderAccountsSQLRepository{
+		store: store,
+	}, nil
+}
+
+type cloudProviderAccountsSQLRepository struct {
+	store sqlstore.SQLStore
+}
+
+func (r *cloudProviderAccountsSQLRepository) listConnected(
+	ctx context.Context, orgId string, cloudProvider string,
+) ([]integrationtypes.CloudIntegration, *model.ApiError) {
+	accounts := []integrationtypes.CloudIntegration{}
+
+	err := r.store.BunDB().NewSelect().
+		Model(&accounts).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", cloudProvider).
+		Where("removed_at is NULL").
+		Where("account_id is not NULL").
+		Where("last_agent_report is not NULL").
+		Order("created_at").
+		Scan(ctx)
+
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not query connected cloud accounts: %w", err,
+		))
+	}
+
+	return accounts, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) get(
+	ctx context.Context, orgId string, provider string, id string,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	var result integrationtypes.CloudIntegration
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", provider).
+		Where("id = ?", id).
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find account with Id %s", id,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud provider accounts: %w", err,
+		))
+	}
+
+	return &result, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) getConnectedCloudAccount(
+	ctx context.Context, orgId string, provider string, accountId string,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	var result integrationtypes.CloudIntegration
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", provider).
+		Where("account_id = ?", accountId).
+		Where("last_agent_report is not NULL").
+		Where("removed_at is NULL").
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find connected cloud account %s", accountId,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud provider accounts: %w", err,
+		))
+	}
+
+	return &result, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) upsert(
+	ctx context.Context,
+	orgId string,
+	provider string,
+	id *string,
+	config *integrationtypes.AccountConfig,
+	accountId *string,
+	agentReport *integrationtypes.AgentReport,
+	removedAt *time.Time,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	// Insert
+	if id == nil {
+		temp := valuer.GenerateUUID().StringValue()
+		id = &temp
+	}
+
+	// Prepare clause for setting values in `on conflict do update`
+	onConflictSetStmts := []string{}
+	setColStatement := func(col string) string {
+		return fmt.Sprintf("%s=excluded.%s", col, col)
+	}
+
+	if config != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("config"),
+		)
+	}
+
+	if accountId != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("account_id"),
+		)
+	}
+
+	if agentReport != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("last_agent_report"),
+		)
+	}
+
+	if removedAt != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("removed_at"),
+		)
+	}
+
+	// set updated_at to current timestamp if it's an upsert
+	onConflictSetStmts = append(
+		onConflictSetStmts, setColStatement("updated_at"),
+	)
+
+	onConflictClause := ""
+	if len(onConflictSetStmts) > 0 {
+		onConflictClause = fmt.Sprintf(
+			"conflict(id) do update SET\n%s",
+			strings.Join(onConflictSetStmts, ",\n"),
+		)
+	}
+
+	integration := integrationtypes.CloudIntegration{
+		OrgID:        orgId,
+		Provider:     provider,
+		Identifiable: types.Identifiable{ID: valuer.MustNewUUID(*id)},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+		Config:          config,
+		AccountID:       accountId,
+		LastAgentReport: agentReport,
+		RemovedAt:       removedAt,
+	}
+
+	_, dbErr := r.store.BunDB().NewInsert().
+		Model(&integration).
+		On(onConflictClause).
+		Exec(ctx)
+
+	if dbErr != nil {
+		// for now returning internal error even if there is a conflict,
+		// will be handled better in the future iteration
+		return nil, model.InternalError(fmt.Errorf(
+			"could not upsert cloud account record: %w", dbErr,
+		))
+	}
+
+	upsertedAccount, apiErr := r.get(ctx, orgId, provider, *id)
+	if apiErr != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't fetch upserted account by id: %w", apiErr.ToError(),
+		))
+	}
+
+	return upsertedAccount, nil
+}

pkg/query-service/app/cloudintegrations/constants.go

@@ -0,0 +1,43 @@
+package cloudintegrations
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+var (
+	CodeInvalidCloudRegion    = errors.MustNewCode("invalid_cloud_region")
+	CodeMismatchCloudProvider = errors.MustNewCode("cloud_provider_mismatch")
+)
+
+// List of all valid cloud regions on Amazon Web Services
+var ValidAWSRegions = map[string]bool{
+	"af-south-1":     true, // Africa (Cape Town).
+	"ap-east-1":      true, // Asia Pacific (Hong Kong).
+	"ap-northeast-1": true, // Asia Pacific (Tokyo).
+	"ap-northeast-2": true, // Asia Pacific (Seoul).
+	"ap-northeast-3": true, // Asia Pacific (Osaka).
+	"ap-south-1":     true, // Asia Pacific (Mumbai).
+	"ap-south-2":     true, // Asia Pacific (Hyderabad).
+	"ap-southeast-1": true, // Asia Pacific (Singapore).
+	"ap-southeast-2": true, // Asia Pacific (Sydney).
+	"ap-southeast-3": true, // Asia Pacific (Jakarta).
+	"ap-southeast-4": true, // Asia Pacific (Melbourne).
+	"ca-central-1":   true, // Canada (Central).
+	"ca-west-1":      true, // Canada West (Calgary).
+	"eu-central-1":   true, // Europe (Frankfurt).
+	"eu-central-2":   true, // Europe (Zurich).
+	"eu-north-1":     true, // Europe (Stockholm).
+	"eu-south-1":     true, // Europe (Milan).
+	"eu-south-2":     true, // Europe (Spain).
+	"eu-west-1":      true, // Europe (Ireland).
+	"eu-west-2":      true, // Europe (London).
+	"eu-west-3":      true, // Europe (Paris).
+	"il-central-1":   true, // Israel (Tel Aviv).
+	"me-central-1":   true, // Middle East (UAE).
+	"me-south-1":     true, // Middle East (Bahrain).
+	"sa-east-1":      true, // South America (Sao Paulo).
+	"us-east-1":      true, // US East (N. Virginia).
+	"us-east-2":      true, // US East (Ohio).
+	"us-west-1":      true, // US West (N. California).
+	"us-west-2":      true, // US West (Oregon).
+}

pkg/query-service/app/cloudintegrations/controller.go

@@ -0,0 +1,625 @@
+package cloudintegrations
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"golang.org/x/exp/maps"
+)
+
+var SupportedCloudProviders = []string{
+	"aws",
+}
+
+func validateCloudProviderName(name string) *model.ApiError {
+	if !slices.Contains(SupportedCloudProviders, name) {
+		return model.BadRequest(fmt.Errorf("invalid cloud provider: %s", name))
+	}
+	return nil
+}
+
+type Controller struct {
+	accountsRepo      cloudProviderAccountsRepository
+	serviceConfigRepo ServiceConfigDatabase
+}
+
+func NewController(sqlStore sqlstore.SQLStore) (*Controller, error) {
+	accountsRepo, err := newCloudProviderAccountsRepository(sqlStore)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create cloud provider accounts repo: %w", err)
+	}
+
+	serviceConfigRepo, err := newServiceConfigRepository(sqlStore)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create cloud provider service config repo: %w", err)
+	}
+
+	return &Controller{
+		accountsRepo:      accountsRepo,
+		serviceConfigRepo: serviceConfigRepo,
+	}, nil
+}
+
+type ConnectedAccountsListResponse struct {
+	Accounts []integrationtypes.Account `json:"accounts"`
+}
+
+func (c *Controller) ListConnectedAccounts(ctx context.Context, orgId string, cloudProvider string) (
+	*ConnectedAccountsListResponse, *model.ApiError,
+) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	accountRecords, apiErr := c.accountsRepo.listConnected(ctx, orgId, cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list cloud accounts")
+	}
+
+	connectedAccounts := []integrationtypes.Account{}
+	for _, a := range accountRecords {
+		connectedAccounts = append(connectedAccounts, a.Account())
+	}
+
+	return &ConnectedAccountsListResponse{
+		Accounts: connectedAccounts,
+	}, nil
+}
+
+type GenerateConnectionUrlRequest struct {
+	// Optional. To be specified for updates.
+	AccountId *string `json:"account_id,omitempty"`
+
+	AccountConfig integrationtypes.AccountConfig `json:"account_config"`
+
+	AgentConfig SigNozAgentConfig `json:"agent_config"`
+}
+
+type SigNozAgentConfig struct {
+	// The region in which SigNoz agent should be installed.
+	Region string `json:"region"`
+
+	IngestionUrl string `json:"ingestion_url"`
+	IngestionKey string `json:"ingestion_key"`
+	SigNozAPIUrl string `json:"signoz_api_url"`
+	SigNozAPIKey string `json:"signoz_api_key"`
+
+	Version string `json:"version,omitempty"`
+}
+
+type GenerateConnectionUrlResponse struct {
+	AccountId     string `json:"account_id"`
+	ConnectionUrl string `json:"connection_url"`
+}
+
+func (c *Controller) GenerateConnectionUrl(ctx context.Context, orgId string, cloudProvider string, req GenerateConnectionUrlRequest) (*GenerateConnectionUrlResponse, *model.ApiError) {
+	// Account connection with a simple connection URL may not be available for all providers.
+	if cloudProvider != "aws" {
+		return nil, model.BadRequest(fmt.Errorf("unsupported cloud provider: %s", cloudProvider))
+	}
+
+	account, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, req.AccountId, &req.AccountConfig, nil, nil, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	agentVersion := "v0.0.8"
+	if req.AgentConfig.Version != "" {
+		agentVersion = req.AgentConfig.Version
+	}
+
+	connectionUrl := fmt.Sprintf(
+		"https://%s.console.aws.amazon.com/cloudformation/home?region=%s#/stacks/quickcreate?",
+		req.AgentConfig.Region, req.AgentConfig.Region,
+	)
+
+	for qp, value := range map[string]string{
+		"param_SigNozIntegrationAgentVersion": agentVersion,
+		"param_SigNozApiUrl":                  req.AgentConfig.SigNozAPIUrl,
+		"param_SigNozApiKey":                  req.AgentConfig.SigNozAPIKey,
+		"param_SigNozAccountId":               account.ID.StringValue(),
+		"param_IngestionUrl":                  req.AgentConfig.IngestionUrl,
+		"param_IngestionKey":                  req.AgentConfig.IngestionKey,
+		"stackName":                           "signoz-integration",
+		"templateURL": fmt.Sprintf(
+			"https://signoz-integrations.s3.us-east-1.amazonaws.com/aws-quickcreate-template-%s.json",
+			agentVersion,
+		),
+	} {
+		connectionUrl += fmt.Sprintf("&%s=%s", qp, url.QueryEscape(value))
+	}
+
+	return &GenerateConnectionUrlResponse{
+		AccountId:     account.ID.StringValue(),
+		ConnectionUrl: connectionUrl,
+	}, nil
+}
+
+type AccountStatusResponse struct {
+	Id             string                         `json:"id"`
+	CloudAccountId *string                        `json:"cloud_account_id,omitempty"`
+	Status         integrationtypes.AccountStatus `json:"status"`
+}
+
+func (c *Controller) GetAccountStatus(ctx context.Context, orgId string, cloudProvider string, accountId string) (
+	*AccountStatusResponse, *model.ApiError,
+) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	account, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, accountId)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	resp := AccountStatusResponse{
+		Id:             account.ID.StringValue(),
+		CloudAccountId: account.AccountID,
+		Status:         account.Status(),
+	}
+
+	return &resp, nil
+}
+
+type AgentCheckInRequest struct {
+	ID        string `json:"account_id"`
+	AccountID string `json:"cloud_account_id"`
+	// Arbitrary cloud specific Agent data
+	Data map[string]any `json:"data,omitempty"`
+}
+
+type AgentCheckInResponse struct {
+	AccountId      string     `json:"account_id"`
+	CloudAccountId string     `json:"cloud_account_id"`
+	RemovedAt      *time.Time `json:"removed_at"`
+
+	IntegrationConfig IntegrationConfigForAgent `json:"integration_config"`
+}
+
+type IntegrationConfigForAgent struct {
+	EnabledRegions []string `json:"enabled_regions"`
+
+	TelemetryCollectionStrategy *CompiledCollectionStrategy `json:"telemetry,omitempty"`
+}
+
+func (c *Controller) CheckInAsAgent(ctx context.Context, orgId string, cloudProvider string, req AgentCheckInRequest) (*AgentCheckInResponse, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	existingAccount, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, req.ID)
+	if existingAccount != nil && existingAccount.AccountID != nil && *existingAccount.AccountID != req.AccountID {
+		return nil, model.BadRequest(fmt.Errorf(
+			"can't check in with new %s account id %s for account %s with existing %s id %s",
+			cloudProvider, req.AccountID, existingAccount.ID.StringValue(), cloudProvider, *existingAccount.AccountID,
+		))
+	}
+
+	existingAccount, apiErr = c.accountsRepo.getConnectedCloudAccount(ctx, orgId, cloudProvider, req.AccountID)
+	if existingAccount != nil && existingAccount.ID.StringValue() != req.ID {
+		return nil, model.BadRequest(fmt.Errorf(
+			"can't check in to %s account %s with id %s. already connected with id %s",
+			cloudProvider, req.AccountID, req.ID, existingAccount.ID.StringValue(),
+		))
+	}
+
+	agentReport := integrationtypes.AgentReport{
+		TimestampMillis: time.Now().UnixMilli(),
+		Data:            req.Data,
+	}
+
+	account, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &req.ID, nil, &req.AccountID, &agentReport, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	// prepare and return integration config to be consumed by agent
+	compiledStrategy, err := NewCompiledCollectionStrategy(cloudProvider)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't init telemetry collection strategy: %w", err,
+		))
+	}
+
+	agentConfig := IntegrationConfigForAgent{
+		EnabledRegions:              []string{},
+		TelemetryCollectionStrategy: compiledStrategy,
+	}
+
+	if account.Config != nil && account.Config.EnabledRegions != nil {
+		agentConfig.EnabledRegions = account.Config.EnabledRegions
+	}
+
+	services, err := services.Map(cloudProvider)
+	if err != nil {
+		return nil, err
+	}
+
+	svcConfigs, apiErr := c.serviceConfigRepo.getAllForAccount(
+		ctx, orgId, account.ID.StringValue(),
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(
+			apiErr, "couldn't get service configs for cloud account",
+		)
+	}
+
+	// accumulate config in a fixed order to ensure same config generated across runs
+	configuredServices := maps.Keys(svcConfigs)
+	slices.Sort(configuredServices)
+
+	for _, svcType := range configuredServices {
+		definition, ok := services[svcType]
+		if !ok {
+			continue
+		}
+		config := svcConfigs[svcType]
+
+		err := AddServiceStrategy(svcType, compiledStrategy, definition.Strategy, config)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &AgentCheckInResponse{
+		AccountId:         account.ID.StringValue(),
+		CloudAccountId:    *account.AccountID,
+		RemovedAt:         account.RemovedAt,
+		IntegrationConfig: agentConfig,
+	}, nil
+}
+
+type UpdateAccountConfigRequest struct {
+	Config integrationtypes.AccountConfig `json:"config"`
+}
+
+func (c *Controller) UpdateAccountConfig(ctx context.Context, orgId string, cloudProvider string, accountId string, req UpdateAccountConfigRequest) (*integrationtypes.Account, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	accountRecord, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &accountId, &req.Config, nil, nil, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	account := accountRecord.Account()
+
+	return &account, nil
+}
+
+func (c *Controller) DisconnectAccount(ctx context.Context, orgId string, cloudProvider string, accountId string) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	account, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, accountId)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't disconnect account")
+	}
+
+	tsNow := time.Now()
+	account, apiErr = c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &accountId, nil, nil, nil, &tsNow,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't disconnect account")
+	}
+
+	return account, nil
+}
+
+type ListServicesResponse struct {
+	Services []ServiceSummary `json:"services"`
+}
+
+func (c *Controller) ListServices(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	cloudAccountId *string,
+) (*ListServicesResponse, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	definitions, apiErr := services.List(cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list cloud services")
+	}
+
+	svcConfigs := map[string]*integrationtypes.CloudServiceConfig{}
+	if cloudAccountId != nil {
+		activeAccount, apiErr := c.accountsRepo.getConnectedCloudAccount(
+			ctx, orgID, cloudProvider, *cloudAccountId,
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(apiErr, "couldn't get active account")
+		}
+		svcConfigs, apiErr = c.serviceConfigRepo.getAllForAccount(
+			ctx, orgID, activeAccount.ID.StringValue(),
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(
+				apiErr, "couldn't get service configs for cloud account",
+			)
+		}
+	}
+
+	summaries := []ServiceSummary{}
+	for _, def := range definitions {
+		summary := ServiceSummary{
+			Metadata: def.Metadata,
+		}
+		summary.Config = svcConfigs[summary.Id]
+
+		summaries = append(summaries, summary)
+	}
+
+	return &ListServicesResponse{
+		Services: summaries,
+	}, nil
+}
+
+func (c *Controller) GetServiceDetails(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	serviceId string,
+	cloudAccountId *string,
+) (*ServiceDetails, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	definition, err := services.GetServiceDefinition(cloudProvider, serviceId)
+	if err != nil {
+		return nil, err
+	}
+
+	details := ServiceDetails{
+		Definition: *definition,
+	}
+
+	if cloudAccountId != nil {
+
+		activeAccount, apiErr := c.accountsRepo.getConnectedCloudAccount(
+			ctx, orgID, cloudProvider, *cloudAccountId,
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(apiErr, "couldn't get active account")
+		}
+
+		config, apiErr := c.serviceConfigRepo.get(
+			ctx, orgID, activeAccount.ID.StringValue(), serviceId,
+		)
+		if apiErr != nil && apiErr.Type() != model.ErrorNotFound {
+			return nil, model.WrapApiError(apiErr, "couldn't fetch service config")
+		}
+
+		if config != nil {
+			details.Config = config
+
+			enabled := false
+			if config.Metrics != nil && config.Metrics.Enabled {
+				enabled = true
+			}
+
+			// add links to service dashboards, making them clickable.
+			for i, d := range definition.Assets.Dashboards {
+				dashboardUuid := c.dashboardUuid(
+					cloudProvider, serviceId, d.Id,
+				)
+				if enabled {
+					definition.Assets.Dashboards[i].Url = fmt.Sprintf("/dashboard/%s", dashboardUuid)
+				} else {
+					definition.Assets.Dashboards[i].Url = "" // to unset the in-memory URL if enabled once and disabled afterwards
+				}
+			}
+		}
+	}
+
+	return &details, nil
+}
+
+type UpdateServiceConfigRequest struct {
+	CloudAccountId string                              `json:"cloud_account_id"`
+	Config         integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+func (u *UpdateServiceConfigRequest) Validate(def *services.Definition) error {
+	if def.Id != services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "s3 buckets can only be added to service-type[%s]", services.S3Sync)
+	} else if def.Id == services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
+		for region := range u.Config.Logs.S3Buckets {
+			if _, found := ValidAWSRegions[region]; !found {
+				return errors.NewInvalidInputf(CodeInvalidCloudRegion, "invalid cloud region: %s", region)
+			}
+		}
+	}
+
+	return nil
+}
+
+type UpdateServiceConfigResponse struct {
+	Id     string                              `json:"id"`
+	Config integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+func (c *Controller) UpdateServiceConfig(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	serviceType string,
+	req *UpdateServiceConfigRequest,
+) (*UpdateServiceConfigResponse, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	// can only update config for a valid service.
+	definition, err := services.GetServiceDefinition(cloudProvider, serviceType)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := req.Validate(definition); err != nil {
+		return nil, err
+	}
+
+	// can only update config for a connected cloud account id
+	_, apiErr := c.accountsRepo.getConnectedCloudAccount(
+		ctx, orgID, cloudProvider, req.CloudAccountId,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't find connected cloud account")
+	}
+
+	updatedConfig, apiErr := c.serviceConfigRepo.upsert(
+		ctx, orgID, cloudProvider, req.CloudAccountId, serviceType, req.Config,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't update service config")
+	}
+
+	return &UpdateServiceConfigResponse{
+		Id:     serviceType,
+		Config: *updatedConfig,
+	}, nil
+}
+
+// All dashboards that are available based on cloud integrations configuration
+// across all cloud providers
+func (c *Controller) AvailableDashboards(ctx context.Context, orgId valuer.UUID) ([]*dashboardtypes.Dashboard, *model.ApiError) {
+	allDashboards := []*dashboardtypes.Dashboard{}
+
+	for _, provider := range []string{"aws"} {
+		providerDashboards, apiErr := c.AvailableDashboardsForCloudProvider(ctx, orgId, provider)
+		if apiErr != nil {
+			return nil, model.WrapApiError(
+				apiErr, fmt.Sprintf("couldn't get available dashboards for %s", provider),
+			)
+		}
+
+		allDashboards = append(allDashboards, providerDashboards...)
+	}
+
+	return allDashboards, nil
+}
+
+func (c *Controller) AvailableDashboardsForCloudProvider(ctx context.Context, orgID valuer.UUID, cloudProvider string) ([]*dashboardtypes.Dashboard, *model.ApiError) {
+	accountRecords, apiErr := c.accountsRepo.listConnected(ctx, orgID.StringValue(), cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list connected cloud accounts")
+	}
+
+	// for v0, service dashboards are only available when metrics are enabled.
+	servicesWithAvailableMetrics := map[string]*time.Time{}
+
+	for _, ar := range accountRecords {
+		if ar.AccountID != nil {
+			configsBySvcId, apiErr := c.serviceConfigRepo.getAllForAccount(
+				ctx, orgID.StringValue(), ar.ID.StringValue(),
+			)
+			if apiErr != nil {
+				return nil, apiErr
+			}
+
+			for svcId, config := range configsBySvcId {
+				if config.Metrics != nil && config.Metrics.Enabled {
+					servicesWithAvailableMetrics[svcId] = &ar.CreatedAt
+				}
+			}
+		}
+	}
+
+	allServices, apiErr := services.List(cloudProvider)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	svcDashboards := []*dashboardtypes.Dashboard{}
+	for _, svc := range allServices {
+		serviceDashboardsCreatedAt := servicesWithAvailableMetrics[svc.Id]
+		if serviceDashboardsCreatedAt != nil {
+			for _, d := range svc.Assets.Dashboards {
+				author := fmt.Sprintf("%s-integration", cloudProvider)
+				svcDashboards = append(svcDashboards, &dashboardtypes.Dashboard{
+					ID:     c.dashboardUuid(cloudProvider, svc.Id, d.Id),
+					Locked: true,
+					Data:   *d.Definition,
+					TimeAuditable: types.TimeAuditable{
+						CreatedAt: *serviceDashboardsCreatedAt,
+						UpdatedAt: *serviceDashboardsCreatedAt,
+					},
+					UserAuditable: types.UserAuditable{
+						CreatedBy: author,
+						UpdatedBy: author,
+					},
+					OrgID: orgID,
+				})
+			}
+			servicesWithAvailableMetrics[svc.Id] = nil
+		}
+	}
+
+	return svcDashboards, nil
+}
+func (c *Controller) GetDashboardById(ctx context.Context, orgId valuer.UUID, dashboardUuid string) (*dashboardtypes.Dashboard, *model.ApiError) {
+	cloudProvider, _, _, apiErr := c.parseDashboardUuid(dashboardUuid)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	allDashboards, apiErr := c.AvailableDashboardsForCloudProvider(ctx, orgId, cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list available dashboards")
+	}
+
+	for _, d := range allDashboards {
+		if d.ID == dashboardUuid {
+			return d, nil
+		}
+	}
+
+	return nil, model.NotFoundError(fmt.Errorf("couldn't find dashboard with uuid: %s", dashboardUuid))
+}
+
+func (c *Controller) dashboardUuid(
+	cloudProvider string, svcId string, dashboardId string,
+) string {
+	return fmt.Sprintf("cloud-integration--%s--%s--%s", cloudProvider, svcId, dashboardId)
+}
+
+func (c *Controller) parseDashboardUuid(dashboardUuid string) (cloudProvider string, svcId string, dashboardId string, apiErr *model.ApiError) {
+	parts := strings.SplitN(dashboardUuid, "--", 4)
+	if len(parts) != 4 || parts[0] != "cloud-integration" {
+		return "", "", "", model.BadRequest(fmt.Errorf("invalid cloud integration dashboard id"))
+	}
+
+	return parts[1], parts[2], parts[3], nil
+}
+
+func (c *Controller) IsCloudIntegrationDashboardUuid(dashboardUuid string) bool {
+	_, _, _, apiErr := c.parseDashboardUuid(dashboardUuid)
+	return apiErr == nil
+}

pkg/query-service/app/cloudintegrations/models.go

@@ -0,0 +1,94 @@
+package cloudintegrations
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+)
+
+type ServiceSummary struct {
+	services.Metadata
+
+	Config *integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+type ServiceDetails struct {
+	services.Definition
+
+	Config           *integrationtypes.CloudServiceConfig `json:"config"`
+	ConnectionStatus *ServiceConnectionStatus             `json:"status,omitempty"`
+}
+
+type AccountStatus struct {
+	Integration AccountIntegrationStatus `json:"integration"`
+}
+
+type AccountIntegrationStatus struct {
+	LastHeartbeatTsMillis *int64 `json:"last_heartbeat_ts_ms"`
+}
+
+type LogsConfig struct {
+	Enabled   bool                `json:"enabled"`
+	S3Buckets map[string][]string `json:"s3_buckets,omitempty"`
+}
+
+type MetricsConfig struct {
+	Enabled bool `json:"enabled"`
+}
+
+type ServiceConnectionStatus struct {
+	Logs    *SignalConnectionStatus `json:"logs"`
+	Metrics *SignalConnectionStatus `json:"metrics"`
+}
+
+type SignalConnectionStatus struct {
+	LastReceivedTsMillis int64  `json:"last_received_ts_ms"` // epoch milliseconds
+	LastReceivedFrom     string `json:"last_received_from"`  // resource identifier
+}
+
+type CompiledCollectionStrategy = services.CollectionStrategy
+
+func NewCompiledCollectionStrategy(provider string) (*CompiledCollectionStrategy, error) {
+	if provider == "aws" {
+		return &CompiledCollectionStrategy{
+			Provider:   "aws",
+			AWSMetrics: &services.AWSMetricsStrategy{},
+			AWSLogs:    &services.AWSLogsStrategy{},
+		}, nil
+	}
+	return nil, errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", provider)
+}
+
+// Helper for accumulating strategies for enabled services.
+func AddServiceStrategy(serviceType string, cs *CompiledCollectionStrategy,
+	definitionStrat *services.CollectionStrategy, config *integrationtypes.CloudServiceConfig) error {
+	if definitionStrat.Provider != cs.Provider {
+		return errors.NewInternalf(CodeMismatchCloudProvider, "can't add %s service strategy to compiled strategy for %s",
+			definitionStrat.Provider, cs.Provider)
+	}
+
+	if cs.Provider == "aws" {
+		if config.Logs != nil && config.Logs.Enabled {
+			if serviceType == services.S3Sync {
+				// S3 bucket sync; No cloudwatch logs are appended for this service type;
+				// Though definition is populated with a custom cloudwatch group that helps in calculating logs connection status
+				cs.S3Buckets = config.Logs.S3Buckets
+			} else if definitionStrat.AWSLogs != nil { // services that includes a logs subscription
+				cs.AWSLogs.Subscriptions = append(
+					cs.AWSLogs.Subscriptions,
+					definitionStrat.AWSLogs.Subscriptions...,
+				)
+			}
+		}
+		if config.Metrics != nil && config.Metrics.Enabled && definitionStrat.AWSMetrics != nil {
+			cs.AWSMetrics.StreamFilters = append(
+				cs.AWSMetrics.StreamFilters,
+				definitionStrat.AWSMetrics.StreamFilters...,
+			)
+		}
+
+		return nil
+	}
+
+	return errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", cs.Provider)
+}

pkg/query-service/app/cloudintegrations/serviceconfig_db.go

@@ -0,0 +1,165 @@
+package cloudintegrations
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type ServiceConfigDatabase interface {
+	get(
+		ctx context.Context,
+		orgID string,
+		cloudAccountId string,
+		serviceType string,
+	) (*integrationtypes.CloudServiceConfig, *model.ApiError)
+
+	upsert(
+		ctx context.Context,
+		orgID string,
+		cloudProvider string,
+		cloudAccountId string,
+		serviceId string,
+		config integrationtypes.CloudServiceConfig,
+	) (*integrationtypes.CloudServiceConfig, *model.ApiError)
+
+	getAllForAccount(
+		ctx context.Context,
+		orgID string,
+		cloudAccountId string,
+	) (
+		configsBySvcId map[string]*integrationtypes.CloudServiceConfig,
+		apiErr *model.ApiError,
+	)
+}
+
+func newServiceConfigRepository(store sqlstore.SQLStore) (
+	*serviceConfigSQLRepository, error,
+) {
+	return &serviceConfigSQLRepository{
+		store: store,
+	}, nil
+}
+
+type serviceConfigSQLRepository struct {
+	store sqlstore.SQLStore
+}
+
+func (r *serviceConfigSQLRepository) get(
+	ctx context.Context,
+	orgID string,
+	cloudAccountId string,
+	serviceType string,
+) (*integrationtypes.CloudServiceConfig, *model.ApiError) {
+
+	var result integrationtypes.CloudIntegrationService
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Join("JOIN cloud_integration ci ON ci.id = cis.cloud_integration_id").
+		Where("ci.org_id = ?", orgID).
+		Where("ci.id = ?", cloudAccountId).
+		Where("cis.type = ?", serviceType).
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find config for cloud account %s",
+			cloudAccountId,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud service config: %w", err,
+		))
+	}
+
+	return &result.Config, nil
+
+}
+
+func (r *serviceConfigSQLRepository) upsert(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	cloudAccountId string,
+	serviceId string,
+	config integrationtypes.CloudServiceConfig,
+) (*integrationtypes.CloudServiceConfig, *model.ApiError) {
+
+	// get cloud integration id from account id
+	// if the account is not connected, we don't need to upsert the config
+	var cloudIntegrationId string
+	err := r.store.BunDB().NewSelect().
+		Model((*integrationtypes.CloudIntegration)(nil)).
+		Column("id").
+		Where("provider = ?", cloudProvider).
+		Where("account_id = ?", cloudAccountId).
+		Where("org_id = ?", orgID).
+		Where("removed_at is NULL").
+		Where("last_agent_report is not NULL").
+		Scan(ctx, &cloudIntegrationId)
+
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud integration id: %w", err,
+		))
+	}
+
+	serviceConfig := integrationtypes.CloudIntegrationService{
+		Identifiable: types.Identifiable{ID: valuer.GenerateUUID()},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+		Config:             config,
+		Type:               serviceId,
+		CloudIntegrationID: cloudIntegrationId,
+	}
+	_, err = r.store.BunDB().NewInsert().
+		Model(&serviceConfig).
+		On("conflict(cloud_integration_id, type) do update set config=excluded.config, updated_at=excluded.updated_at").
+		Exec(ctx)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not upsert cloud service config: %w", err,
+		))
+	}
+
+	return &serviceConfig.Config, nil
+
+}
+
+func (r *serviceConfigSQLRepository) getAllForAccount(
+	ctx context.Context,
+	orgID string,
+	cloudAccountId string,
+) (map[string]*integrationtypes.CloudServiceConfig, *model.ApiError) {
+	serviceConfigs := []integrationtypes.CloudIntegrationService{}
+
+	err := r.store.BunDB().NewSelect().
+		Model(&serviceConfigs).
+		Join("JOIN cloud_integration ci ON ci.id = cis.cloud_integration_id").
+		Where("ci.id = ?", cloudAccountId).
+		Where("ci.org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not query service configs from db: %w", err,
+		))
+	}
+
+	result := map[string]*integrationtypes.CloudServiceConfig{}
+
+	for _, r := range serviceConfigs {
+		result[r.Type] = &r.Config
+	}
+
+	return result, nil
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 85 85" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-linecap="round" stroke-linejoin="round"><use xlink:href="#A" x="2.5" y="2.5"/><symbol id="A" overflow="visible"><g stroke="none"><path d="M0 41.579C0 20.293 17.84 3.157 40 3.157s40 17.136 40 38.422S62.16 80 40 80 0 62.864 0 41.579z" fill="#9d5025"/><path d="M0 38.422C0 17.136 17.84 0 40 0s40 17.136 40 38.422-17.84 38.422-40 38.422S0 59.707 0 38.422z" fill="#f58536"/><path d="M51.672 7.387v13.952H28.327V7.387zm18.061 40.378v11.364h-11.83V47.765zm-14.958 0v11.364h-11.83V47.765zm-18.206 0v11.364h-11.83V47.765zm-14.959 0v11.364H9.78V47.765z"/><path d="M14.63 37.929h2.13v11.149h-2.13z"/><path d="M14.63 37.929h17.088v2.045H14.63z"/><path d="M29.589 37.929h2.13v11.149H29.59zm18.206 0h2.13v11.149h-2.13z"/><path d="M47.795 37.929h17.088v2.045H47.795z"/><path d="M62.754 37.929h2.13v11.149h-2.129zm-40.631-7.954h2.13v8.977h-2.13zM38.935 19.28h2.13v10.859h-2.129z"/><path d="M22.123 29.116h35.32v2.045h-35.32z"/><path d="M55.314 29.975h2.13v8.977h-2.129z"/></g></symbol></svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/integration.json

@@ -0,0 +1,467 @@
+{
+  "id": "alb",
+  "title": "ALB",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_count",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_max",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_min",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_sum",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/ApplicationELB"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "ALB Overview",
+        "description": "Overview of Application Load Balancer",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/overview.md

@@ -0,0 +1,3 @@
+### Monitor Application Load Balancers with SigNoz
+
+Collect key ALB metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/icon.svg

@@ -0,0 +1,14 @@
+<svg width="24px" height="24px" viewBox="0 0 24 24" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <defs>
+        <linearGradient x1="0%" y1="100%" x2="100%" y2="0%" id="linearGradient-1">
+            <stop stop-color="#4D27A8" offset="0%"></stop>
+            <stop stop-color="#A166FF" offset="100%"></stop>
+        </linearGradient>
+    </defs>
+    <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g fill="url(#linearGradient-1)">
+            <rect id="Rectangle" x="0" y="0" width="24" height="24"></rect>
+        </g>
+        <path d="M6,6.76751613 L8,5.43446738 L8,18.5659476 L6,17.2328988 L6,6.76751613 Z M5,6.49950633 L5,17.4999086 C5,17.6669147 5.084,17.8239204 5.223,17.9159238 L8.223,19.9159969 C8.307,19.971999 8.403,20 8.5,20 C8.581,20 8.662,19.9809993 8.736,19.9409978 C8.898,19.8539947 9,19.6849885 9,19.4999817 L9,16.9998903 L10,16.9998903 L10,15.9998537 L9,15.9998537 L9,7.99956118 L10,7.99956118 L10,6.99952461 L9,6.99952461 L9,4.49943319 C9,4.31542646 8.898,4.14542025 8.736,4.0594171 C8.574,3.97241392 8.377,3.98141425 8.223,4.08341798 L5.223,6.08349112 C5.084,6.17649452 5,6.33250022 5,6.49950633 L5,6.49950633 Z M19,17.2328988 L17,18.5659476 L17,5.43446738 L19,6.76751613 L19,17.2328988 Z M19.777,6.08349112 L16.777,4.08341798 C16.623,3.98141425 16.426,3.97241392 16.264,4.0594171 C16.102,4.14542025 16,4.31542646 16,4.49943319 L16,6.99952461 L15,6.99952461 L15,7.99956118 L16,7.99956118 L16,15.9998537 L15,15.9998537 L15,16.9998903 L16,16.9998903 L16,19.4999817 C16,19.6849885 16.102,19.8539947 16.264,19.9409978 C16.338,19.9809993 16.419,20 16.5,20 C16.597,20 16.693,19.971999 16.777,19.9159969 L19.777,17.9159238 C19.916,17.8239204 20,17.6669147 20,17.4999086 L20,6.49950633 C20,6.33250022 19.916,6.17649452 19.777,6.08349112 L19.777,6.08349112 Z M13,7.99956118 L14,7.99956118 L14,6.99952461 L13,6.99952461 L13,7.99956118 Z M11,7.99956118 L12,7.99956118 L12,6.99952461 L11,6.99952461 L11,7.99956118 Z M13,16.9998903 L14,16.9998903 L14,15.9998537 L13,15.9998537 L13,16.9998903 Z M11,16.9998903 L12,16.9998903 L12,15.9998537 L11,15.9998537 L11,16.9998903 Z M13.18,14.884813 L10.18,12.3847215 C10.065,12.288718 10,12.1487129 10,11.9997075 C10,11.851702 10.065,11.7106969 10.18,11.6156934 L13.18,9.11560199 L13.82,9.88463011 L11.281,11.9997075 L13.82,14.1157848 L13.18,14.884813 Z" id="Amazon-API-Gateway_Icon_16_Squid" fill="#FFFFFF"></path>
+    </g>
+</svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/integration.json

@@ -0,0 +1,199 @@
+{
+  "id": "api-gateway",
+  "title": "API Gateway",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": true
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_ApiGateway_4XXError_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      }
+    ],
+    "logs": [
+      {
+        "name": "Account Id",
+        "path": "resources.cloud.account.id",
+        "type": "string"
+      },
+      {
+        "name": "Log Group Name",
+        "path": "resources.aws.cloudwatch.log_group_name",
+        "type": "string"
+      },
+      {
+        "name": "Log Stream Name",
+        "path": "resources.aws.cloudwatch.log_stream_name",
+        "type": "string"
+      }
+    ]
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/ApiGateway"
+        }
+      ]
+    },
+    "aws_logs": {
+      "cloudwatch_logs_subscriptions": [
+        {
+          "log_group_name_prefix": "API-Gateway",
+          "filter_pattern": ""
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "API Gateway Overview",
+        "description": "Overview of API Gateway",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/overview.md

@@ -0,0 +1,3 @@
+### Monitor API Gateway with SigNoz
+
+Collect key API Gateway metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/dynamodb/integration.json

@@ -0,0 +1,394 @@
+{
+  "id": "dynamodb",
+  "title": "DynamoDB",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      }
+    ]
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/DynamoDB"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "DynamoDB Overview",
+        "description": "Overview of DynamoDB",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/dynamodb/overview.md

@@ -0,0 +1,3 @@
+### Monitor DynamoDB with SigNoz
+
+Collect DynamoDB Key Metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/icon.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none">
+  <path fill="#9D5025" d="M1.702 2.98L1 3.312v9.376l.702.332 2.842-4.777L1.702 2.98z" />
+  <path fill="#F58536" d="M3.339 12.657l-1.637.363V2.98l1.637.353v9.324z" />
+  <path fill="#9D5025" d="M2.476 2.612l.863-.406 4.096 6.216-4.096 5.372-.863-.406V2.612z" />
+  <path fill="#F58536" d="M5.38 13.248l-2.041.546V2.206l2.04.548v10.494z" />
+  <path fill="#9D5025" d="M4.3 1.75l1.08-.512 6.043 7.864-6.043 5.66-1.08-.511V1.749z" />
+  <path fill="#F58536" d="M7.998 13.856l-2.618.906V1.238l2.618.908v11.71z" />
+  <path fill="#9D5025" d="M6.602.66L7.998 0l6.538 8.453L7.998 16l-1.396-.66V.66z" />
+  <path fill="#F58536" d="M15 12.686L7.998 16V0L15 3.314v9.372z" />
+</svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/integration.json

@@ -0,0 +1,518 @@
+{
+  "id": "ec2",
+  "title": "EC2",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_EC2_CPUCreditBalance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/EC2"
+        },
+        {
+          "Namespace": "CWAgent"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "EC2 Overview",
+        "description": "Overview of EC2",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/overview.md

@@ -0,0 +1,3 @@
+### Monitor EC2 with SigNoz
+
+Collect key EC2 metrics and view them with an out of the box dashboard.