chore(release): bump to v0.125.0 (#11369)

Co-authored-by: primus-bot[bot] <171087277+primus-bot[bot]@users.noreply.github.com>

.mockery.yml

@@ -8,6 +8,14 @@ packages:
       filename: "alertmanager.go"
       structname: 'Mock{{.InterfaceName}}'
       pkgname: '{{.SrcPackageName}}test'
+  github.com/SigNoz/signoz/pkg/types/alertmanagertypes:
+    interfaces:
+      MaintenanceStore:
+    config:
+      dir: '{{.InterfaceDir}}/alertmanagertypestest'
+      filename: "maintenance.go"
+      structname: 'Mock{{.InterfaceName}}'
+      pkgname: '{{.SrcPackageName}}test'
   github.com/SigNoz/signoz/pkg/tokenizer:
     config:
       all: true

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.124.0
+    image: signoz/signoz:v0.125.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.124.0
+    image: signoz/signoz:v0.125.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.124.0}
+    image: signoz/signoz:${VERSION:-v0.125.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.124.0}
+    image: signoz/signoz:${VERSION:-v0.125.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

docs/api/openapi.yml

@@ -96,6 +96,53 @@ components:
       - createdAt
       - updatedAt
       type: object
+    AlertmanagertypesMaintenanceKind:
+      enum:
+      - fixed
+      - recurring
+      type: string
+    AlertmanagertypesMaintenanceStatus:
+      enum:
+      - active
+      - upcoming
+      - expired
+      type: string
+    AlertmanagertypesPlannedMaintenance:
+      properties:
+        alertIds:
+          items:
+            type: string
+          nullable: true
+          type: array
+        createdAt:
+          format: date-time
+          type: string
+        createdBy:
+          type: string
+        description:
+          type: string
+        id:
+          type: string
+        kind:
+          $ref: '#/components/schemas/AlertmanagertypesMaintenanceKind'
+        name:
+          type: string
+        schedule:
+          $ref: '#/components/schemas/AlertmanagertypesSchedule'
+        status:
+          $ref: '#/components/schemas/AlertmanagertypesMaintenanceStatus'
+        updatedAt:
+          format: date-time
+          type: string
+        updatedBy:
+          type: string
+      required:
+      - id
+      - name
+      - schedule
+      - status
+      - kind
+      type: object
     AlertmanagertypesPostableChannel:
       oneOf:
       - required:
@@ -212,6 +259,23 @@ components:
       required:
       - name
       type: object
+    AlertmanagertypesPostablePlannedMaintenance:
+      properties:
+        alertIds:
+          items:
+            type: string
+          nullable: true
+          type: array
+        description:
+          type: string
+        name:
+          type: string
+        schedule:
+          $ref: '#/components/schemas/AlertmanagertypesSchedule'
+      required:
+      - name
+      - schedule
+      type: object
     AlertmanagertypesPostableRoutePolicy:
       properties:
         channels:
@@ -237,6 +301,60 @@ components:
       - channels
       - name
       type: object
+    AlertmanagertypesRecurrence:
+      properties:
+        duration:
+          type: string
+        endTime:
+          format: date-time
+          nullable: true
+          type: string
+        repeatOn:
+          items:
+            $ref: '#/components/schemas/AlertmanagertypesRepeatOn'
+          nullable: true
+          type: array
+        repeatType:
+          $ref: '#/components/schemas/AlertmanagertypesRepeatType'
+        startTime:
+          format: date-time
+          type: string
+      required:
+      - startTime
+      - duration
+      - repeatType
+      type: object
+    AlertmanagertypesRepeatOn:
+      enum:
+      - sunday
+      - monday
+      - tuesday
+      - wednesday
+      - thursday
+      - friday
+      - saturday
+      type: string
+    AlertmanagertypesRepeatType:
+      enum:
+      - daily
+      - weekly
+      - monthly
+      type: string
+    AlertmanagertypesSchedule:
+      properties:
+        endTime:
+          format: date-time
+          type: string
+        recurrence:
+          $ref: '#/components/schemas/AlertmanagertypesRecurrence'
+        startTime:
+          format: date-time
+          type: string
+        timezone:
+          type: string
+      required:
+      - timezone
+      type: object
     AuthtypesAttributeMapping:
       properties:
         email:
@@ -5137,17 +5255,6 @@ components:
         message:
           type: string
       type: object
-    RuletypesMaintenanceKind:
-      enum:
-      - fixed
-      - recurring
-      type: string
-    RuletypesMaintenanceStatus:
-      enum:
-      - active
-      - upcoming
-      - expired
-      type: string
     RuletypesMatchType:
       enum:
       - at_least_once
@@ -5175,59 +5282,6 @@ components:
       - table
       - graph
       type: string
-    RuletypesPlannedMaintenance:
-      properties:
-        alertIds:
-          items:
-            type: string
-          nullable: true
-          type: array
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        description:
-          type: string
-        id:
-          type: string
-        kind:
-          $ref: '#/components/schemas/RuletypesMaintenanceKind'
-        name:
-          type: string
-        schedule:
-          $ref: '#/components/schemas/RuletypesSchedule'
-        status:
-          $ref: '#/components/schemas/RuletypesMaintenanceStatus'
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - name
-      - schedule
-      - status
-      - kind
-      type: object
-    RuletypesPostablePlannedMaintenance:
-      properties:
-        alertIds:
-          items:
-            type: string
-          nullable: true
-          type: array
-        description:
-          type: string
-        name:
-          type: string
-        schedule:
-          $ref: '#/components/schemas/RuletypesSchedule'
-      required:
-      - name
-      - schedule
-      type: object
     RuletypesPostableRule:
       properties:
         alert:
@@ -5280,29 +5334,6 @@ components:
       - clickhouse_sql
       - promql
       type: string
-    RuletypesRecurrence:
-      properties:
-        duration:
-          type: string
-        endTime:
-          format: date-time
-          nullable: true
-          type: string
-        repeatOn:
-          items:
-            $ref: '#/components/schemas/RuletypesRepeatOn'
-          nullable: true
-          type: array
-        repeatType:
-          $ref: '#/components/schemas/RuletypesRepeatType'
-        startTime:
-          format: date-time
-          type: string
-      required:
-      - startTime
-      - duration
-      - repeatType
-      type: object
     RuletypesRenotify:
       properties:
         alertStates:
@@ -5314,22 +5345,6 @@ components:
         interval:
           type: string
       type: object
-    RuletypesRepeatOn:
-      enum:
-      - sunday
-      - monday
-      - tuesday
-      - wednesday
-      - thursday
-      - friday
-      - saturday
-      type: string
-    RuletypesRepeatType:
-      enum:
-      - daily
-      - weekly
-      - monthly
-      type: string
     RuletypesRollingWindow:
       properties:
         evalWindow:
@@ -5449,21 +5464,6 @@ components:
       - promql_rule
       - anomaly_rule
       type: string
-    RuletypesSchedule:
-      properties:
-        endTime:
-          format: date-time
-          type: string
-        recurrence:
-          $ref: '#/components/schemas/RuletypesRecurrence'
-        startTime:
-          format: date-time
-          type: string
-        timezone:
-          type: string
-      required:
-      - timezone
-      type: object
     RuletypesScheduleType:
       enum:
       - hourly
@@ -8024,7 +8024,7 @@ paths:
                 properties:
                   data:
                     items:
-                      $ref: '#/components/schemas/RuletypesPlannedMaintenance'
+                      $ref: '#/components/schemas/AlertmanagertypesPlannedMaintenance'
                     type: array
                   status:
                     type: string
@@ -8067,7 +8067,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/RuletypesPostablePlannedMaintenance'
+              $ref: '#/components/schemas/AlertmanagertypesPostablePlannedMaintenance'
       responses:
         "201":
           content:
@@ -8075,7 +8075,7 @@ paths:
               schema:
                 properties:
                   data:
-                    $ref: '#/components/schemas/RuletypesPlannedMaintenance'
+                    $ref: '#/components/schemas/AlertmanagertypesPlannedMaintenance'
                   status:
                     type: string
                 required:
@@ -8178,7 +8178,7 @@ paths:
               schema:
                 properties:
                   data:
-                    $ref: '#/components/schemas/RuletypesPlannedMaintenance'
+                    $ref: '#/components/schemas/AlertmanagertypesPlannedMaintenance'
                   status:
                     type: string
                 required:
@@ -8232,7 +8232,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/RuletypesPostablePlannedMaintenance'
+              $ref: '#/components/schemas/AlertmanagertypesPostablePlannedMaintenance'
       responses:
         "204":
           description: No Content

ee/query-service/rules/manager.go

@@ -13,7 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -49,7 +48,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, tr)
 
 		// create ch rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeProm {
 
@@ -73,7 +72,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, pr)
 
 		// create promql rule task for evaluation
-		task = newTask(baserules.TaskTypeProm, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeProm, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeAnomaly {
 		// create anomaly rule
@@ -96,7 +95,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, ar)
 
 		// create anomaly rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
@@ -210,9 +209,9 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 }
 
 // newTask returns an appropriate group for the rule type
-func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) baserules.Task {
+func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc) baserules.Task {
 	if taskType == baserules.TaskTypeCh {
-		return baserules.NewRuleTask(name, "", frequency, rules, opts, notify, maintenanceStore, orgID)
+		return baserules.NewRuleTask(name, "", frequency, rules, opts, notify)
 	}
-	return baserules.NewPromRuleTask(name, "", frequency, rules, opts, notify, maintenanceStore, orgID)
+	return baserules.NewPromRuleTask(name, "", frequency, rules, opts, notify)
 }

frontend/src/api/generated/services/downtimeschedules/index.ts

@@ -18,6 +18,7 @@ import type {
 } from 'react-query';
 
 import type {
+	AlertmanagertypesPostablePlannedMaintenanceDTO,
 	CreateDowntimeSchedule201,
 	DeleteDowntimeScheduleByIDPathParameters,
 	GetDowntimeScheduleByID200,
@@ -25,7 +26,6 @@ import type {
 	ListDowntimeSchedules200,
 	ListDowntimeSchedulesParams,
 	RenderErrorResponseDTO,
-	RuletypesPostablePlannedMaintenanceDTO,
 	UpdateDowntimeScheduleByIDPathParameters,
 } from '../sigNoz.schemas';
 
@@ -135,14 +135,14 @@ export const invalidateListDowntimeSchedules = async (
  * @summary Create downtime schedule
  */
 export const createDowntimeSchedule = (
-	ruletypesPostablePlannedMaintenanceDTO?: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
+	alertmanagertypesPostablePlannedMaintenanceDTO?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateDowntimeSchedule201>({
 		url: `/api/v1/downtime_schedules`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostablePlannedMaintenanceDTO,
+		data: alertmanagertypesPostablePlannedMaintenanceDTO,
 		signal,
 	});
 };
@@ -154,13 +154,13 @@ export const getCreateDowntimeScheduleMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+		{ data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+	{ data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO> },
 	TContext
 > => {
 	const mutationKey = ['createDowntimeSchedule'];
@@ -174,7 +174,7 @@ export const getCreateDowntimeScheduleMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> }
+		{ data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -188,7 +188,7 @@ export type CreateDowntimeScheduleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>
 >;
 export type CreateDowntimeScheduleMutationBody =
-	| BodyType<RuletypesPostablePlannedMaintenanceDTO>
+	| BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>
 	| undefined;
 export type CreateDowntimeScheduleMutationError =
 	ErrorType<RenderErrorResponseDTO>;
@@ -203,13 +203,13 @@ export const useCreateDowntimeSchedule = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+		{ data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+	{ data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO> },
 	TContext
 > => {
 	return useMutation(getCreateDowntimeScheduleMutationOptions(options));
@@ -403,14 +403,14 @@ export const invalidateGetDowntimeScheduleByID = async (
  */
 export const updateDowntimeScheduleByID = (
 	{ id }: UpdateDowntimeScheduleByIDPathParameters,
-	ruletypesPostablePlannedMaintenanceDTO?: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
+	alertmanagertypesPostablePlannedMaintenanceDTO?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/downtime_schedules/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostablePlannedMaintenanceDTO,
+		data: alertmanagertypesPostablePlannedMaintenanceDTO,
 		signal,
 	});
 };
@@ -424,7 +424,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>;
 		},
 		TContext
 	>;
@@ -433,7 +433,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+		data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>;
 	},
 	TContext
 > => {
@@ -450,7 +450,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -465,7 +465,7 @@ export type UpdateDowntimeScheduleByIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>
 >;
 export type UpdateDowntimeScheduleByIDMutationBody =
-	| BodyType<RuletypesPostablePlannedMaintenanceDTO>
+	| BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>
 	| undefined;
 export type UpdateDowntimeScheduleByIDMutationError =
 	ErrorType<RenderErrorResponseDTO>;
@@ -482,7 +482,7 @@ export const useUpdateDowntimeScheduleByID = <
 		TError,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>;
 		},
 		TContext
 	>;
@@ -491,7 +491,7 @@ export const useUpdateDowntimeScheduleByID = <
 	TError,
 	{
 		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+		data?: BodyType<AlertmanagertypesPostablePlannedMaintenanceDTO>;
 	},
 	TContext
 > => {

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

@@ -134,6 +134,109 @@ export interface AlertmanagertypesGettableRoutePolicyDTO {
 	updatedBy?: string | null;
 }
 
+export enum AlertmanagertypesMaintenanceKindDTO {
+	fixed = 'fixed',
+	recurring = 'recurring',
+}
+export enum AlertmanagertypesMaintenanceStatusDTO {
+	active = 'active',
+	upcoming = 'upcoming',
+	expired = 'expired',
+}
+export enum AlertmanagertypesRepeatOnDTO {
+	sunday = 'sunday',
+	monday = 'monday',
+	tuesday = 'tuesday',
+	wednesday = 'wednesday',
+	thursday = 'thursday',
+	friday = 'friday',
+	saturday = 'saturday',
+}
+export enum AlertmanagertypesRepeatTypeDTO {
+	daily = 'daily',
+	weekly = 'weekly',
+	monthly = 'monthly',
+}
+export interface AlertmanagertypesRecurrenceDTO {
+	/**
+	 * @type string
+	 */
+	duration: string;
+	/**
+	 * @type string,null
+	 * @format date-time
+	 */
+	endTime?: string | null;
+	/**
+	 * @type array,null
+	 */
+	repeatOn?: AlertmanagertypesRepeatOnDTO[] | null;
+	repeatType: AlertmanagertypesRepeatTypeDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	startTime: string;
+}
+
+export interface AlertmanagertypesScheduleDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	endTime?: string;
+	recurrence?: AlertmanagertypesRecurrenceDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	startTime?: string;
+	/**
+	 * @type string
+	 */
+	timezone: string;
+}
+
+export interface AlertmanagertypesPlannedMaintenanceDTO {
+	/**
+	 * @type array,null
+	 */
+	alertIds?: string[] | null;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: string;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type string
+	 */
+	id: string;
+	kind: AlertmanagertypesMaintenanceKindDTO;
+	/**
+	 * @type string
+	 */
+	name: string;
+	schedule: AlertmanagertypesScheduleDTO;
+	status: AlertmanagertypesMaintenanceStatusDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: string;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+}
+
 export interface ConfigAuthorizationDTO {
 	/**
 	 * @type string
@@ -1597,6 +1700,22 @@ export type AlertmanagertypesPostableChannelDTO = unknown & {
 	wechat_configs?: ConfigWechatConfigDTO[];
 };
 
+export interface AlertmanagertypesPostablePlannedMaintenanceDTO {
+	/**
+	 * @type array,null
+	 */
+	alertIds?: string[] | null;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type string
+	 */
+	name: string;
+	schedule: AlertmanagertypesScheduleDTO;
+}
+
 export interface AlertmanagertypesPostableRoutePolicyDTO {
 	/**
 	 * @type array,null
@@ -6116,15 +6235,6 @@ export interface RuletypesGettableTestRuleDTO {
 	message?: string;
 }
 
-export enum RuletypesMaintenanceKindDTO {
-	fixed = 'fixed',
-	recurring = 'recurring',
-}
-export enum RuletypesMaintenanceStatusDTO {
-	active = 'active',
-	upcoming = 'upcoming',
-	expired = 'expired',
-}
 export interface RuletypesRenotifyDTO {
 	/**
 	 * @type array
@@ -6156,116 +6266,6 @@ export interface RuletypesNotificationSettingsDTO {
 	usePolicy?: boolean;
 }
 
-export enum RuletypesRepeatOnDTO {
-	sunday = 'sunday',
-	monday = 'monday',
-	tuesday = 'tuesday',
-	wednesday = 'wednesday',
-	thursday = 'thursday',
-	friday = 'friday',
-	saturday = 'saturday',
-}
-export enum RuletypesRepeatTypeDTO {
-	daily = 'daily',
-	weekly = 'weekly',
-	monthly = 'monthly',
-}
-export interface RuletypesRecurrenceDTO {
-	/**
-	 * @type string
-	 */
-	duration: string;
-	/**
-	 * @type string,null
-	 * @format date-time
-	 */
-	endTime?: string | null;
-	/**
-	 * @type array,null
-	 */
-	repeatOn?: RuletypesRepeatOnDTO[] | null;
-	repeatType: RuletypesRepeatTypeDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	startTime: string;
-}
-
-export interface RuletypesScheduleDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	endTime?: string;
-	recurrence?: RuletypesRecurrenceDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	startTime?: string;
-	/**
-	 * @type string
-	 */
-	timezone: string;
-}
-
-export interface RuletypesPlannedMaintenanceDTO {
-	/**
-	 * @type array,null
-	 */
-	alertIds?: string[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type string
-	 */
-	description?: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	kind: RuletypesMaintenanceKindDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-	schedule: RuletypesScheduleDTO;
-	status: RuletypesMaintenanceStatusDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface RuletypesPostablePlannedMaintenanceDTO {
-	/**
-	 * @type array,null
-	 */
-	alertIds?: string[] | null;
-	/**
-	 * @type string
-	 */
-	description?: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	schedule: RuletypesScheduleDTO;
-}
-
 export type RuletypesPostableRuleDTOAnnotations = { [key: string]: string };
 
 export type RuletypesPostableRuleDTOLabels = { [key: string]: string };
@@ -7793,7 +7793,7 @@ export type ListDowntimeSchedules200 = {
 	/**
 	 * @type array
 	 */
-	data: RuletypesPlannedMaintenanceDTO[];
+	data: AlertmanagertypesPlannedMaintenanceDTO[];
 	/**
 	 * @type string
 	 */
@@ -7801,7 +7801,7 @@ export type ListDowntimeSchedules200 = {
 };
 
 export type CreateDowntimeSchedule201 = {
-	data: RuletypesPlannedMaintenanceDTO;
+	data: AlertmanagertypesPlannedMaintenanceDTO;
 	/**
 	 * @type string
 	 */
@@ -7815,7 +7815,7 @@ export type GetDowntimeScheduleByIDPathParameters = {
 	id: string;
 };
 export type GetDowntimeScheduleByID200 = {
-	data: RuletypesPlannedMaintenanceDTO;
+	data: AlertmanagertypesPlannedMaintenanceDTO;
 	/**
 	 * @type string
 	 */

frontend/src/container/AIAssistant/components/ActivityGroup/ActivityGroup.module.scss

@@ -1,64 +0,0 @@
-// Collapsed activity summary — one row that hides the underlying
-// thinking + tool-call steps. Reuses the same quiet treatment as
-// ThinkingStep / ToolCallStep so it sits flush in the assistant bubble.
-.activityGroup {
-	width: 100%;
-	font-size: 12px;
-}
-
-.activityHeader {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	padding: 4px 0;
-	background: transparent;
-	border: none;
-	cursor: pointer;
-	color: var(--l3-foreground);
-	user-select: none;
-	transition: color 0.12s ease;
-	width: 100%;
-	text-align: left;
-
-	&:hover {
-		color: var(--l1-foreground);
-	}
-}
-
-.sparkleIcon {
-	flex-shrink: 0;
-	color: var(--accent-primary);
-
-	&.iconPulsing {
-		animation: activityGroupPulse 1.4s ease-in-out infinite;
-	}
-}
-
-@keyframes activityGroupPulse {
-	0%,
-	100% {
-		opacity: 0.55;
-	}
-	50% {
-		opacity: 1;
-	}
-}
-
-.activitySummary {
-	flex: 1;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-	font-weight: 400;
-}
-
-.toggleChevron {
-	flex-shrink: 0;
-	color: inherit;
-}
-
-.activityBody {
-	display: flex;
-	flex-direction: column;
-	padding: 2px 0 4px;
-}

frontend/src/container/AIAssistant/components/ActivityGroup/ActivityGroup.tsx

@@ -1,148 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-import cx from 'classnames';
-import { ChevronDown, ChevronRight, Sparkles } from '@signozhq/icons';
-
-import { formatTime } from 'utils/timeUtils';
-
-import { StreamingToolCall } from '../../types';
-import ThinkingStep, { ThinkingContent, thinkingLabel } from '../ThinkingStep';
-import ToolCallStep, {
-	getToolDisplayLabel,
-	ToolCallContent,
-} from '../ToolCallStep';
-
-import styles from './ActivityGroup.module.scss';
-
-export type ActivityItem =
-	| { id: string; kind: 'thinking'; content: string }
-	| { id: string; kind: 'tool'; toolCall: StreamingToolCall };
-
-interface ActivityGroupProps {
-	items: ActivityItem[];
-	/**
-	 * True only for the trailing activity group of an active stream — drives
-	 * the live "Working…" label and the elapsed-time tick (which re-stamps on
-	 * approval/clarification resume so wait time isn't counted).
-	 */
-	isLive?: boolean;
-}
-
-/**
- * Single-item groups get a step-specific summary so the user doesn't see a
- * pointless "Worked through 1 step". Multi-item groups roll up into the
- * generic "Working… / Worked through N steps" treatment.
- */
-function buildSummary(
-	items: ActivityItem[],
-	isLive: boolean,
-	elapsed: number,
-): string {
-	if (items.length === 1) {
-		const [only] = items;
-		if (only.kind === 'thinking') {
-			return thinkingLabel(isLive);
-		}
-		return getToolDisplayLabel(only.toolCall);
-	}
-	const stepLabel = `${items.length} steps`;
-	if (!isLive) {
-		return `Worked through ${stepLabel}`;
-	}
-	// Suppress the elapsed token until ≥ 1s — the first tick fires after
-	// 1s anyway, and showing "0s" or "<1s" briefly adds noise.
-	return elapsed >= 1000
-		? `Working… · ${formatTime(elapsed / 1000)} · ${stepLabel}`
-		: `Working… · ${stepLabel}`;
-}
-
-/**
- * Single collapsed summary row that hides a run of thinking + tool-call steps.
- * Expands to show each underlying step inline. Used for every activity row
- * (including single-item ones) so all "what the agent did" rows share a
- * consistent ✨-led visual contract.
- */
-export default function ActivityGroup({
-	items,
-	isLive = false,
-}: ActivityGroupProps): JSX.Element {
-	const [expanded, setExpanded] = useState(false);
-
-	// Captures the moment this live phase started. Re-stamped on every
-	// false→true transition so a stream that pauses on
-	// approval/clarification and resumes doesn't roll the user's wait time
-	// into the elapsed counter.
-	const startedAtRef = useRef<number>(Date.now());
-	const wasLiveRef = useRef<boolean>(isLive);
-	const [elapsed, setElapsed] = useState(0);
-
-	useEffect(() => {
-		if (isLive && !wasLiveRef.current) {
-			startedAtRef.current = Date.now();
-			setElapsed(0);
-		}
-		wasLiveRef.current = isLive;
-
-		if (!isLive) {
-			return undefined;
-		}
-		// Tick once per second — the display is integer-second precision, so
-		// faster ticks would just re-render the bubble for no visible change.
-		const id = window.setInterval(() => {
-			setElapsed(Date.now() - startedAtRef.current);
-		}, 1000);
-		return (): void => window.clearInterval(id);
-	}, [isLive]);
-
-	const summary = buildSummary(items, isLive, elapsed);
-	const isSingle = items.length === 1;
-
-	const toggle = (): void => setExpanded((v) => !v);
-
-	return (
-		<div className={styles.activityGroup}>
-			<div className={styles.activityHeader} onClick={toggle}>
-				<Sparkles
-					size={12}
-					className={cx(styles.sparkleIcon, { [styles.iconPulsing]: isLive })}
-				/>
-				<span className={styles.activitySummary}>{summary}</span>
-				{expanded ? (
-					<ChevronDown size={12} className={styles.toggleChevron} />
-				) : (
-					<ChevronRight size={12} className={styles.toggleChevron} />
-				)}
-			</div>
-
-			{expanded && (
-				<div className={styles.activityBody}>
-					{isSingle ? (
-						// Single-item: the outer chevron already provides disclosure,
-						// so render the underlying content directly instead of wrapping
-						// it in a second collapsible step row.
-						items[0].kind === 'thinking' ? (
-							<ThinkingContent content={items[0].content} />
-						) : (
-							<ToolCallContent toolCall={items[0].toolCall} />
-						)
-					) : (
-						items.map((item, i) => {
-							// A thinking step is live only while it's the trailing item
-							// in a trailing live group — once any later event (text or
-							// tool) arrives, the pass is done.
-							const isLastItem = i === items.length - 1;
-							return item.kind === 'thinking' ? (
-								<ThinkingStep
-									key={item.id}
-									content={item.content}
-									isLive={isLive && isLastItem}
-								/>
-							) : (
-								<ToolCallStep key={item.id} toolCall={item.toolCall} />
-							);
-						})
-					)}
-				</div>
-			)}
-		</div>
-	);
-}

frontend/src/container/AIAssistant/components/ActivityGroup/index.ts

@@ -1,2 +0,0 @@
-export { default } from './ActivityGroup';
-export type { ActivityItem } from './ActivityGroup';

frontend/src/container/AIAssistant/components/MessageBubble/MessageBubble.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo } from 'react';
+import React from 'react';
 import cx from 'classnames';
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
@@ -9,10 +9,11 @@ import '../blocks';
 import { useVariant } from '../../VariantContext';
 import { Message, MessageBlock } from '../../types';
 import ActionsSection from '../ActionsSection';
-import ActivityGroup, { ActivityItem } from '../ActivityGroup';
 import { RichCodeBlock } from '../blocks';
 import { MessageContext } from '../MessageContext';
 import MessageFeedback from '../MessageFeedback';
+import ThinkingStep from '../ThinkingStep';
+import ToolCallStep from '../ToolCallStep';
 import UserMessageActions from '../UserMessageActions';
 
 import styles from './MessageBubble.module.scss';
@@ -39,61 +40,38 @@ function SmartPre({ children }: { children?: React.ReactNode }): JSX.Element {
 const MD_PLUGINS = [remarkGfm];
 const MD_COMPONENTS = { code: RichCodeBlock, pre: SmartPre };
 
-type RenderGroup =
-	| { kind: 'text'; id: string; content: string }
-	| { kind: 'activity'; id: string; items: ActivityItem[] };
-
-/**
- * Partition message blocks into render groups so consecutive thinking and
- * tool_call blocks collapse into a single ActivityGroup row. Text blocks
- * stand alone, mirroring the streaming view.
- */
-function groupBlocks(blocks: MessageBlock[]): RenderGroup[] {
-	const groups: RenderGroup[] = [];
-	blocks.forEach((block, i) => {
-		if (block.type === 'text') {
-			groups.push({ kind: 'text', id: `text-${i}`, content: block.content });
-			return;
-		}
-		const item: ActivityItem =
-			block.type === 'thinking'
-				? { id: `t-${i}`, kind: 'thinking', content: block.content }
-				: {
-						id: `c-${block.toolCallId}`,
-						kind: 'tool',
-						// Persisted blocks are always complete.
-						toolCall: {
-							toolName: block.toolName,
-							input: block.toolInput,
-							result: block.result,
-							done: true,
-							displayText: block.displayText,
-						},
-					};
-		const last = groups[groups.length - 1];
-		if (last?.kind === 'activity') {
-			last.items.push(item);
-		} else {
-			groups.push({ kind: 'activity', id: `a-${i}`, items: [item] });
-		}
-	});
-	return groups;
-}
-
-function renderGroup(group: RenderGroup): JSX.Element {
-	if (group.kind === 'text') {
-		return (
-			<ReactMarkdown
-				key={group.id}
-				className={styles.markdown}
-				remarkPlugins={MD_PLUGINS}
-				components={MD_COMPONENTS}
-			>
-				{group.content}
-			</ReactMarkdown>
-		);
+/** Renders a single MessageBlock by type. */
+function renderBlock(block: MessageBlock, index: number): JSX.Element {
+	switch (block.type) {
+		case 'thinking':
+			return <ThinkingStep key={index} content={block.content} />;
+		case 'tool_call':
+			// Blocks in a persisted message are always complete — done is always true.
+			return (
+				<ToolCallStep
+					key={index}
+					toolCall={{
+						toolName: block.toolName,
+						input: block.toolInput,
+						result: block.result,
+						done: true,
+						displayText: block.displayText,
+					}}
+				/>
+			);
+		case 'text':
+		default:
+			return (
+				<ReactMarkdown
+					key={index}
+					className={styles.markdown}
+					remarkPlugins={MD_PLUGINS}
+					components={MD_COMPONENTS}
+				>
+					{block.content}
+				</ReactMarkdown>
+			);
 	}
-	return <ActivityGroup key={group.id} items={group.items} />;
 }
 
 interface MessageBubbleProps {
@@ -112,14 +90,6 @@ export default function MessageBubble({
 	const isUser = message.role === 'user';
 	const hasBlocks = !isUser && message.blocks && message.blocks.length > 0;
 
-	// Recompute groups only when the blocks array identity changes — store
-	// updates that don't touch this message's blocks should not re-render the
-	// underlying ThinkingStep/ToolCallStep children.
-	const groups = useMemo(
-		() => (hasBlocks ? groupBlocks(message.blocks!) : []),
-		[hasBlocks, message.blocks],
-	);
-
 	const messageClass = cx(
 		styles.message,
 		isUser ? styles.user : styles.assistant,
@@ -158,7 +128,8 @@ export default function MessageBubble({
 							<p className={styles.text}>{message.content}</p>
 						) : hasBlocks ? (
 							<MessageContext.Provider value={{ messageId: message.id }}>
-								{groups.map((g) => renderGroup(g))}
+								{/* eslint-disable-next-line react/no-array-index-key */}
+								{message.blocks!.map((block, i) => renderBlock(block, i))}
 							</MessageContext.Provider>
 						) : (
 							<MessageContext.Provider value={{ messageId: message.id }}>

frontend/src/container/AIAssistant/components/StreamingMessage/StreamingMessage.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo } from 'react';
+import React from 'react';
 import cx from 'classnames';
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
@@ -10,10 +10,11 @@ import type {
 
 import { useVariant } from '../../VariantContext';
 import { StreamingEventItem } from '../../types';
-import ActivityGroup, { ActivityItem } from '../ActivityGroup';
 import ApprovalCard from '../ApprovalCard';
 import { RichCodeBlock } from '../blocks';
 import ClarificationForm from '../ClarificationForm';
+import ThinkingStep from '../ThinkingStep';
+import ToolCallStep from '../ToolCallStep';
 
 import messageStyles from '../MessageBubble/MessageBubble.module.scss';
 import styles from './StreamingMessage.module.scss';
@@ -32,59 +33,6 @@ function SmartPre({ children }: { children?: React.ReactNode }): JSX.Element {
 const MD_PLUGINS = [remarkGfm];
 const MD_COMPONENTS = { code: RichCodeBlock, pre: SmartPre };
 
-type RenderGroup =
-	| { kind: 'text'; id: string; content: string }
-	| {
-			kind: 'activity';
-			id: string;
-			items: ActivityItem[];
-			isTrailing: boolean;
-	  };
-
-/**
- * Partition the streaming event timeline into render groups: runs of
- * consecutive thinking/tool events fold into a single activity group, text
- * events stay standalone. The last group is flagged as trailing so the
- * caller can drive a "live" indicator on it.
- *
- * Invariant relied on by the ActivityGroup elapsed-time timer: once a
- * group exists at a given array index, later events only extend its
- * `items` — they never shrink the array or re-key existing groups. That
- * keeps each ActivityGroup React instance stable across re-renders so the
- * timer's `wasLive` → `isLive` re-stamp captures the right transition.
- * The id fields below piggyback on that invariant: each event's position in
- * `events` is stable, so the derived id stays stable across re-renders.
- */
-function groupStreamingEvents(events: StreamingEventItem[]): RenderGroup[] {
-	const groups: RenderGroup[] = [];
-	events.forEach((event, i) => {
-		if (event.kind === 'text') {
-			groups.push({ kind: 'text', id: `text-${i}`, content: event.content });
-			return;
-		}
-		const item: ActivityItem =
-			event.kind === 'thinking'
-				? { id: `t-${i}`, kind: 'thinking', content: event.content }
-				: { id: `c-${i}`, kind: 'tool', toolCall: event.toolCall };
-		const last = groups[groups.length - 1];
-		if (last?.kind === 'activity') {
-			last.items.push(item);
-		} else {
-			groups.push({
-				kind: 'activity',
-				id: `a-${i}`,
-				items: [item],
-				isTrailing: false,
-			});
-		}
-	});
-	const last = groups[groups.length - 1];
-	if (last?.kind === 'activity') {
-		last.isTrailing = true;
-	}
-	return groups;
-}
-
 /** Human-readable labels for execution status codes shown before any events arrive. */
 const STATUS_LABEL: Record<string, string> = {
 	queued: 'Queued…',
@@ -131,11 +79,6 @@ export default function StreamingMessage({
 		[messageStyles.compact]: isCompact,
 	});
 
-	// Recompute groups only when the events array identity changes. The
-	// streaming reducer pushes new entries into the same array reference
-	// once per tick, so this naturally invalidates as events arrive.
-	const groups = useMemo(() => groupStreamingEvents(events), [events]);
-
 	return (
 		<div className={messageClass}>
 			<div className={messageStyles.bubble}>
@@ -145,28 +88,27 @@ export default function StreamingMessage({
 				)}
 				{isEmpty && !statusLabel && <TypingDots />}
 
-				{/* Runs of consecutive thinking + tool events collapse into a
-				    single ActivityGroup; text events render inline between
-				    them. The trailing group is "live" while streaming is
-				    active and not blocked on the user. */}
-				{groups.map((group) => {
-					if (group.kind === 'text') {
-						return (
-							<ReactMarkdown
-								key={group.id}
-								className={messageStyles.markdown}
-								remarkPlugins={MD_PLUGINS}
-								components={MD_COMPONENTS}
-							>
-								{group.content}
-							</ReactMarkdown>
-						);
+				{/* eslint-disable react/no-array-index-key */}
+				{/* Events rendered in arrival order: text, thinking, and tool calls interleaved */}
+				{events.map((event, i) => {
+					if (event.kind === 'tool') {
+						return <ToolCallStep key={i} toolCall={event.toolCall} />;
+					}
+					if (event.kind === 'thinking') {
+						return <ThinkingStep key={i} content={event.content} />;
 					}
-					const groupIsLive = group.isTrailing && !isWaitingOnUser;
 					return (
-						<ActivityGroup key={group.id} items={group.items} isLive={groupIsLive} />
+						<ReactMarkdown
+							key={i}
+							className={messageStyles.markdown}
+							remarkPlugins={MD_PLUGINS}
+							components={MD_COMPONENTS}
+						>
+							{event.content}
+						</ReactMarkdown>
 					);
 				})}
+				{/* eslint-enable react/no-array-index-key */}
 
 				{/* While events are still streaming, append the typing dots so the
 				    user has a clear "more is coming" signal. Hidden when the agent

frontend/src/container/AIAssistant/components/ThinkingStep/ThinkingStep.tsx

@@ -5,31 +5,11 @@ import styles from './ThinkingStep.module.scss';
 
 interface ThinkingStepProps {
 	content: string;
-	/**
-	 * When false, label reads "Thought for a few seconds" — intentionally
-	 * vague because the API doesn't persist precise timing, so showing
-	 * seconds would be inconsistent between fresh and reloaded threads.
-	 */
-	isLive?: boolean;
-}
-
-/** Body of a thinking step — extracted so ActivityGroup can render it directly. */
-export function ThinkingContent({ content }: { content: string }): JSX.Element {
-	return (
-		<div className={styles.body}>
-			<p className={styles.content}>{content}</p>
-		</div>
-	);
-}
-
-export function thinkingLabel(isLive: boolean): string {
-	return isLive ? 'Thinking…' : 'Thought for a few seconds';
 }
 
 /** Collapsible thinking row — chevron + label, content in the expanded body. */
 export default function ThinkingStep({
 	content,
-	isLive = false,
 }: ThinkingStepProps): JSX.Element {
 	const [expanded, setExpanded] = useState(false);
 
@@ -43,10 +23,14 @@ export default function ThinkingStep({
 				) : (
 					<ChevronRight size={12} className={styles.chevron} />
 				)}
-				<span className={styles.label}>{thinkingLabel(isLive)}</span>
+				<span className={styles.label}>Thinking</span>
 			</div>
 
-			{expanded && <ThinkingContent content={content} />}
+			{expanded && (
+				<div className={styles.body}>
+					<p className={styles.content}>{content}</p>
+				</div>
+			)}
 		</div>
 	);
 }

frontend/src/container/AIAssistant/components/ToolCallStep/ToolCallStep.tsx

@@ -10,58 +10,24 @@ interface ToolCallStepProps {
 	toolCall: StreamingToolCall;
 }
 
-/**
- * Server-supplied `displayText` is the human-friendly title the backend
- * wants surfaced. Falls back to a derived label
- * ("signoz_get_dashboard" → "Get Dashboard") when missing.
- */
-export function getToolDisplayLabel(toolCall: StreamingToolCall): string {
-	const { toolName, displayText } = toolCall;
-	if (displayText && displayText.trim().length > 0) {
-		return displayText;
-	}
-	return toolName
-		.replace(/^[a-z]+_/, '') // strip prefix like "signoz_"
-		.replace(/_/g, ' ')
-		.replace(/\b\w/g, (c) => c.toUpperCase());
-}
-
-/** Body of a tool-call step — extracted so ActivityGroup can render it directly. */
-export function ToolCallContent({
-	toolCall,
-}: {
-	toolCall: StreamingToolCall;
-}): JSX.Element {
-	const { toolName, input, result, done } = toolCall;
-	return (
-		<div className={styles.body}>
-			<div className={styles.section}>
-				<span className={styles.sectionLabel}>Tool</span>
-				<span className={styles.toolName}>{toolName}</span>
-			</div>
-			<div className={styles.section}>
-				<span className={styles.sectionLabel}>Input</span>
-				<pre className={styles.json}>{JSON.stringify(input, null, 2)}</pre>
-			</div>
-			{done && result !== undefined && (
-				<div className={styles.section}>
-					<span className={styles.sectionLabel}>Output</span>
-					<pre className={styles.json}>
-						{typeof result === 'string' ? result : JSON.stringify(result, null, 2)}
-					</pre>
-				</div>
-			)}
-		</div>
-	);
-}
-
 /** Collapsible tool-call row — chevron + label, in/out detail in the body. */
 export default function ToolCallStep({
 	toolCall,
 }: ToolCallStepProps): JSX.Element {
 	const [expanded, setExpanded] = useState(false);
-	const { done } = toolCall;
-	const label = getToolDisplayLabel(toolCall);
+	const { toolName, input, result, done, displayText } = toolCall;
+
+	// Prefer the server-supplied `displayText` from `ToolCallEventDTO` —
+	// it's the human-friendly title the backend wants surfaced. Fall back
+	// to a derived label ("signoz_get_dashboard" → "Get Dashboard") when
+	// the field is empty / null / missing.
+	const label =
+		displayText && displayText.trim().length > 0
+			? displayText
+			: toolName
+					.replace(/^[a-z]+_/, '') // strip prefix like "signoz_"
+					.replace(/_/g, ' ')
+					.replace(/\b\w/g, (c) => c.toUpperCase());
 
 	const toggle = (): void => setExpanded((v) => !v);
 
@@ -78,7 +44,26 @@ export default function ToolCallStep({
 				<span className={styles.label}>{label}</span>
 			</div>
 
-			{expanded && <ToolCallContent toolCall={toolCall} />}
+			{expanded && (
+				<div className={styles.body}>
+					<div className={styles.section}>
+						<span className={styles.sectionLabel}>Tool</span>
+						<span className={styles.toolName}>{toolName}</span>
+					</div>
+					<div className={styles.section}>
+						<span className={styles.sectionLabel}>Input</span>
+						<pre className={styles.json}>{JSON.stringify(input, null, 2)}</pre>
+					</div>
+					{done && result !== undefined && (
+						<div className={styles.section}>
+							<span className={styles.sectionLabel}>Output</span>
+							<pre className={styles.json}>
+								{typeof result === 'string' ? result : JSON.stringify(result, null, 2)}
+							</pre>
+						</div>
+					)}
+				</div>
+			)}
 		</div>
 	);
 }

frontend/src/container/PlannedDowntime/PlannedDowntime.tsx

@@ -9,7 +9,7 @@ import {
 	useListDowntimeSchedules,
 } from 'api/generated/services/downtimeschedules';
 import { useListRules } from 'api/generated/services/rules';
-import type { RuletypesPlannedMaintenanceDTO } from 'api/generated/services/sigNoz.schemas';
+import type { AlertmanagertypesPlannedMaintenanceDTO } from 'api/generated/services/sigNoz.schemas';
 import dayjs from 'dayjs';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { useNotifications } from 'hooks/useNotifications';
@@ -48,7 +48,9 @@ export function PlannedDowntime(): JSX.Element {
 	const urlQuery = useUrlQuery();
 
 	const [initialValues, setInitialValues] =
-		useState<Partial<RuletypesPlannedMaintenanceDTO>>(defaultInitialValues);
+		useState<Partial<AlertmanagertypesPlannedMaintenanceDTO>>(
+			defaultInitialValues,
+		);
 
 	const downtimeSchedules = useListDowntimeSchedules();
 	const alertOptions = React.useMemo(

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -20,9 +20,9 @@ import {
 	updateDowntimeScheduleByID,
 } from 'api/generated/services/downtimeschedules';
 import type {
-	RuletypesPlannedMaintenanceDTO,
-	RuletypesPostablePlannedMaintenanceDTO,
-	RuletypesRecurrenceDTO,
+	AlertmanagertypesPlannedMaintenanceDTO,
+	AlertmanagertypesPostablePlannedMaintenanceDTO,
+	AlertmanagertypesRecurrenceDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
 import { AxiosError } from 'axios';
@@ -74,16 +74,16 @@ interface PlannedDowntimeFormData {
 	name: string;
 	startTime: dayjs.Dayjs | null;
 	endTime: dayjs.Dayjs | null;
-	recurrence?: RuletypesRecurrenceDTO;
+	recurrence?: AlertmanagertypesRecurrenceDTO;
 	alertRules: DefaultOptionType[];
-	recurrenceSelect?: RuletypesRecurrenceDTO;
+	recurrenceSelect?: AlertmanagertypesRecurrenceDTO;
 	timezone?: string;
 }
 
 const customFormat = DATE_TIME_FORMATS.ORDINAL_DATETIME;
 
 interface PlannedDowntimeFormProps {
-	initialValues: Partial<RuletypesPlannedMaintenanceDTO>;
+	initialValues: Partial<AlertmanagertypesPlannedMaintenanceDTO>;
 	alertOptions: DefaultOptionType[];
 	isError: boolean;
 	isLoading: boolean;
@@ -139,7 +139,7 @@ export function PlannedDowntimeForm(
 
 	const saveHandler = useCallback(
 		async (values: PlannedDowntimeFormData) => {
-			const data: RuletypesPostablePlannedMaintenanceDTO = {
+			const data: AlertmanagertypesPostablePlannedMaintenanceDTO = {
 				alertIds: values.alertRules
 					.map((alert) => alert.value)
 					.filter((alert) => alert !== undefined) as string[],
@@ -276,7 +276,7 @@ export function PlannedDowntimeForm(
 					? recurrenceOptions.doesNotRepeat.value
 					: schedule?.recurrence?.repeatType,
 				duration: getDurationInfo(schedule?.recurrence?.duration)?.value ?? '',
-			} as RuletypesRecurrenceDTO,
+			} as AlertmanagertypesRecurrenceDTO,
 			timezone: schedule?.timezone as string,
 		};
 	}, [initialValues, alertOptions]);

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -7,8 +7,8 @@ import type { DefaultOptionType } from 'antd/es/select';
 import type {
 	ListDowntimeSchedules200,
 	RenderErrorResponseDTO,
-	RuletypesPlannedMaintenanceDTO,
-	RuletypesScheduleDTO,
+	AlertmanagertypesPlannedMaintenanceDTO,
+	AlertmanagertypesScheduleDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type { ErrorType } from 'api/generatedAPIInstance';
 import cx from 'classnames';
@@ -133,7 +133,7 @@ export function CollapseListContent({
 	created_at?: string;
 	created_by_name?: string;
 	created_by_email?: string;
-	schedule?: RuletypesScheduleDTO;
+	schedule?: AlertmanagertypesScheduleDTO;
 	updated_at?: string;
 	updated_by_name?: string;
 	alertOptions?: DefaultOptionType[];
@@ -214,7 +214,7 @@ export function CollapseListContent({
 export function CustomCollapseList(
 	props: DowntimeSchedulesTableData & {
 		setInitialValues: React.Dispatch<
-			React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
+			React.SetStateAction<Partial<AlertmanagertypesPlannedMaintenanceDTO>>
 		>;
 		setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
 		handleDeleteDowntime: (id: string, name: string) => void;
@@ -281,9 +281,10 @@ export function CustomCollapseList(
 	);
 }
 
-export type DowntimeSchedulesTableData = RuletypesPlannedMaintenanceDTO & {
-	alertOptions: DefaultOptionType[];
-};
+export type DowntimeSchedulesTableData =
+	AlertmanagertypesPlannedMaintenanceDTO & {
+		alertOptions: DefaultOptionType[];
+	};
 
 export function PlannedDowntimeList({
 	downtimeSchedules,
@@ -300,7 +301,7 @@ export function PlannedDowntimeList({
 	>;
 	alertOptions: DefaultOptionType[];
 	setInitialValues: React.Dispatch<
-		React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
+		React.SetStateAction<Partial<AlertmanagertypesPlannedMaintenanceDTO>>
 	>;
 	setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
 	handleDeleteDowntime: (id: string, name: string) => void;

frontend/src/container/PlannedDowntime/PlannedDowntimeutils.ts

@@ -5,8 +5,8 @@ import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import type {
 	DeleteDowntimeScheduleByIDPathParameters,
 	RenderErrorResponseDTO,
-	RuletypesPlannedMaintenanceDTO,
-	RuletypesRecurrenceDTO,
+	AlertmanagertypesPlannedMaintenanceDTO,
+	AlertmanagertypesRecurrenceDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type { ErrorType } from 'api/generatedAPIInstance';
 import { AxiosError } from 'axios';
@@ -66,7 +66,7 @@ export const getAlertOptionsFromIds = (
 	);
 
 export const recurrenceInfo = (
-	recurrence?: RuletypesRecurrenceDTO | null,
+	recurrence?: AlertmanagertypesRecurrenceDTO | null,
 	timezone?: string,
 ): string => {
 	if (!recurrence) {
@@ -87,19 +87,20 @@ export const recurrenceInfo = (
 	return `Repeats - ${repeatType} ${weeklyRepeatString} from ${formattedStartTime} ${formattedEndTime} ${durationString}`;
 };
 
-export const defaultInitialValues: Partial<RuletypesPlannedMaintenanceDTO> = {
-	name: '',
-	description: '',
-	schedule: {
-		timezone: '',
-		endTime: undefined,
-		recurrence: undefined,
-		startTime: undefined,
-	},
-	alertIds: [],
-	createdAt: undefined,
-	createdBy: undefined,
-};
+export const defaultInitialValues: Partial<AlertmanagertypesPlannedMaintenanceDTO> =
+	{
+		name: '',
+		description: '',
+		schedule: {
+			timezone: '',
+			endTime: undefined,
+			recurrence: undefined,
+			startTime: undefined,
+		},
+		alertIds: [],
+		createdAt: undefined,
+		createdBy: undefined,
+	};
 
 type DeleteDowntimeScheduleProps = {
 	deleteDowntimeScheduleAsync: UseMutateAsyncFunction<
@@ -215,5 +216,5 @@ export const recurrenceOptionWithSubmenu: Option[] = [
 ];
 
 export const isScheduleRecurring = (
-	schedule?: RuletypesPlannedMaintenanceDTO['schedule'] | null,
+	schedule?: AlertmanagertypesPlannedMaintenanceDTO['schedule'] | null,
 ): boolean => (schedule ? !isEmpty(schedule?.recurrence) : false);

frontend/src/container/PlannedDowntime/__test__/testUtils.ts

@@ -1,15 +1,15 @@
 import type {
-	RuletypesPlannedMaintenanceDTO,
-	RuletypesScheduleDTO,
+	AlertmanagertypesScheduleDTO,
+	AlertmanagertypesPlannedMaintenanceDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import {
-	RuletypesMaintenanceKindDTO,
-	RuletypesMaintenanceStatusDTO,
+	AlertmanagertypesMaintenanceKindDTO,
+	AlertmanagertypesMaintenanceStatusDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
 export const buildSchedule = (
-	schedule: Partial<RuletypesScheduleDTO>,
-): RuletypesScheduleDTO => ({
+	schedule: Partial<AlertmanagertypesScheduleDTO>,
+): AlertmanagertypesScheduleDTO => ({
 	timezone: schedule?.timezone ?? '',
 	startTime: schedule?.startTime,
 	endTime: schedule?.endTime,
@@ -17,8 +17,8 @@ export const buildSchedule = (
 });
 
 export const createMockDowntime = (
-	overrides: Partial<RuletypesPlannedMaintenanceDTO>,
-): RuletypesPlannedMaintenanceDTO => ({
+	overrides: Partial<AlertmanagertypesPlannedMaintenanceDTO>,
+): AlertmanagertypesPlannedMaintenanceDTO => ({
 	id: overrides.id ?? '0',
 	name: overrides.name ?? '',
 	description: overrides.description ?? '',
@@ -32,6 +32,6 @@ export const createMockDowntime = (
 	createdBy: overrides.createdBy ?? '',
 	updatedAt: overrides.updatedAt,
 	updatedBy: overrides.updatedBy ?? '',
-	kind: overrides.kind ?? RuletypesMaintenanceKindDTO.recurring,
-	status: overrides.status ?? RuletypesMaintenanceStatusDTO.active,
+	kind: overrides.kind ?? AlertmanagertypesMaintenanceKindDTO.recurring,
+	status: overrides.status ?? AlertmanagertypesMaintenanceStatusDTO.active,
 });

pkg/alertmanager/alertmanagerserver/maintenance_muter.go

@@ -0,0 +1,96 @@
+package alertmanagerserver
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/prometheus/common/model"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+)
+
+// MaintenanceMuter implements types.Muter for maintenance windows.
+// It suppresses alerts whose ruleId label matches an active maintenance schedule.
+// Results are cached for cacheTTL to avoid a DB query on every per-alert check.
+type MaintenanceMuter struct {
+	maintenanceStore alertmanagertypes.MaintenanceStore
+	orgID            string
+	logger           *slog.Logger
+
+	mu          sync.RWMutex
+	cached      []*alertmanagertypes.PlannedMaintenance
+	cacheExpiry time.Time
+}
+
+const maintenanceCacheTTL = 30 * time.Second
+
+func NewMaintenanceMuter(store alertmanagertypes.MaintenanceStore, orgID string, logger *slog.Logger) *MaintenanceMuter {
+	return &MaintenanceMuter{
+		maintenanceStore: store,
+		orgID:            orgID,
+		logger:           logger,
+	}
+}
+
+func (m *MaintenanceMuter) Mutes(ctx context.Context, lset model.LabelSet) bool {
+	ruleID := string(lset[ruletypes.AlertRuleIDLabel])
+	if ruleID == "" {
+		return false
+	}
+	now := time.Now()
+	for _, mw := range m.getMaintenances(ctx) {
+		if mw.ShouldSkip(ruleID, now) {
+			return true
+		}
+	}
+	return false
+}
+
+// MutedBy returns the IDs of all active maintenance windows currently
+// suppressing the alert identified by lset. It is used to populate the
+// `mutedBy` field on the v2 API alert response so that maintenance-suppressed
+// alerts surface as `state=suppressed` in GetAlerts responses.
+func (m *MaintenanceMuter) MutedBy(ctx context.Context, lset model.LabelSet) []string {
+	ruleID := string(lset[ruletypes.AlertRuleIDLabel])
+	if ruleID == "" {
+		return nil
+	}
+	var ids []string
+	now := time.Now()
+	for _, mw := range m.getMaintenances(ctx) {
+		if mw.ShouldSkip(ruleID, now) {
+			ids = append(ids, mw.ID.String())
+		}
+	}
+	return ids
+}
+
+func (m *MaintenanceMuter) getMaintenances(ctx context.Context) []*alertmanagertypes.PlannedMaintenance {
+	m.mu.RLock()
+	if time.Now().Before(m.cacheExpiry) {
+		cached := m.cached
+		m.mu.RUnlock()
+		return cached
+	}
+	m.mu.RUnlock()
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Double-check after acquiring write lock.
+	if time.Now().Before(m.cacheExpiry) {
+		return m.cached
+	}
+
+	mws, err := m.maintenanceStore.ListPlannedMaintenance(ctx, m.orgID)
+	if err != nil {
+		m.logger.ErrorContext(ctx, "failed to list planned maintenance windows; alerts will not be suppressed", slog.String("org_id", m.orgID))
+		return m.cached // return stale (potentially empty) cache on error
+	}
+	m.cached = mws
+	m.cacheExpiry = time.Now().Add(maintenanceCacheTTL)
+	return m.cached
+}

pkg/alertmanager/alertmanagerserver/maintenance_muter_test.go

@@ -0,0 +1,234 @@
+package alertmanagerserver
+
+import (
+	"context"
+	"log/slog"
+	"sort"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes/alertmanagertypestest"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+func newMuter(store alertmanagertypes.MaintenanceStore) *MaintenanceMuter {
+	return NewMaintenanceMuter(store, "org-1", slog.New(slog.DiscardHandler))
+}
+
+// activeFixed builds a fixed-time maintenance window that brackets now.
+// ruleIDs scope the window; an empty slice matches every rule.
+func activeFixed(ruleIDs ...string) *alertmanagertypes.PlannedMaintenance {
+	now := time.Now().UTC()
+	return &alertmanagertypes.PlannedMaintenance{
+		ID: valuer.GenerateUUID(),
+		Schedule: &alertmanagertypes.Schedule{
+			Timezone:  "UTC",
+			StartTime: now.Add(-time.Hour),
+			EndTime:   now.Add(time.Hour),
+		},
+		RuleIDs: ruleIDs,
+	}
+}
+
+// futureFixed builds a fixed-time maintenance window that starts in the future.
+func futureFixed(ruleIDs ...string) *alertmanagertypes.PlannedMaintenance {
+	now := time.Now().UTC()
+	return &alertmanagertypes.PlannedMaintenance{
+		ID: valuer.GenerateUUID(),
+		Schedule: &alertmanagertypes.Schedule{
+			Timezone:  "UTC",
+			StartTime: now.Add(time.Hour),
+			EndTime:   now.Add(2 * time.Hour),
+		},
+		RuleIDs: ruleIDs,
+	}
+}
+
+func labelsFor(ruleID string) model.LabelSet {
+	return model.LabelSet{ruletypes.AlertRuleIDLabel: model.LabelValue(ruleID)}
+}
+
+func TestMutes_EmptyRuleIDLabel(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	muter := newMuter(store)
+	assert.False(t, muter.Mutes(context.Background(), model.LabelSet{}))
+	// Short-circuit: no store lookup needed when the label is missing.
+	store.AssertNotCalled(t, "ListPlannedMaintenance")
+}
+
+func TestMutes_NoMaintenanceWindows(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return([]*alertmanagertypes.PlannedMaintenance(nil), nil)
+	muter := newMuter(store)
+	assert.False(t, muter.Mutes(context.Background(), labelsFor("rule-1")))
+}
+
+func TestMutes_MaintenanceWindowWithRules(t *testing.T) {
+	mw := activeFixed("rule-1", "rule-2")
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return([]*alertmanagertypes.PlannedMaintenance{mw}, nil)
+	muter := newMuter(store)
+	assert.True(t, muter.Mutes(context.Background(), labelsFor("rule-1")))
+	assert.True(t, muter.Mutes(context.Background(), labelsFor("rule-2")))
+	assert.False(t, muter.Mutes(context.Background(), labelsFor("rule-3")))
+}
+
+func TestMutes_EmptyRuleIDsMatchesAllRules(t *testing.T) {
+	// A maintenance with no RuleIDs is treated as scoping every rule.
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return([]*alertmanagertypes.PlannedMaintenance{activeFixed()}, nil)
+	muter := newMuter(store)
+	assert.True(t, muter.Mutes(context.Background(), labelsFor("any-rule")))
+}
+
+func TestMutes_FutureWindowDoesNotMute(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return([]*alertmanagertypes.PlannedMaintenance{futureFixed("rule-1")}, nil)
+	muter := newMuter(store)
+	assert.False(t, muter.Mutes(context.Background(), labelsFor("rule-1")))
+}
+
+func TestMutes_AnyOfMultipleWindowsMatches(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{futureFixed("rule-1"), activeFixed("rule-1")}, nil,
+	)
+	muter := newMuter(store)
+	assert.True(t, muter.Mutes(context.Background(), labelsFor("rule-1")))
+}
+
+func TestMutedBy_EmptyRuleIDLabel(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	muter := newMuter(store)
+	assert.Nil(t, muter.MutedBy(context.Background(), model.LabelSet{}))
+	store.AssertNotCalled(t, "ListPlannedMaintenance")
+}
+
+func TestMutedBy_NoMatches(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{activeFixed("rule-1"), futureFixed("rule-1")}, nil,
+	)
+	muter := newMuter(store)
+	assert.Nil(t, muter.MutedBy(context.Background(), labelsFor("rule-other")))
+}
+
+func TestMutedBy_ReturnsIDsOfAllActiveMatchingWindows(t *testing.T) {
+	mw1 := activeFixed("rule-1")
+	mw2 := activeFixed() // matches all rules
+	mw3 := futureFixed("rule-1")
+	mw4 := activeFixed("rule-other")
+
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{mw1, mw2, mw3, mw4}, nil,
+	)
+	muter := newMuter(store)
+	ids := muter.MutedBy(context.Background(), labelsFor("rule-1"))
+
+	want := []string{mw1.ID.String(), mw2.ID.String()}
+	sort.Strings(want)
+	sort.Strings(ids)
+	assert.Equal(t, want, ids)
+}
+
+func TestCache_RepeatedCallsHitStoreOnce(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{activeFixed("rule-1")}, nil,
+	)
+	muter := newMuter(store)
+	ctx := context.Background()
+	for i := 0; i < 5; i++ {
+		require.True(t, muter.Mutes(ctx, labelsFor("rule-1")))
+	}
+	store.AssertNumberOfCalls(t, "ListPlannedMaintenance", 1)
+}
+
+func TestCache_StoreErrorReturnsStaleCache(t *testing.T) {
+	mw := activeFixed("rule-1")
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{mw}, nil,
+	).Once()
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		([]*alertmanagertypes.PlannedMaintenance)(nil),
+		errors.New(errors.TypeInternal, errors.MustNewCode("internal_error"), "boom"),
+	).Once()
+
+	ctx := context.Background()
+	muter := newMuter(store)
+
+	// First call populates the cache from a working store.
+	require.True(t, muter.Mutes(ctx, labelsFor("rule-1")))
+
+	// Force cache to be considered expired so the next call re-fetches.
+	muter.mu.Lock()
+	muter.cacheExpiry = time.Time{}
+	muter.mu.Unlock()
+
+	// Store now errors. The muter should fall back to the previously cached value
+	// (i.e. still mute rule-1) rather than returning false.
+	assert.True(t, muter.Mutes(ctx, labelsFor("rule-1")),
+		"on store error, muter should keep using the last known cache to avoid losing suppression")
+	store.AssertNumberOfCalls(t, "ListPlannedMaintenance", 2)
+}
+
+func TestCache_ExpiredCacheRefetchesUpdatedData(t *testing.T) {
+	mw := activeFixed("rule-1")
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{mw}, nil,
+	).Once()
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		([]*alertmanagertypes.PlannedMaintenance)(nil), nil,
+	).Once()
+
+	ctx := context.Background()
+	muter := newMuter(store)
+
+	require.True(t, muter.Mutes(ctx, labelsFor("rule-1")))
+
+	// Expire the cache and let the store return an empty list.
+	muter.mu.Lock()
+	muter.cacheExpiry = time.Time{}
+	muter.mu.Unlock()
+
+	assert.False(t, muter.Mutes(ctx, labelsFor("rule-1")))
+	store.AssertNumberOfCalls(t, "ListPlannedMaintenance", 2)
+}
+
+func TestMutes_IsConcurrencySafe(t *testing.T) {
+	store := alertmanagertypestest.NewMockMaintenanceStore(t)
+	store.On("ListPlannedMaintenance", mock.Anything, "org-1").Return(
+		[]*alertmanagertypes.PlannedMaintenance{activeFixed("rule-1")}, nil,
+	)
+	muter := newMuter(store)
+	ctx := context.Background()
+
+	const goroutines = 32
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+	for i := 0; i < goroutines; i++ {
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 50; j++ {
+				_ = muter.Mutes(ctx, labelsFor("rule-1"))
+				_ = muter.MutedBy(ctx, labelsFor("rule-1"))
+			}
+		}()
+	}
+	wg.Wait()
+
+	// Even under contention the cache must collapse the load to a single fetch.
+	store.AssertNumberOfCalls(t, "ListPlannedMaintenance", 1)
+}

pkg/alertmanager/alertmanagerserver/pipeline_builder.go

@@ -0,0 +1,109 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// Copyright 2015 Prometheus Team
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package alertmanagerserver
+
+import (
+	"time"
+
+	"github.com/prometheus/alertmanager/featurecontrol"
+	"github.com/prometheus/alertmanager/inhibit"
+	"github.com/prometheus/alertmanager/nflog/nflogpb"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/silence"
+	"github.com/prometheus/alertmanager/timeinterval"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// pipelineBuilder is a local copy of notify.PipelineBuilder that injects
+// the maintenance mute stage immediately before the receiver stage.
+//
+// We maintain our own copy so we can control exactly where in the pipeline
+// the maintenance stage runs (between the silence stage and the receiver),
+// which is not possible by wrapping the output of the upstream builder.
+//
+// Upstream pipeline order:
+// GossipSettle → Inhibit → TimeActive → TimeMute → Silence → [mms] → Receiver.
+type pipelineBuilder struct {
+	metrics *notify.Metrics
+	ff      featurecontrol.Flagger
+}
+
+func newPipelineBuilder(
+	r prometheus.Registerer,
+	ff featurecontrol.Flagger,
+) *pipelineBuilder {
+	return &pipelineBuilder{
+		metrics: notify.NewMetrics(r, ff),
+		ff:      ff,
+	}
+}
+
+// New returns a map of receivers to Stages, mirroring notify.PipelineBuilder.New
+// but inserting a maintenanceMuteStage between the silence stage and the receiver.
+func (pb *pipelineBuilder) New(
+	receivers map[string][]notify.Integration,
+	wait func() time.Duration,
+	inhibitor *inhibit.Inhibitor,
+	silencer *silence.Silencer,
+	intervener *timeinterval.Intervener,
+	marker types.GroupMarker,
+	muter *MaintenanceMuter,
+	notificationLog notify.NotificationLog,
+	peer notify.Peer,
+) notify.RoutingStage {
+	rs := make(notify.RoutingStage, len(receivers))
+
+	ms := notify.NewGossipSettleStage(peer)
+	is := notify.NewMuteStage(inhibitor, pb.metrics)
+	tas := notify.NewTimeActiveStage(intervener, marker, pb.metrics)
+	tms := notify.NewTimeMuteStage(intervener, marker, pb.metrics)
+	ss := notify.NewMuteStage(silencer, pb.metrics)
+	mms := notify.NewMuteStage(muter, pb.metrics)
+
+	for name := range receivers {
+		stages := notify.MultiStage{ms, is, tas, tms, ss, mms}
+		stages = append(stages, createReceiverStage(name, receivers[name], wait, notificationLog, pb.metrics))
+		rs[name] = stages
+	}
+
+	pb.metrics.InitializeFor(receivers)
+	return rs
+}
+
+// createReceiverStage is a copy of notify.createReceiverStage (unexported upstream).
+func createReceiverStage(
+	name string,
+	integrations []notify.Integration,
+	wait func() time.Duration,
+	notificationLog notify.NotificationLog,
+	metrics *notify.Metrics,
+) notify.Stage {
+	var fs notify.FanoutStage
+	for i := range integrations {
+		recv := &nflogpb.Receiver{
+			GroupName:   name,
+			Integration: integrations[i].Name(),
+			Idx:         uint32(integrations[i].Index()),
+		}
+		var s notify.MultiStage
+		s = append(s, notify.NewWaitStage(wait))
+		s = append(s, notify.NewDedupStage(&integrations[i], notificationLog, recv))
+		s = append(s, notify.NewRetryStage(integrations[i], name, metrics))
+		s = append(s, notify.NewSetNotifiesStage(notificationLog, recv))
+		fs = append(fs, s)
+	}
+	return fs
+}

pkg/alertmanager/alertmanagerserver/server.go

@@ -28,12 +28,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 )
 
-var (
-	// This is not a real file and will never be used. We need this placeholder to ensure maintenance runs on shutdown. See
-	// https://github.com/prometheus/server/blob/3ee2cd0f1271e277295c02b6160507b4d193dde2/silence/silence.go#L435-L438
-	// and https://github.com/prometheus/server/blob/3b06b97af4d146e141af92885a185891eb79a5b0/nflog/nflog.go#L362.
-	snapfnoop string = "snapfnoop"
-)
+// This is not a real snapshot file and will never be used. We need this placeholder to ensure maintenance runs on shutdown.
+// See https://github.com/prometheus/alertmanager/blob/3ee2cd0f1271e277295c02b6160507b4d193dde2/silence/silence.go#L435-L438
+// and https://github.com/prometheus/alertmanager/blob/3b06b97af4d146e141af92885a185891eb79a5b0/nflog/nflog.go#L362.
+var snapfnoop string = "snapfnoop"
 
 type Server struct {
 	// logger is the logger for the alertmanager
@@ -63,15 +61,25 @@ type Server struct {
 	silencer            *silence.Silencer
 	silences            *silence.Silences
 	timeIntervals       map[string][]timeinterval.TimeInterval
-	pipelineBuilder     *notify.PipelineBuilder
-	marker              *alertmanagertypes.MemMarker
+	pipelineBuilder     *pipelineBuilder
+	muter               *MaintenanceMuter
+	marker              *types.MemMarker
 	tmpl                *template.Template
 	wg                  sync.WaitGroup
 	stopc               chan struct{}
 	notificationManager nfmanager.NotificationManager
 }
 
-func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registerer, srvConfig Config, orgID string, stateStore alertmanagertypes.StateStore, nfManager nfmanager.NotificationManager) (*Server, error) {
+func New(
+	ctx context.Context,
+	logger *slog.Logger,
+	registry prometheus.Registerer,
+	srvConfig Config,
+	orgID string,
+	stateStore alertmanagertypes.StateStore,
+	nfManager nfmanager.NotificationManager,
+	maintenanceStore alertmanagertypes.MaintenanceStore,
+) (*Server, error) {
 	server := &Server{
 		logger:              logger.With(slog.String("pkg", "go.signoz.io/pkg/alertmanager/alertmanagerserver")),
 		registry:            registry,
@@ -84,7 +92,7 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 	signozRegisterer := prometheus.WrapRegistererWithPrefix("signoz_", registry)
 	signozRegisterer = prometheus.WrapRegistererWith(prometheus.Labels{"org_id": server.orgID}, signozRegisterer)
 	// initialize marker
-	server.marker = alertmanagertypes.NewMarker(signozRegisterer)
+	server.marker = types.NewMarker(signozRegisterer)
 
 	// get silences for initial state
 	state, err := server.stateStore.Get(ctx, server.orgID)
@@ -160,7 +168,6 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 
 			return c, server.stateStore.Set(ctx, storableSilences)
 		})
-
 	}()
 
 	// Start maintenance for notification logs
@@ -196,17 +203,25 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 		return nil, err
 	}
 
-	server.pipelineBuilder = notify.NewPipelineBuilder(signozRegisterer, featurecontrol.NoopFlags{})
+	server.muter = NewMaintenanceMuter(maintenanceStore, orgID, server.logger)
+	server.pipelineBuilder = newPipelineBuilder(signozRegisterer, featurecontrol.NoopFlags{})
 	server.dispatcherMetrics = NewDispatcherMetrics(false, signozRegisterer)
 
 	return server, nil
 }
 
 func (server *Server) GetAlerts(ctx context.Context, params alertmanagertypes.GettableAlertsParams) (alertmanagertypes.GettableAlerts, error) {
-	return alertmanagertypes.NewGettableAlertsFromAlertProvider(server.alerts, server.alertmanagerConfig, server.marker.Status, func(labels model.LabelSet) {
-		server.inhibitor.Mutes(ctx, labels)
-		server.silencer.Mutes(ctx, labels)
-	}, params)
+	return alertmanagertypes.NewGettableAlertsFromAlertProvider(
+		server.alerts, server.alertmanagerConfig, server.marker.Status,
+		func(labels model.LabelSet) {
+			server.inhibitor.Mutes(ctx, labels)
+			server.silencer.Mutes(ctx, labels)
+		},
+		func(labels model.LabelSet) []string {
+			return server.muter.MutedBy(ctx, labels)
+		},
+		params,
+	)
 }
 
 func (server *Server) PutAlerts(ctx context.Context, postableAlerts alertmanagertypes.PostableAlerts) error {
@@ -290,6 +305,7 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 		server.silencer,
 		intervener,
 		server.marker,
+		server.muter,
 		server.nflog,
 		pipelinePeer,
 	)

pkg/alertmanager/alertmanagerserver/server_e2e_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/model"
 
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -86,11 +87,25 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 	err = notificationManager.SetNotificationConfig(orgID, "high-cpu-usage", &notifConfig)
 	require.NoError(t, err)
 
+	mwID := valuer.GenerateUUID()
+	maintenanceStore := alertmanagertypestest.NewMockMaintenanceStore(t)
+	maintenanceStore.On("ListPlannedMaintenance", mock.Anything, orgID).Return(
+		[]*alertmanagertypes.PlannedMaintenance{{
+			ID: mwID,
+			Schedule: &alertmanagertypes.Schedule{
+				Timezone:  "UTC",
+				StartTime: time.Now().Add(-time.Hour),
+				EndTime:   time.Now().Add(time.Hour),
+			},
+			RuleIDs: []string{"high-cpu-usage"},
+		}}, nil,
+	)
+
 	srvCfg := NewConfig()
 	stateStore := alertmanagertypestest.NewStateStore()
 	registry := prometheus.NewRegistry()
 	logger := slog.New(slog.DiscardHandler)
-	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager)
+	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager, maintenanceStore)
 	require.NoError(t, err)
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
 	require.NoError(t, err)
@@ -151,6 +166,16 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 			StartsAt: strfmt.DateTime(now.Add(-3 * time.Minute)),
 			EndsAt:   strfmt.DateTime(time.Time{}), // Active alert
 		},
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId":    "other-rule",
+					"alertname": "OtherAlert",
+				},
+			},
+			StartsAt: strfmt.DateTime(now.Add(-time.Minute)),
+			EndsAt:   strfmt.DateTime(time.Time{}), // Active alert
+		},
 	}
 
 	err = server.PutAlerts(ctx, testAlerts)
@@ -166,10 +191,12 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 		require.NoError(t, err)
 		alerts, err := server.GetAlerts(context.Background(), params)
 		require.NoError(t, err)
-		require.Len(t, alerts, 3, "Expected 3 active alerts")
+		require.Len(t, alerts, 4, "Expected 4 active alerts")
 
 		for _, alert := range alerts {
-			require.Equal(t, "high-cpu-usage", alert.Labels["ruleId"])
+			if alert.Labels["ruleId"] != "high-cpu-usage" {
+				continue
+			}
 			require.NotEmpty(t, alert.Labels["severity"])
 			require.Contains(t, []string{"critical", "warning"}, alert.Labels["severity"])
 			require.Equal(t, "prod-cluster", alert.Labels["cluster"])
@@ -221,4 +248,20 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 		require.Equal(t, "{__receiver__=\"webhook\"}:{cluster=\"prod-cluster\", instance=\"server-02\", ruleId=\"high-cpu-usage\"}", alertGroups[1].GroupKey)
 		require.Equal(t, "{__receiver__=\"webhook\"}:{cluster=\"prod-cluster\", instance=\"server-03\", ruleId=\"high-cpu-usage\"}", alertGroups[2].GroupKey)
 	})
+
+	t.Run("verify_muting", func(t *testing.T) {
+		req, err := http.NewRequest(http.MethodGet, "/alerts", nil)
+		require.NoError(t, err)
+		params, err := alertmanagertypes.NewGettableAlertsParams(req)
+		require.NoError(t, err)
+		alerts, err := server.GetAlerts(ctx, params)
+		require.NoError(t, err)
+		for _, alert := range alerts {
+			if alert.Labels["ruleId"] == "high-cpu-usage" {
+				require.Equal(t, []string{mwID.String()}, alert.Status.MutedBy)
+			} else {
+				require.Empty(t, alert.Status.MutedBy)
+			}
+		}
+	})
 }

pkg/alertmanager/alertmanagerserver/server_test.go

@@ -10,7 +10,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
+	"github.com/SigNoz/signoz/pkg/factory/factorytest"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes/alertmanagertypestest"
 	"github.com/go-openapi/strfmt"
@@ -23,9 +28,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func newTestMaintenanceStore() alertmanagertypes.MaintenanceStore {
+	ss := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)
+	return sqlalertmanagerstore.NewMaintenanceStore(ss, factorytest.NewSettings())
+}
+
 func TestServerSetConfigAndStop(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, newTestMaintenanceStore())
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -37,7 +47,7 @@ func TestServerSetConfigAndStop(t *testing.T) {
 
 func TestServerTestReceiverTypeWebhook(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, newTestMaintenanceStore())
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -85,7 +95,7 @@ func TestServerPutAlerts(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, newTestMaintenanceStore())
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -133,7 +143,7 @@ func TestServerTestAlert(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, newTestMaintenanceStore())
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -238,7 +248,7 @@ func TestServerTestAlertContinuesOnFailure(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, newTestMaintenanceStore())
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")

pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/maintenance.go

@@ -1,4 +1,4 @@
-package sqlrulestore
+package sqlalertmanagerstore
 
 import (
 	"context"
@@ -9,8 +9,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -19,15 +19,15 @@ type maintenance struct {
 	logger   *slog.Logger
 }
 
-func NewMaintenanceStore(store sqlstore.SQLStore, providerSettings factory.ProviderSettings) ruletypes.MaintenanceStore {
+func NewMaintenanceStore(store sqlstore.SQLStore, providerSettings factory.ProviderSettings) alertmanagertypes.MaintenanceStore {
 	return &maintenance{
 		sqlstore: store,
 		logger:   providerSettings.Logger,
 	}
 }
 
-func (r *maintenance) ListPlannedMaintenance(ctx context.Context, orgID string) ([]*ruletypes.PlannedMaintenance, error) {
-	gettableMaintenancesRules := make([]*ruletypes.PlannedMaintenanceWithRules, 0)
+func (r *maintenance) ListPlannedMaintenance(ctx context.Context, orgID string) ([]*alertmanagertypes.PlannedMaintenance, error) {
+	gettableMaintenancesRules := make([]*alertmanagertypes.PlannedMaintenanceWithRules, 0)
 	err := r.sqlstore.
 		BunDB().
 		NewSelect().
@@ -39,7 +39,7 @@ func (r *maintenance) ListPlannedMaintenance(ctx context.Context, orgID string)
 		return nil, err
 	}
 
-	gettablePlannedMaintenance := make([]*ruletypes.PlannedMaintenance, 0)
+	gettablePlannedMaintenance := make([]*alertmanagertypes.PlannedMaintenance, 0)
 	for _, gettableMaintenancesRule := range gettableMaintenancesRules {
 		m := gettableMaintenancesRule.ToPlannedMaintenance()
 		gettablePlannedMaintenance = append(gettablePlannedMaintenance, m)
@@ -51,8 +51,8 @@ func (r *maintenance) ListPlannedMaintenance(ctx context.Context, orgID string)
 	return gettablePlannedMaintenance, nil
 }
 
-func (r *maintenance) GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*ruletypes.PlannedMaintenance, error) {
-	storableMaintenanceRule := new(ruletypes.PlannedMaintenanceWithRules)
+func (r *maintenance) GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*alertmanagertypes.PlannedMaintenance, error) {
+	storableMaintenanceRule := new(alertmanagertypes.PlannedMaintenanceWithRules)
 	err := r.sqlstore.
 		BunDB().
 		NewSelect().
@@ -67,13 +67,13 @@ func (r *maintenance) GetPlannedMaintenanceByID(ctx context.Context, id valuer.U
 	return storableMaintenanceRule.ToPlannedMaintenance(), nil
 }
 
-func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance *ruletypes.PostablePlannedMaintenance) (*ruletypes.PlannedMaintenance, error) {
+func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance *alertmanagertypes.PostablePlannedMaintenance) (*alertmanagertypes.PlannedMaintenance, error) {
 	claims, err := authtypes.ClaimsFromContext(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	storablePlannedMaintenance := ruletypes.StorablePlannedMaintenance{
+	storablePlannedMaintenance := alertmanagertypes.StorablePlannedMaintenance{
 		Identifiable: types.Identifiable{
 			ID: valuer.GenerateUUID(),
 		},
@@ -91,14 +91,14 @@ func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance
 		OrgID:       claims.OrgID,
 	}
 
-	maintenanceRules := make([]*ruletypes.StorablePlannedMaintenanceRule, 0)
+	maintenanceRules := make([]*alertmanagertypes.StorablePlannedMaintenanceRule, 0)
 	for _, ruleIDStr := range maintenance.AlertIds {
 		ruleID, err := valuer.NewUUID(ruleIDStr)
 		if err != nil {
 			return nil, err
 		}
 
-		maintenanceRules = append(maintenanceRules, &ruletypes.StorablePlannedMaintenanceRule{
+		maintenanceRules = append(maintenanceRules, &alertmanagertypes.StorablePlannedMaintenanceRule{
 			Identifiable: types.Identifiable{
 				ID: valuer.GenerateUUID(),
 			},
@@ -135,7 +135,7 @@ func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance
 		return nil, err
 	}
 
-	return &ruletypes.PlannedMaintenance{
+	return &alertmanagertypes.PlannedMaintenance{
 		ID:          storablePlannedMaintenance.ID,
 		Name:        storablePlannedMaintenance.Name,
 		Description: storablePlannedMaintenance.Description,
@@ -152,7 +152,7 @@ func (r *maintenance) DeletePlannedMaintenance(ctx context.Context, id valuer.UU
 	_, err := r.sqlstore.
 		BunDB().
 		NewDelete().
-		Model(new(ruletypes.StorablePlannedMaintenance)).
+		Model(new(alertmanagertypes.StorablePlannedMaintenance)).
 		Where("id = ?", id.StringValue()).
 		Exec(ctx)
 	if err != nil {
@@ -162,7 +162,7 @@ func (r *maintenance) DeletePlannedMaintenance(ctx context.Context, id valuer.UU
 	return nil
 }
 
-func (r *maintenance) UpdatePlannedMaintenance(ctx context.Context, maintenance *ruletypes.PostablePlannedMaintenance, id valuer.UUID) error {
+func (r *maintenance) UpdatePlannedMaintenance(ctx context.Context, maintenance *alertmanagertypes.PostablePlannedMaintenance, id valuer.UUID) error {
 	claims, err := authtypes.ClaimsFromContext(ctx)
 	if err != nil {
 		return err
@@ -173,7 +173,7 @@ func (r *maintenance) UpdatePlannedMaintenance(ctx context.Context, maintenance
 		return err
 	}
 
-	storablePlannedMaintenance := ruletypes.StorablePlannedMaintenance{
+	storablePlannedMaintenance := alertmanagertypes.StorablePlannedMaintenance{
 		Identifiable: types.Identifiable{
 			ID: id,
 		},
@@ -191,14 +191,14 @@ func (r *maintenance) UpdatePlannedMaintenance(ctx context.Context, maintenance
 		OrgID:       claims.OrgID,
 	}
 
-	storablePlannedMaintenanceRules := make([]*ruletypes.StorablePlannedMaintenanceRule, 0)
+	storablePlannedMaintenanceRules := make([]*alertmanagertypes.StorablePlannedMaintenanceRule, 0)
 	for _, ruleIDStr := range maintenance.AlertIds {
 		ruleID, err := valuer.NewUUID(ruleIDStr)
 		if err != nil {
 			return err
 		}
 
-		storablePlannedMaintenanceRules = append(storablePlannedMaintenanceRules, &ruletypes.StorablePlannedMaintenanceRule{
+		storablePlannedMaintenanceRules = append(storablePlannedMaintenanceRules, &alertmanagertypes.StorablePlannedMaintenanceRule{
 			Identifiable: types.Identifiable{
 				ID: valuer.GenerateUUID(),
 			},
@@ -221,7 +221,7 @@ func (r *maintenance) UpdatePlannedMaintenance(ctx context.Context, maintenance
 		_, err = r.sqlstore.
 			BunDBCtx(ctx).
 			NewDelete().
-			Model(new(ruletypes.StorablePlannedMaintenanceRule)).
+			Model(new(alertmanagertypes.StorablePlannedMaintenanceRule)).
 			Where("planned_maintenance_id = ?", storablePlannedMaintenance.ID.StringValue()).
 			Exec(ctx)
 

pkg/alertmanager/alertmanagertest/alertmanager.go

@@ -6,6 +6,7 @@ package alertmanagertest
 
 import (
 	"context"
+	"net/http"
 
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -1845,3 +1846,628 @@ func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) RunAndReturn(run func(ctx
 	_c.Call.Return(run)
 	return _c
 }
+
+// NewMockHandler creates a new instance of MockHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockHandler(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockHandler {
+	mock := &MockHandler{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockHandler is an autogenerated mock type for the Handler type
+type MockHandler struct {
+	mock.Mock
+}
+
+type MockHandler_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockHandler) EXPECT() *MockHandler_Expecter {
+	return &MockHandler_Expecter{mock: &_m.Mock}
+}
+
+// CreateChannel provides a mock function for the type MockHandler
+func (_mock *MockHandler) CreateChannel(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_CreateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannel'
+type MockHandler_CreateChannel_Call struct {
+	*mock.Call
+}
+
+// CreateChannel is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) CreateChannel(responseWriter interface{}, request interface{}) *MockHandler_CreateChannel_Call {
+	return &MockHandler_CreateChannel_Call{Call: _e.mock.On("CreateChannel", responseWriter, request)}
+}
+
+func (_c *MockHandler_CreateChannel_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_CreateChannel_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_CreateChannel_Call) Return() *MockHandler_CreateChannel_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_CreateChannel_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_CreateChannel_Call {
+	_c.Run(run)
+	return _c
+}
+
+// CreateRoutePolicy provides a mock function for the type MockHandler
+func (_mock *MockHandler) CreateRoutePolicy(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_CreateRoutePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoutePolicy'
+type MockHandler_CreateRoutePolicy_Call struct {
+	*mock.Call
+}
+
+// CreateRoutePolicy is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) CreateRoutePolicy(responseWriter interface{}, request interface{}) *MockHandler_CreateRoutePolicy_Call {
+	return &MockHandler_CreateRoutePolicy_Call{Call: _e.mock.On("CreateRoutePolicy", responseWriter, request)}
+}
+
+func (_c *MockHandler_CreateRoutePolicy_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_CreateRoutePolicy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_CreateRoutePolicy_Call) Return() *MockHandler_CreateRoutePolicy_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_CreateRoutePolicy_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_CreateRoutePolicy_Call {
+	_c.Run(run)
+	return _c
+}
+
+// DeleteChannelByID provides a mock function for the type MockHandler
+func (_mock *MockHandler) DeleteChannelByID(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_DeleteChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChannelByID'
+type MockHandler_DeleteChannelByID_Call struct {
+	*mock.Call
+}
+
+// DeleteChannelByID is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) DeleteChannelByID(responseWriter interface{}, request interface{}) *MockHandler_DeleteChannelByID_Call {
+	return &MockHandler_DeleteChannelByID_Call{Call: _e.mock.On("DeleteChannelByID", responseWriter, request)}
+}
+
+func (_c *MockHandler_DeleteChannelByID_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_DeleteChannelByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_DeleteChannelByID_Call) Return() *MockHandler_DeleteChannelByID_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_DeleteChannelByID_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_DeleteChannelByID_Call {
+	_c.Run(run)
+	return _c
+}
+
+// DeleteRoutePolicyByID provides a mock function for the type MockHandler
+func (_mock *MockHandler) DeleteRoutePolicyByID(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_DeleteRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoutePolicyByID'
+type MockHandler_DeleteRoutePolicyByID_Call struct {
+	*mock.Call
+}
+
+// DeleteRoutePolicyByID is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) DeleteRoutePolicyByID(responseWriter interface{}, request interface{}) *MockHandler_DeleteRoutePolicyByID_Call {
+	return &MockHandler_DeleteRoutePolicyByID_Call{Call: _e.mock.On("DeleteRoutePolicyByID", responseWriter, request)}
+}
+
+func (_c *MockHandler_DeleteRoutePolicyByID_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_DeleteRoutePolicyByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_DeleteRoutePolicyByID_Call) Return() *MockHandler_DeleteRoutePolicyByID_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_DeleteRoutePolicyByID_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_DeleteRoutePolicyByID_Call {
+	_c.Run(run)
+	return _c
+}
+
+// GetAlerts provides a mock function for the type MockHandler
+func (_mock *MockHandler) GetAlerts(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_GetAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlerts'
+type MockHandler_GetAlerts_Call struct {
+	*mock.Call
+}
+
+// GetAlerts is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) GetAlerts(responseWriter interface{}, request interface{}) *MockHandler_GetAlerts_Call {
+	return &MockHandler_GetAlerts_Call{Call: _e.mock.On("GetAlerts", responseWriter, request)}
+}
+
+func (_c *MockHandler_GetAlerts_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetAlerts_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_GetAlerts_Call) Return() *MockHandler_GetAlerts_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_GetAlerts_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetAlerts_Call {
+	_c.Run(run)
+	return _c
+}
+
+// GetAllRoutePolicies provides a mock function for the type MockHandler
+func (_mock *MockHandler) GetAllRoutePolicies(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_GetAllRoutePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllRoutePolicies'
+type MockHandler_GetAllRoutePolicies_Call struct {
+	*mock.Call
+}
+
+// GetAllRoutePolicies is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) GetAllRoutePolicies(responseWriter interface{}, request interface{}) *MockHandler_GetAllRoutePolicies_Call {
+	return &MockHandler_GetAllRoutePolicies_Call{Call: _e.mock.On("GetAllRoutePolicies", responseWriter, request)}
+}
+
+func (_c *MockHandler_GetAllRoutePolicies_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetAllRoutePolicies_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_GetAllRoutePolicies_Call) Return() *MockHandler_GetAllRoutePolicies_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_GetAllRoutePolicies_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetAllRoutePolicies_Call {
+	_c.Run(run)
+	return _c
+}
+
+// GetChannelByID provides a mock function for the type MockHandler
+func (_mock *MockHandler) GetChannelByID(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_GetChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChannelByID'
+type MockHandler_GetChannelByID_Call struct {
+	*mock.Call
+}
+
+// GetChannelByID is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) GetChannelByID(responseWriter interface{}, request interface{}) *MockHandler_GetChannelByID_Call {
+	return &MockHandler_GetChannelByID_Call{Call: _e.mock.On("GetChannelByID", responseWriter, request)}
+}
+
+func (_c *MockHandler_GetChannelByID_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetChannelByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_GetChannelByID_Call) Return() *MockHandler_GetChannelByID_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_GetChannelByID_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetChannelByID_Call {
+	_c.Run(run)
+	return _c
+}
+
+// GetRoutePolicyByID provides a mock function for the type MockHandler
+func (_mock *MockHandler) GetRoutePolicyByID(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_GetRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutePolicyByID'
+type MockHandler_GetRoutePolicyByID_Call struct {
+	*mock.Call
+}
+
+// GetRoutePolicyByID is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) GetRoutePolicyByID(responseWriter interface{}, request interface{}) *MockHandler_GetRoutePolicyByID_Call {
+	return &MockHandler_GetRoutePolicyByID_Call{Call: _e.mock.On("GetRoutePolicyByID", responseWriter, request)}
+}
+
+func (_c *MockHandler_GetRoutePolicyByID_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetRoutePolicyByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_GetRoutePolicyByID_Call) Return() *MockHandler_GetRoutePolicyByID_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_GetRoutePolicyByID_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_GetRoutePolicyByID_Call {
+	_c.Run(run)
+	return _c
+}
+
+// ListAllChannels provides a mock function for the type MockHandler
+func (_mock *MockHandler) ListAllChannels(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_ListAllChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllChannels'
+type MockHandler_ListAllChannels_Call struct {
+	*mock.Call
+}
+
+// ListAllChannels is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) ListAllChannels(responseWriter interface{}, request interface{}) *MockHandler_ListAllChannels_Call {
+	return &MockHandler_ListAllChannels_Call{Call: _e.mock.On("ListAllChannels", responseWriter, request)}
+}
+
+func (_c *MockHandler_ListAllChannels_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_ListAllChannels_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_ListAllChannels_Call) Return() *MockHandler_ListAllChannels_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_ListAllChannels_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_ListAllChannels_Call {
+	_c.Run(run)
+	return _c
+}
+
+// ListChannels provides a mock function for the type MockHandler
+func (_mock *MockHandler) ListChannels(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
+type MockHandler_ListChannels_Call struct {
+	*mock.Call
+}
+
+// ListChannels is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) ListChannels(responseWriter interface{}, request interface{}) *MockHandler_ListChannels_Call {
+	return &MockHandler_ListChannels_Call{Call: _e.mock.On("ListChannels", responseWriter, request)}
+}
+
+func (_c *MockHandler_ListChannels_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_ListChannels_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_ListChannels_Call) Return() *MockHandler_ListChannels_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_ListChannels_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_ListChannels_Call {
+	_c.Run(run)
+	return _c
+}
+
+// TestReceiver provides a mock function for the type MockHandler
+func (_mock *MockHandler) TestReceiver(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_TestReceiver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestReceiver'
+type MockHandler_TestReceiver_Call struct {
+	*mock.Call
+}
+
+// TestReceiver is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) TestReceiver(responseWriter interface{}, request interface{}) *MockHandler_TestReceiver_Call {
+	return &MockHandler_TestReceiver_Call{Call: _e.mock.On("TestReceiver", responseWriter, request)}
+}
+
+func (_c *MockHandler_TestReceiver_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_TestReceiver_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_TestReceiver_Call) Return() *MockHandler_TestReceiver_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_TestReceiver_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_TestReceiver_Call {
+	_c.Run(run)
+	return _c
+}
+
+// UpdateChannelByID provides a mock function for the type MockHandler
+func (_mock *MockHandler) UpdateChannelByID(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_UpdateChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelByID'
+type MockHandler_UpdateChannelByID_Call struct {
+	*mock.Call
+}
+
+// UpdateChannelByID is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) UpdateChannelByID(responseWriter interface{}, request interface{}) *MockHandler_UpdateChannelByID_Call {
+	return &MockHandler_UpdateChannelByID_Call{Call: _e.mock.On("UpdateChannelByID", responseWriter, request)}
+}
+
+func (_c *MockHandler_UpdateChannelByID_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_UpdateChannelByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_UpdateChannelByID_Call) Return() *MockHandler_UpdateChannelByID_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_UpdateChannelByID_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_UpdateChannelByID_Call {
+	_c.Run(run)
+	return _c
+}
+
+// UpdateRoutePolicy provides a mock function for the type MockHandler
+func (_mock *MockHandler) UpdateRoutePolicy(responseWriter http.ResponseWriter, request *http.Request) {
+	_mock.Called(responseWriter, request)
+	return
+}
+
+// MockHandler_UpdateRoutePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoutePolicy'
+type MockHandler_UpdateRoutePolicy_Call struct {
+	*mock.Call
+}
+
+// UpdateRoutePolicy is a helper method to define mock.On call
+//   - responseWriter http.ResponseWriter
+//   - request *http.Request
+func (_e *MockHandler_Expecter) UpdateRoutePolicy(responseWriter interface{}, request interface{}) *MockHandler_UpdateRoutePolicy_Call {
+	return &MockHandler_UpdateRoutePolicy_Call{Call: _e.mock.On("UpdateRoutePolicy", responseWriter, request)}
+}
+
+func (_c *MockHandler_UpdateRoutePolicy_Call) Run(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_UpdateRoutePolicy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 http.ResponseWriter
+		if args[0] != nil {
+			arg0 = args[0].(http.ResponseWriter)
+		}
+		var arg1 *http.Request
+		if args[1] != nil {
+			arg1 = args[1].(*http.Request)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockHandler_UpdateRoutePolicy_Call) Return() *MockHandler_UpdateRoutePolicy_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockHandler_UpdateRoutePolicy_Call) RunAndReturn(run func(responseWriter http.ResponseWriter, request *http.Request)) *MockHandler_UpdateRoutePolicy_Call {
+	_c.Run(run)
+	return _c
+}

pkg/alertmanager/service.go

@@ -39,16 +39,18 @@ type Service struct {
 	serversMtx sync.RWMutex
 
 	notificationManager nfmanager.NotificationManager
+
+	maintenanceStore alertmanagertypes.MaintenanceStore
 }
 
 func New(
-	ctx context.Context,
 	settings factory.ScopedProviderSettings,
 	config alertmanagerserver.Config,
 	stateStore alertmanagertypes.StateStore,
 	configStore alertmanagertypes.ConfigStore,
 	orgGetter organization.Getter,
 	nfManager nfmanager.NotificationManager,
+	maintenanceStore alertmanagertypes.MaintenanceStore,
 ) *Service {
 	service := &Service{
 		config:              config,
@@ -59,6 +61,7 @@ func New(
 		servers:             make(map[string]*alertmanagerserver.Server),
 		serversMtx:          sync.RWMutex{},
 		notificationManager: nfManager,
+		maintenanceStore:    maintenanceStore,
 	}
 
 	return service
@@ -177,7 +180,10 @@ func (service *Service) newServer(ctx context.Context, orgID string) (*alertmana
 		return nil, err
 	}
 
-	server, err := alertmanagerserver.New(ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID, service.stateStore, service.notificationManager)
+	server, err := alertmanagerserver.New(
+		ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID,
+		service.stateStore, service.notificationManager, service.maintenanceStore,
+	)
 	if err != nil {
 		return nil, err
 	}

pkg/alertmanager/signozalertmanager/provider.go

@@ -4,11 +4,8 @@ import (
 	"context"
 	"time"
 
-	"github.com/prometheus/common/model"
-
-	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
-
 	amConfig "github.com/prometheus/alertmanager/config"
+	"github.com/prometheus/common/model"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
@@ -20,6 +17,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -30,35 +28,49 @@ type provider struct {
 	configStore         alertmanagertypes.ConfigStore
 	stateStore          alertmanagertypes.StateStore
 	notificationManager nfmanager.NotificationManager
+	maintenanceStore    alertmanagertypes.MaintenanceStore
 	stopC               chan struct{}
 }
 
-func NewFactory(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
+func NewFactory(
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	notificationManager nfmanager.NotificationManager,
+	maintenanceStore alertmanagertypes.MaintenanceStore,
+) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, settings factory.ProviderSettings, config alertmanager.Config) (alertmanager.Alertmanager, error) {
-		return New(ctx, settings, config, sqlstore, orgGetter, notificationManager)
+		return New(settings, config, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	})
 }
 
-func New(ctx context.Context, providerSettings factory.ProviderSettings, config alertmanager.Config, sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) (*provider, error) {
+func New(
+	providerSettings factory.ProviderSettings,
+	config alertmanager.Config,
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	notificationManager nfmanager.NotificationManager,
+	maintenanceStore alertmanagertypes.MaintenanceStore,
+) (*provider, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager")
 	configStore := sqlalertmanagerstore.NewConfigStore(sqlstore)
 	stateStore := sqlalertmanagerstore.NewStateStore(sqlstore)
 
 	p := &provider{
 		service: alertmanager.New(
-			ctx,
 			settings,
 			config.Signoz.Config,
 			stateStore,
 			configStore,
 			orgGetter,
 			notificationManager,
+			maintenanceStore,
 		),
 		settings:            settings,
 		config:              config,
 		configStore:         configStore,
 		stateStore:          stateStore,
 		notificationManager: notificationManager,
+		maintenanceStore:    maintenanceStore,
 		stopC:               make(chan struct{}),
 	}
 
@@ -113,7 +125,7 @@ func (provider *provider) TestAlert(ctx context.Context, orgID string, ruleID st
 			for k, v := range alert.Labels {
 				set[model.LabelName(k)] = model.LabelValue(v)
 			}
-			match, err := provider.notificationManager.Match(ctx, orgID, alert.Labels[labels.AlertRuleIdLabel], set)
+			match, err := provider.notificationManager.Match(ctx, orgID, alert.Labels[ruletypes.LabelRuleID], set)
 			if err != nil {
 				return err
 			}

pkg/apiserver/signozapiserver/ruler.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/gorilla/mux"
 )
@@ -120,8 +121,8 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
 		Tags:                []string{"downtimeschedules"},
 		Summary:             "List downtime schedules",
 		Description:         "This endpoint lists all planned maintenance / downtime schedules",
-		RequestQuery:        new(ruletypes.ListPlannedMaintenanceParams),
-		Response:            make([]*ruletypes.PlannedMaintenance, 0),
+		RequestQuery:        new(alertmanagertypes.ListPlannedMaintenanceParams),
+		Response:            make([]*alertmanagertypes.PlannedMaintenance, 0),
 		ResponseContentType: "application/json",
 		SuccessStatusCode:   http.StatusOK,
 		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
@@ -134,7 +135,7 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
 		Tags:                []string{"downtimeschedules"},
 		Summary:             "Get downtime schedule by ID",
 		Description:         "This endpoint returns a downtime schedule by ID",
-		Response:            new(ruletypes.PlannedMaintenance),
+		Response:            new(alertmanagertypes.PlannedMaintenance),
 		ResponseContentType: "application/json",
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{http.StatusNotFound},
@@ -148,9 +149,9 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
 		Tags:                []string{"downtimeschedules"},
 		Summary:             "Create downtime schedule",
 		Description:         "This endpoint creates a new planned maintenance / downtime schedule",
-		Request:             new(ruletypes.PostablePlannedMaintenance),
+		Request:             new(alertmanagertypes.PostablePlannedMaintenance),
 		RequestContentType:  "application/json",
-		Response:            new(ruletypes.PlannedMaintenance),
+		Response:            new(alertmanagertypes.PlannedMaintenance),
 		ResponseContentType: "application/json",
 		SuccessStatusCode:   http.StatusCreated,
 		ErrorStatusCodes:    []int{http.StatusBadRequest},
@@ -164,7 +165,7 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
 		Tags:               []string{"downtimeschedules"},
 		Summary:            "Update downtime schedule",
 		Description:        "This endpoint updates a downtime schedule by ID",
-		Request:            new(ruletypes.PostablePlannedMaintenance),
+		Request:            new(alertmanagertypes.PostablePlannedMaintenance),
 		RequestContentType: "application/json",
 		SuccessStatusCode:  http.StatusNoContent,
 		ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},

pkg/query-service/rules/manager.go

@@ -32,30 +32,28 @@ import (
 )
 
 type PrepareTaskOptions struct {
-	Rule             *ruletypes.PostableRule
-	TaskName         string
-	RuleStore        ruletypes.RuleStore
-	MaintenanceStore ruletypes.MaintenanceStore
-	Querier          querier.Querier
-	Logger           *slog.Logger
-	Cache            cache.Cache
-	ManagerOpts      *ManagerOptions
-	NotifyFunc       NotifyFunc
-	SQLStore         sqlstore.SQLStore
-	OrgID            valuer.UUID
+	Rule        *ruletypes.PostableRule
+	TaskName    string
+	RuleStore   ruletypes.RuleStore
+	Querier     querier.Querier
+	Logger      *slog.Logger
+	Cache       cache.Cache
+	ManagerOpts *ManagerOptions
+	NotifyFunc  NotifyFunc
+	SQLStore    sqlstore.SQLStore
+	OrgID       valuer.UUID
 }
 
 type PrepareTestRuleOptions struct {
-	Rule             *ruletypes.PostableRule
-	RuleStore        ruletypes.RuleStore
-	MaintenanceStore ruletypes.MaintenanceStore
-	Querier          querier.Querier
-	Logger           *slog.Logger
-	Cache            cache.Cache
-	ManagerOpts      *ManagerOptions
-	NotifyFunc       NotifyFunc
-	SQLStore         sqlstore.SQLStore
-	OrgID            valuer.UUID
+	Rule        *ruletypes.PostableRule
+	RuleStore   ruletypes.RuleStore
+	Querier     querier.Querier
+	Logger      *slog.Logger
+	Cache       cache.Cache
+	ManagerOpts *ManagerOptions
+	NotifyFunc  NotifyFunc
+	SQLStore    sqlstore.SQLStore
+	OrgID       valuer.UUID
 }
 
 const taskNameSuffix = "webAppEditor"
@@ -89,7 +87,7 @@ type ManagerOptions struct {
 	Alertmanager        alertmanager.Alertmanager
 	OrgGetter           organization.Getter
 	RuleStore           ruletypes.RuleStore
-	MaintenanceStore    ruletypes.MaintenanceStore
+	MaintenanceStore    alertmanagertypes.MaintenanceStore
 	SQLStore            sqlstore.SQLStore
 	QueryParser         queryparser.QueryParser
 }
@@ -103,7 +101,7 @@ type Manager struct {
 	block chan struct{}
 	// datastore to store alert definitions
 	ruleStore        ruletypes.RuleStore
-	maintenanceStore ruletypes.MaintenanceStore
+	maintenanceStore alertmanagertypes.MaintenanceStore
 
 	logger              *slog.Logger
 	cache               cache.Cache
@@ -134,7 +132,6 @@ func defaultOptions(o *ManagerOptions) *ManagerOptions {
 }
 
 func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
-
 	rules := make([]Rule, 0)
 	var task Task
 
@@ -159,7 +156,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
-
 		if err != nil {
 			return task, err
 		}
@@ -167,7 +163,7 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 		rules = append(rules, tr)
 
 		// create ch rule task for evaluation
-		task = newTask(TaskTypeCh, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(TaskTypeCh, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeProm {
 
@@ -183,7 +179,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
-
 		if err != nil {
 			return task, err
 		}
@@ -191,7 +186,7 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 		rules = append(rules, pr)
 
 		// create promql rule task for evaluation
-		task = newTask(TaskTypeProm, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(TaskTypeProm, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
@@ -237,10 +232,11 @@ func (m *Manager) RuleStore() ruletypes.RuleStore {
 	return m.ruleStore
 }
 
-func (m *Manager) MaintenanceStore() ruletypes.MaintenanceStore {
+func (m *Manager) MaintenanceStore() alertmanagertypes.MaintenanceStore {
 	return m.maintenanceStore
 }
 
+// TODO(jatinderjit): remove (unused)?
 func (m *Manager) Pause(b bool) {
 	m.mtx.Lock()
 	defer m.mtx.Unlock()
@@ -430,19 +426,17 @@ func (m *Manager) editTask(_ context.Context, orgID valuer.UUID, rule *ruletypes
 	m.logger.Debug("editing a rule task", "name", taskName)
 
 	newTask, err := m.prepareTaskFunc(PrepareTaskOptions{
-		Rule:             rule,
-		TaskName:         taskName,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.notifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        rule,
+		TaskName:    taskName,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.notifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
-
 	if err != nil {
 		m.logger.Error("loading tasks failed", errors.Attr(err))
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error preparing rule with given parameters, previous rule set restored")
@@ -643,19 +637,17 @@ func (m *Manager) addTask(_ context.Context, orgID valuer.UUID, rule *ruletypes.
 
 	m.logger.Debug("adding a new rule task", "name", taskName)
 	newTask, err := m.prepareTaskFunc(PrepareTaskOptions{
-		Rule:             rule,
-		TaskName:         taskName,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.notifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        rule,
+		TaskName:    taskName,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.notifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
-
 	if err != nil {
 		m.logger.Error("creating rule task failed", "name", taskName, errors.Attr(err))
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error loading rules, previous rule set restored")
@@ -703,7 +695,6 @@ func (m *Manager) RuleTasks() []Task {
 // RuleTasksWithoutLock returns the list of manager's rule tasks without
 // acquiring a lock on the manager.
 func (m *Manager) RuleTasksWithoutLock() []Task {
-
 	rgs := make([]Task, 0, len(m.tasks))
 	for _, g := range m.tasks {
 		rgs = append(rgs, g)
@@ -897,7 +888,6 @@ func (m *Manager) GetRule(ctx context.Context, id valuer.UUID) (*ruletypes.Getta
 // the task state. For example - if a stored rule is disabled, then
 // there is no task running against it.
 func (m *Manager) syncRuleStateWithTask(ctx context.Context, orgID valuer.UUID, taskName string, rule *ruletypes.PostableRule) error {
-
 	if rule.Disabled {
 		// check if rule has any task running
 		if _, ok := m.tasks[taskName]; ok {
@@ -1029,16 +1019,15 @@ func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleS
 	}
 
 	alertCount, err := m.prepareTestRuleFunc(PrepareTestRuleOptions{
-		Rule:             &parsedRule,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.testNotifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        &parsedRule,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.testNotifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
 
 	return alertCount, err

pkg/query-service/rules/prom_rule_task.go

@@ -15,7 +15,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // PromRuleTask is a promql rule executor
@@ -39,14 +38,11 @@ type PromRuleTask struct {
 	pause  bool
 	logger *slog.Logger
 	notify NotifyFunc
-
-	maintenanceStore ruletypes.MaintenanceStore
-	orgID            valuer.UUID
 }
 
 // NewPromRuleTask holds rules that have promql condition
 // and evaluates the rule at a given frequency
-func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) *PromRuleTask {
+func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) *PromRuleTask {
 	opts.Logger.Info("initiating a new rule group", "name", name, "frequency", frequency)
 
 	if frequency == 0 {
@@ -63,10 +59,8 @@ func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, o
 		seriesInPreviousEval: make([]map[string]plabels.Labels, len(rules)),
 		done:                 make(chan struct{}),
 		terminated:           make(chan struct{}),
-		notify:               notify,
-		maintenanceStore:     maintenanceStore,
-		logger:               opts.Logger,
-		orgID:                orgID,
+		notify: notify,
+		logger: opts.Logger,
 	}
 }
 
@@ -330,30 +324,12 @@ func (g *PromRuleTask) Eval(ctx context.Context, ts time.Time) {
 	}()
 
 	g.logger.InfoContext(ctx, "promql rule task", "name", g.name, "eval_started_at", ts)
-	maintenance, err := g.maintenanceStore.ListPlannedMaintenance(ctx, g.orgID.StringValue())
-	if err != nil {
-		g.logger.ErrorContext(ctx, "error in processing sql query", errors.Attr(err))
-	}
 
 	for i, rule := range g.rules {
 		if rule == nil {
 			continue
 		}
 
-		shouldSkip := false
-		for _, m := range maintenance {
-			g.logger.InfoContext(ctx, "checking if rule should be skipped", slog.String("rule.id", rule.ID()), slog.Any("maintenance", m))
-			if m.ShouldSkip(rule.ID(), ts) {
-				shouldSkip = true
-				break
-			}
-		}
-
-		if shouldSkip {
-			g.logger.InfoContext(ctx, "rule should be skipped", slog.String("rule.id", rule.ID()))
-			continue
-		}
-
 		select {
 		case <-g.done:
 			return

pkg/query-service/rules/rule_task.go

@@ -2,20 +2,18 @@ package rules
 
 import (
 	"context"
+	"log/slog"
 	"runtime/debug"
 	"sort"
 	"sync"
 	"time"
 
-	"log/slog"
-
 	opentracing "github.com/opentracing/opentracing-go"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // RuleTask holds a rule (with composite queries)
@@ -37,34 +35,28 @@ type RuleTask struct {
 
 	pause  bool
 	notify NotifyFunc
-
-	maintenanceStore ruletypes.MaintenanceStore
-	orgID            valuer.UUID
 }
 
 const DefaultFrequency = 1 * time.Minute
 
 // NewRuleTask makes a new RuleTask with the given name, options, and rules.
-func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) *RuleTask {
-
+func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) *RuleTask {
 	if frequency == 0 {
 		frequency = DefaultFrequency
 	}
 	opts.Logger.Info("initiating a new rule task", "name", name, "frequency", frequency)
 
 	return &RuleTask{
-		name:             name,
-		file:             file,
-		pause:            false,
-		frequency:        frequency,
-		rules:            rules,
-		opts:             opts,
-		logger:           opts.Logger,
-		done:             make(chan struct{}),
-		terminated:       make(chan struct{}),
-		notify:           notify,
-		maintenanceStore: maintenanceStore,
-		orgID:            orgID,
+		name:       name,
+		file:       file,
+		pause:      false,
+		frequency:  frequency,
+		rules:      rules,
+		opts:       opts,
+		logger:     opts.Logger,
+		done:       make(chan struct{}),
+		terminated: make(chan struct{}),
+		notify:     notify,
 	}
 }
 
@@ -72,6 +64,7 @@ func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts
 func (g *RuleTask) Name() string { return g.name }
 
 // Key returns the group key
+// TODO(jatinderjit): remove (unused)?
 func (g *RuleTask) Key() string {
 	return g.name + ";" + g.file
 }
@@ -83,7 +76,7 @@ func (g *RuleTask) Type() TaskType { return TaskTypeCh }
 func (g *RuleTask) Rules() []Rule { return g.rules }
 
 // Interval returns the group's interval.
-// TODO: remove (unused)?
+// TODO(jatinderjit): remove (unused)?
 func (g *RuleTask) Interval() time.Duration { return g.frequency }
 
 func (g *RuleTask) Pause(b bool) {
@@ -261,7 +254,6 @@ func nameAndLabels(rule Rule) string {
 // Rules are matched based on their name and labels. If there are duplicates, the
 // first is matched with the first, second with the second etc.
 func (g *RuleTask) CopyState(fromTask Task) error {
-
 	from, ok := fromTask.(*RuleTask)
 	if !ok {
 		return errors.NewInternalf(errors.CodeInternal, "invalid from task for copy")
@@ -306,7 +298,6 @@ func (g *RuleTask) CopyState(fromTask Task) error {
 
 // Eval runs a single evaluation cycle in which all rules are evaluated sequentially.
 func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
-
 	defer func() {
 		if r := recover(); r != nil {
 			g.logger.ErrorContext(
@@ -318,31 +309,11 @@ func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
 
 	g.logger.DebugContext(ctx, "rule task eval started", "name", g.name, "start_time", ts)
 
-	maintenance, err := g.maintenanceStore.ListPlannedMaintenance(ctx, g.orgID.StringValue())
-
-	if err != nil {
-		g.logger.ErrorContext(ctx, "error in processing sql query", errors.Attr(err))
-	}
-
 	for i, rule := range g.rules {
 		if rule == nil {
 			continue
 		}
 
-		shouldSkip := false
-		for _, m := range maintenance {
-			g.logger.InfoContext(ctx, "checking if rule should be skipped", slog.String("rule.id", rule.ID()), slog.Any("maintenance", m))
-			if m.ShouldSkip(rule.ID(), ts) {
-				shouldSkip = true
-				break
-			}
-		}
-
-		if shouldSkip {
-			g.logger.InfoContext(ctx, "rule should be skipped", slog.String("rule.id", rule.ID()))
-			continue
-		}
-
 		select {
 		case <-g.done:
 			return
@@ -382,7 +353,6 @@ func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
 			}
 
 			rule.SendAlerts(ctx, ts, g.opts.ResendDelay, g.frequency, g.notify)
-
 		}(i, rule)
 	}
 }

pkg/query-service/rules/task.go

@@ -3,9 +3,6 @@ package rules
 import (
 	"context"
 	"time"
-
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 type TaskType string
@@ -32,9 +29,9 @@ type Task interface {
 
 // newTask returns an appropriate group for
 // rule type
-func newTask(taskType TaskType, name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) Task {
+func newTask(taskType TaskType, name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) Task {
 	if taskType == TaskTypeCh {
-		return NewRuleTask(name, file, frequency, rules, opts, notify, maintenanceStore, orgID)
+		return NewRuleTask(name, file, frequency, rules, opts, notify)
 	}
-	return NewPromRuleTask(name, file, frequency, rules, opts, notify, maintenanceStore, orgID)
+	return NewPromRuleTask(name, file, frequency, rules, opts, notify)
 }

pkg/ruler/ruler.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -44,5 +45,5 @@ type Ruler interface {
 	// MaintenanceStore returns the store for planned maintenance / downtime schedules.
 	// TODO: expose downtime CRUD as methods on Ruler directly instead of leaking the
 	// store interface. The handler should not call store methods directly.
-	MaintenanceStore() ruletypes.MaintenanceStore
+	MaintenanceStore() alertmanagertypes.MaintenanceStore
 }

pkg/ruler/signozruler/handler.go

@@ -10,6 +10,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -194,7 +195,7 @@ func (handler *handler) ListDowntimeSchedules(rw http.ResponseWriter, req *http.
 		return
 	}
 
-	var params ruletypes.ListPlannedMaintenanceParams
+	var params alertmanagertypes.ListPlannedMaintenanceParams
 	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
 		return
@@ -207,7 +208,7 @@ func (handler *handler) ListDowntimeSchedules(rw http.ResponseWriter, req *http.
 	}
 
 	if params.Active != nil {
-		activeSchedules := make([]*ruletypes.PlannedMaintenance, 0)
+		activeSchedules := make([]*alertmanagertypes.PlannedMaintenance, 0)
 		for _, schedule := range schedules {
 			now := time.Now().In(time.FixedZone(schedule.Schedule.Timezone, 0))
 			if schedule.IsActive(now) == *params.Active {
@@ -218,7 +219,7 @@ func (handler *handler) ListDowntimeSchedules(rw http.ResponseWriter, req *http.
 	}
 
 	if params.Recurring != nil {
-		recurringSchedules := make([]*ruletypes.PlannedMaintenance, 0)
+		recurringSchedules := make([]*alertmanagertypes.PlannedMaintenance, 0)
 		for _, schedule := range schedules {
 			if schedule.IsRecurring() == *params.Recurring {
 				recurringSchedules = append(recurringSchedules, schedule)
@@ -253,7 +254,7 @@ func (handler *handler) CreateDowntimeSchedule(rw http.ResponseWriter, req *http
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	schedule := new(ruletypes.PostablePlannedMaintenance)
+	schedule := new(alertmanagertypes.PostablePlannedMaintenance)
 	if err := binding.JSON.BindBody(req.Body, schedule); err != nil {
 		render.Error(rw, err)
 		return
@@ -283,7 +284,7 @@ func (handler *handler) UpdateDowntimeScheduleByID(rw http.ResponseWriter, req *
 		return
 	}
 
-	schedule := new(ruletypes.PostablePlannedMaintenance)
+	schedule := new(alertmanagertypes.PostablePlannedMaintenance)
 	if err := binding.JSON.BindBody(req.Body, schedule); err != nil {
 		render.Error(rw, err)
 		return

pkg/ruler/signozruler/provider.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -16,6 +17,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -44,7 +46,7 @@ func NewFactory(
 ) factory.ProviderFactory[ruler.Ruler, ruler.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config ruler.Config) (ruler.Ruler, error) {
 		ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
-		maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore, providerSettings)
+		maintenanceStore := sqlalertmanagerstore.NewMaintenanceStore(sqlstore, providerSettings)
 
 		managerOpts := &rules.ManagerOptions{
 			TelemetryStore:         telemetryStore,
@@ -129,6 +131,6 @@ func (provider *provider) TestNotification(ctx context.Context, orgID valuer.UUI
 	return provider.manager.TestNotification(ctx, orgID, ruleStr)
 }
 
-func (provider *provider) MaintenanceStore() ruletypes.MaintenanceStore {
+func (provider *provider) MaintenanceStore() alertmanagertypes.MaintenanceStore {
 	return provider.manager.MaintenanceStore()
 }

pkg/signoz/handler_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/emailing/emailingtest"
@@ -40,7 +41,8 @@ func TestNewHandlers(t *testing.T) {
 	orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstore), sharder)
 	notificationManager := nfmanagertest.NewMock()
 	require.NoError(t, err)
-	alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager)
+	maintenanceStore := sqlalertmanagerstore.NewMaintenanceStore(sqlstore, providerSettings)
+	alertmanager, err := signozalertmanager.New(providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	require.NoError(t, err)
 	tokenizer := tokenizertest.NewMockTokenizer(t)
 	emailing := emailingtest.New()

pkg/signoz/module_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/emailing/emailingtest"
@@ -41,7 +42,8 @@ func TestNewModules(t *testing.T) {
 	orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstore), sharder)
 	notificationManager := nfmanagertest.NewMock()
 	require.NoError(t, err)
-	alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager)
+	maintenanceStore := sqlalertmanagerstore.NewMaintenanceStore(sqlstore, providerSettings)
+	alertmanager, err := signozalertmanager.New(providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	require.NoError(t, err)
 	tokenizer := tokenizertest.NewMockTokenizer(t)
 	emailing := emailingtest.New()

pkg/signoz/provider.go

@@ -230,9 +230,14 @@ func NewNotificationManagerProviderFactories(routeStore alertmanagertypes.RouteS
 	)
 }
 
-func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, nfManager nfmanager.NotificationManager) factory.NamedMap[factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config]] {
+func NewAlertmanagerProviderFactories(
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	nfManager nfmanager.NotificationManager,
+	maintenanceStore alertmanagertypes.MaintenanceStore,
+) factory.NamedMap[factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config]] {
 	return factory.MustNewNamedMap(
-		signozalertmanager.NewFactory(sqlstore, orgGetter, nfManager),
+		signozalertmanager.NewFactory(sqlstore, orgGetter, nfManager, maintenanceStore),
 	)
 }
 

pkg/signoz/provider_test.go

@@ -5,8 +5,10 @@ import (
 	"testing"
 
 	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
 	"github.com/SigNoz/signoz/pkg/analytics"
+	"github.com/SigNoz/signoz/pkg/factory/factorytest"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
@@ -59,9 +61,11 @@ func TestNewProviderFactories(t *testing.T) {
 	})
 
 	assert.NotPanics(t, func() {
-		orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)), nil)
+		store := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)
+		orgGetter := implorganization.NewGetter(implorganization.NewStore(store), nil)
 		notificationManager := nfmanagertest.NewMock()
-		NewAlertmanagerProviderFactories(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), orgGetter, notificationManager)
+		maintenanceStore := sqlalertmanagerstore.NewMaintenanceStore(store, factorytest.NewSettings())
+		NewAlertmanagerProviderFactories(store, orgGetter, notificationManager, maintenanceStore)
 	})
 
 	assert.NotPanics(t, func() {

pkg/signoz/signoz.go

@@ -5,6 +5,7 @@ import (
 	"log/slog"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfroutingstore/sqlroutingstore"
 	"github.com/SigNoz/signoz/pkg/analytics"
@@ -375,12 +376,14 @@ func New(
 		return nil, err
 	}
 
+	maintenanceStore := sqlalertmanagerstore.NewMaintenanceStore(sqlstore, providerSettings)
+
 	// Initialize alertmanager from the available alertmanager provider factories
 	alertmanager, err := factory.NewProviderFromNamedMap(
 		ctx,
 		providerSettings,
 		config.Alertmanager,
-		NewAlertmanagerProviderFactories(sqlstore, orgGetter, nfManager),
+		NewAlertmanagerProviderFactories(sqlstore, orgGetter, nfManager, maintenanceStore),
 		config.Alertmanager.Provider,
 	)
 	if err != nil {

pkg/sqlmigration/027_update_rules.go

@@ -11,7 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
-	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"github.com/uptrace/bun/migrate"
@@ -61,7 +61,7 @@ type existingMaintenance struct {
 	Name          string              `bun:"name,type:text,notnull"`
 	Description   string              `bun:"description,type:text"`
 	AlertIDs      *AlertIds           `bun:"alert_ids,type:text"`
-	Schedule      *ruletypes.Schedule `bun:"schedule,type:text,notnull"`
+	Schedule      *alertmanagertypes.Schedule `bun:"schedule,type:text,notnull"`
 	CreatedAt     time.Time           `bun:"created_at,type:datetime,notnull"`
 	CreatedBy     string              `bun:"created_by,type:text,notnull"`
 	UpdatedAt     time.Time           `bun:"updated_at,type:datetime,notnull"`
@@ -75,7 +75,7 @@ type newMaintenance struct {
 	types.UserAuditable
 	Name        string              `bun:"name,type:text,notnull"`
 	Description string              `bun:"description,type:text"`
-	Schedule    *ruletypes.Schedule `bun:"schedule,type:text,notnull"`
+	Schedule    *alertmanagertypes.Schedule `bun:"schedule,type:text,notnull"`
 	OrgID       string              `bun:"org_id,type:text"`
 }
 

pkg/types/alertmanagertypes/alert.go

@@ -170,6 +170,7 @@ func NewGettableAlertsFromAlertProvider(
 	cfg *Config,
 	getAlertStatusFunc func(model.Fingerprint) types.AlertStatus,
 	setAlertStatusFunc func(model.LabelSet),
+	mutedByFunc func(model.LabelSet) []string,
 	params GettableAlertsParams,
 ) (GettableAlerts, error) {
 	res := GettableAlerts{}
@@ -219,7 +220,7 @@ func NewGettableAlertsFromAlertProvider(
 			continue
 		}
 
-		alert := v2.AlertToOpenAPIAlert(alertData, getAlertStatusFunc(alertData.Fingerprint()), receivers, nil)
+		alert := v2.AlertToOpenAPIAlert(alertData, getAlertStatusFunc(alertData.Fingerprint()), receivers, mutedByFunc(alertData.Labels))
 
 		res = append(res, alert)
 	}

pkg/types/alertmanagertypes/alertmanagertypestest/maintenance.go

@@ -0,0 +1,364 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package alertmanagertypestest
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockMaintenanceStore creates a new instance of MockMaintenanceStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockMaintenanceStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockMaintenanceStore {
+	mock := &MockMaintenanceStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockMaintenanceStore is an autogenerated mock type for the MaintenanceStore type
+type MockMaintenanceStore struct {
+	mock.Mock
+}
+
+type MockMaintenanceStore_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockMaintenanceStore) EXPECT() *MockMaintenanceStore_Expecter {
+	return &MockMaintenanceStore_Expecter{mock: &_m.Mock}
+}
+
+// CreatePlannedMaintenance provides a mock function for the type MockMaintenanceStore
+func (_mock *MockMaintenanceStore) CreatePlannedMaintenance(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance) (*alertmanagertypes.PlannedMaintenance, error) {
+	ret := _mock.Called(context1, postablePlannedMaintenance)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreatePlannedMaintenance")
+	}
+
+	var r0 *alertmanagertypes.PlannedMaintenance
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostablePlannedMaintenance) (*alertmanagertypes.PlannedMaintenance, error)); ok {
+		return returnFunc(context1, postablePlannedMaintenance)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostablePlannedMaintenance) *alertmanagertypes.PlannedMaintenance); ok {
+		r0 = returnFunc(context1, postablePlannedMaintenance)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*alertmanagertypes.PlannedMaintenance)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *alertmanagertypes.PostablePlannedMaintenance) error); ok {
+		r1 = returnFunc(context1, postablePlannedMaintenance)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMaintenanceStore_CreatePlannedMaintenance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlannedMaintenance'
+type MockMaintenanceStore_CreatePlannedMaintenance_Call struct {
+	*mock.Call
+}
+
+// CreatePlannedMaintenance is a helper method to define mock.On call
+//   - context1 context.Context
+//   - postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance
+func (_e *MockMaintenanceStore_Expecter) CreatePlannedMaintenance(context1 interface{}, postablePlannedMaintenance interface{}) *MockMaintenanceStore_CreatePlannedMaintenance_Call {
+	return &MockMaintenanceStore_CreatePlannedMaintenance_Call{Call: _e.mock.On("CreatePlannedMaintenance", context1, postablePlannedMaintenance)}
+}
+
+func (_c *MockMaintenanceStore_CreatePlannedMaintenance_Call) Run(run func(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance)) *MockMaintenanceStore_CreatePlannedMaintenance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *alertmanagertypes.PostablePlannedMaintenance
+		if args[1] != nil {
+			arg1 = args[1].(*alertmanagertypes.PostablePlannedMaintenance)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMaintenanceStore_CreatePlannedMaintenance_Call) Return(plannedMaintenance *alertmanagertypes.PlannedMaintenance, err error) *MockMaintenanceStore_CreatePlannedMaintenance_Call {
+	_c.Call.Return(plannedMaintenance, err)
+	return _c
+}
+
+func (_c *MockMaintenanceStore_CreatePlannedMaintenance_Call) RunAndReturn(run func(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance) (*alertmanagertypes.PlannedMaintenance, error)) *MockMaintenanceStore_CreatePlannedMaintenance_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeletePlannedMaintenance provides a mock function for the type MockMaintenanceStore
+func (_mock *MockMaintenanceStore) DeletePlannedMaintenance(context1 context.Context, uUID valuer.UUID) error {
+	ret := _mock.Called(context1, uUID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeletePlannedMaintenance")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok {
+		r0 = returnFunc(context1, uUID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockMaintenanceStore_DeletePlannedMaintenance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePlannedMaintenance'
+type MockMaintenanceStore_DeletePlannedMaintenance_Call struct {
+	*mock.Call
+}
+
+// DeletePlannedMaintenance is a helper method to define mock.On call
+//   - context1 context.Context
+//   - uUID valuer.UUID
+func (_e *MockMaintenanceStore_Expecter) DeletePlannedMaintenance(context1 interface{}, uUID interface{}) *MockMaintenanceStore_DeletePlannedMaintenance_Call {
+	return &MockMaintenanceStore_DeletePlannedMaintenance_Call{Call: _e.mock.On("DeletePlannedMaintenance", context1, uUID)}
+}
+
+func (_c *MockMaintenanceStore_DeletePlannedMaintenance_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockMaintenanceStore_DeletePlannedMaintenance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 valuer.UUID
+		if args[1] != nil {
+			arg1 = args[1].(valuer.UUID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMaintenanceStore_DeletePlannedMaintenance_Call) Return(err error) *MockMaintenanceStore_DeletePlannedMaintenance_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockMaintenanceStore_DeletePlannedMaintenance_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) error) *MockMaintenanceStore_DeletePlannedMaintenance_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPlannedMaintenanceByID provides a mock function for the type MockMaintenanceStore
+func (_mock *MockMaintenanceStore) GetPlannedMaintenanceByID(context1 context.Context, uUID valuer.UUID) (*alertmanagertypes.PlannedMaintenance, error) {
+	ret := _mock.Called(context1, uUID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPlannedMaintenanceByID")
+	}
+
+	var r0 *alertmanagertypes.PlannedMaintenance
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (*alertmanagertypes.PlannedMaintenance, error)); ok {
+		return returnFunc(context1, uUID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) *alertmanagertypes.PlannedMaintenance); ok {
+		r0 = returnFunc(context1, uUID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*alertmanagertypes.PlannedMaintenance)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, valuer.UUID) error); ok {
+		r1 = returnFunc(context1, uUID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMaintenanceStore_GetPlannedMaintenanceByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlannedMaintenanceByID'
+type MockMaintenanceStore_GetPlannedMaintenanceByID_Call struct {
+	*mock.Call
+}
+
+// GetPlannedMaintenanceByID is a helper method to define mock.On call
+//   - context1 context.Context
+//   - uUID valuer.UUID
+func (_e *MockMaintenanceStore_Expecter) GetPlannedMaintenanceByID(context1 interface{}, uUID interface{}) *MockMaintenanceStore_GetPlannedMaintenanceByID_Call {
+	return &MockMaintenanceStore_GetPlannedMaintenanceByID_Call{Call: _e.mock.On("GetPlannedMaintenanceByID", context1, uUID)}
+}
+
+func (_c *MockMaintenanceStore_GetPlannedMaintenanceByID_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockMaintenanceStore_GetPlannedMaintenanceByID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 valuer.UUID
+		if args[1] != nil {
+			arg1 = args[1].(valuer.UUID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMaintenanceStore_GetPlannedMaintenanceByID_Call) Return(plannedMaintenance *alertmanagertypes.PlannedMaintenance, err error) *MockMaintenanceStore_GetPlannedMaintenanceByID_Call {
+	_c.Call.Return(plannedMaintenance, err)
+	return _c
+}
+
+func (_c *MockMaintenanceStore_GetPlannedMaintenanceByID_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (*alertmanagertypes.PlannedMaintenance, error)) *MockMaintenanceStore_GetPlannedMaintenanceByID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListPlannedMaintenance provides a mock function for the type MockMaintenanceStore
+func (_mock *MockMaintenanceStore) ListPlannedMaintenance(context1 context.Context, s string) ([]*alertmanagertypes.PlannedMaintenance, error) {
+	ret := _mock.Called(context1, s)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListPlannedMaintenance")
+	}
+
+	var r0 []*alertmanagertypes.PlannedMaintenance
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*alertmanagertypes.PlannedMaintenance, error)); ok {
+		return returnFunc(context1, s)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*alertmanagertypes.PlannedMaintenance); ok {
+		r0 = returnFunc(context1, s)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*alertmanagertypes.PlannedMaintenance)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = returnFunc(context1, s)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockMaintenanceStore_ListPlannedMaintenance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPlannedMaintenance'
+type MockMaintenanceStore_ListPlannedMaintenance_Call struct {
+	*mock.Call
+}
+
+// ListPlannedMaintenance is a helper method to define mock.On call
+//   - context1 context.Context
+//   - s string
+func (_e *MockMaintenanceStore_Expecter) ListPlannedMaintenance(context1 interface{}, s interface{}) *MockMaintenanceStore_ListPlannedMaintenance_Call {
+	return &MockMaintenanceStore_ListPlannedMaintenance_Call{Call: _e.mock.On("ListPlannedMaintenance", context1, s)}
+}
+
+func (_c *MockMaintenanceStore_ListPlannedMaintenance_Call) Run(run func(context1 context.Context, s string)) *MockMaintenanceStore_ListPlannedMaintenance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMaintenanceStore_ListPlannedMaintenance_Call) Return(plannedMaintenances []*alertmanagertypes.PlannedMaintenance, err error) *MockMaintenanceStore_ListPlannedMaintenance_Call {
+	_c.Call.Return(plannedMaintenances, err)
+	return _c
+}
+
+func (_c *MockMaintenanceStore_ListPlannedMaintenance_Call) RunAndReturn(run func(context1 context.Context, s string) ([]*alertmanagertypes.PlannedMaintenance, error)) *MockMaintenanceStore_ListPlannedMaintenance_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdatePlannedMaintenance provides a mock function for the type MockMaintenanceStore
+func (_mock *MockMaintenanceStore) UpdatePlannedMaintenance(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance, uUID valuer.UUID) error {
+	ret := _mock.Called(context1, postablePlannedMaintenance, uUID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdatePlannedMaintenance")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostablePlannedMaintenance, valuer.UUID) error); ok {
+		r0 = returnFunc(context1, postablePlannedMaintenance, uUID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockMaintenanceStore_UpdatePlannedMaintenance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePlannedMaintenance'
+type MockMaintenanceStore_UpdatePlannedMaintenance_Call struct {
+	*mock.Call
+}
+
+// UpdatePlannedMaintenance is a helper method to define mock.On call
+//   - context1 context.Context
+//   - postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance
+//   - uUID valuer.UUID
+func (_e *MockMaintenanceStore_Expecter) UpdatePlannedMaintenance(context1 interface{}, postablePlannedMaintenance interface{}, uUID interface{}) *MockMaintenanceStore_UpdatePlannedMaintenance_Call {
+	return &MockMaintenanceStore_UpdatePlannedMaintenance_Call{Call: _e.mock.On("UpdatePlannedMaintenance", context1, postablePlannedMaintenance, uUID)}
+}
+
+func (_c *MockMaintenanceStore_UpdatePlannedMaintenance_Call) Run(run func(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance, uUID valuer.UUID)) *MockMaintenanceStore_UpdatePlannedMaintenance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *alertmanagertypes.PostablePlannedMaintenance
+		if args[1] != nil {
+			arg1 = args[1].(*alertmanagertypes.PostablePlannedMaintenance)
+		}
+		var arg2 valuer.UUID
+		if args[2] != nil {
+			arg2 = args[2].(valuer.UUID)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *MockMaintenanceStore_UpdatePlannedMaintenance_Call) Return(err error) *MockMaintenanceStore_UpdatePlannedMaintenance_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockMaintenanceStore_UpdatePlannedMaintenance_Call) RunAndReturn(run func(context1 context.Context, postablePlannedMaintenance *alertmanagertypes.PostablePlannedMaintenance, uUID valuer.UUID) error) *MockMaintenanceStore_UpdatePlannedMaintenance_Call {
+	_c.Call.Return(run)
+	return _c
+}

pkg/types/alertmanagertypes/maintenance.go

@@ -1,4 +1,4 @@
-package ruletypes
+package alertmanagertypes
 
 import (
 	"context"

pkg/types/alertmanagertypes/maintenance_test.go

@@ -1,4 +1,4 @@
-package ruletypes
+package alertmanagertypes
 
 import (
 	"testing"
@@ -633,7 +633,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					// These fixed fields should be ignored when Recurrence is set.
-					StartTime: time.Date(2026, 4, 1, 10, 0, 0, 0, time.UTC),
+					StartTime: time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC),
 					EndTime:   time.Date(2026, 4, 30, 18, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
 						StartTime:  time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC), // daily at 14:00
@@ -642,8 +642,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 					},
 				},
 			},
-			// 11:00 is inside the fixed range but outside the daily 14:00-16:00 window.
-			// Before the fix this returned true (bug); after fix it returns false.
+			// 2026-04-15 11:00 is inside the fixed range but outside the daily 14:00-16:00 window.
 			ts:   time.Date(2026, 4, 15, 11, 0, 0, 0, time.UTC),
 			skip: false,
 		},
@@ -652,16 +651,17 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
 					Timezone:  "UTC",
-					StartTime: time.Date(2026, 4, 1, 10, 0, 0, 0, time.UTC),
+					StartTime: time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC),
 					EndTime:   time.Date(2026, 4, 30, 18, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
 						StartTime:  time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC),
+						EndTime:    timePtr(time.Date(2026, 4, 30, 18, 0, 0, 0, time.UTC)),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
 				},
 			},
-			// 15:00 is inside the daily 14:00-16:00 window — should skip.
+			// 15:00 is inside the daily 14:00-16:00 window. Should skip.
 			ts:   time.Date(2026, 4, 15, 15, 0, 0, 0, time.UTC),
 			skip: true,
 		},

pkg/types/alertmanagertypes/marker.go

@@ -5,8 +5,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-type MemMarker = types.MemMarker
-
-func NewMarker(r prometheus.Registerer) *MemMarker {
+func NewMarker(r prometheus.Registerer) *types.MemMarker {
 	return types.NewMarker(r)
 }

pkg/types/alertmanagertypes/recurrence.go

@@ -0,0 +1,92 @@
+package alertmanagertypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"reflect"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type RepeatType struct {
+	valuer.String
+}
+
+var (
+	RepeatTypeDaily   = RepeatType{valuer.NewString("daily")}
+	RepeatTypeWeekly  = RepeatType{valuer.NewString("weekly")}
+	RepeatTypeMonthly = RepeatType{valuer.NewString("monthly")}
+)
+
+// Enum implements jsonschema.Enum; returns the acceptable values for RepeatType.
+func (RepeatType) Enum() []any {
+	return []any{
+		RepeatTypeDaily,
+		RepeatTypeWeekly,
+		RepeatTypeMonthly,
+	}
+}
+
+type RepeatOn struct {
+	valuer.String
+}
+
+var (
+	RepeatOnSunday    = RepeatOn{valuer.NewString("sunday")}
+	RepeatOnMonday    = RepeatOn{valuer.NewString("monday")}
+	RepeatOnTuesday   = RepeatOn{valuer.NewString("tuesday")}
+	RepeatOnWednesday = RepeatOn{valuer.NewString("wednesday")}
+	RepeatOnThursday  = RepeatOn{valuer.NewString("thursday")}
+	RepeatOnFriday    = RepeatOn{valuer.NewString("friday")}
+	RepeatOnSaturday  = RepeatOn{valuer.NewString("saturday")}
+)
+
+// Enum implements jsonschema.Enum; returns the acceptable values for RepeatOn.
+func (RepeatOn) Enum() []any {
+	return []any{
+		RepeatOnSunday,
+		RepeatOnMonday,
+		RepeatOnTuesday,
+		RepeatOnWednesday,
+		RepeatOnThursday,
+		RepeatOnFriday,
+		RepeatOnSaturday,
+	}
+}
+
+var RepeatOnAllMap = map[RepeatOn]time.Weekday{
+	RepeatOnSunday:    time.Sunday,
+	RepeatOnMonday:    time.Monday,
+	RepeatOnTuesday:   time.Tuesday,
+	RepeatOnWednesday: time.Wednesday,
+	RepeatOnThursday:  time.Thursday,
+	RepeatOnFriday:    time.Friday,
+	RepeatOnSaturday:  time.Saturday,
+}
+
+type Recurrence struct {
+	StartTime  time.Time           `json:"startTime" required:"true"`
+	EndTime    *time.Time          `json:"endTime,omitempty"`
+	Duration   valuer.TextDuration `json:"duration" required:"true"`
+	RepeatType RepeatType          `json:"repeatType" required:"true"`
+	RepeatOn   []RepeatOn          `json:"repeatOn"`
+}
+
+func (r *Recurrence) Scan(src interface{}) error {
+	switch data := src.(type) {
+	case []byte:
+		return json.Unmarshal(data, r)
+	case string:
+		return json.Unmarshal([]byte(data), r)
+	case nil:
+		return nil
+	default:
+		return errors.Newf(errors.TypeInternal, errors.CodeInternal, "recurrence: (unsupported \"%s\")", reflect.TypeOf(data).String())
+	}
+}
+
+func (r *Recurrence) Value() (driver.Value, error) {
+	return json.Marshal(r)
+}

pkg/types/alertmanagertypes/schedule.go

@@ -1,4 +1,4 @@
-package ruletypes
+package alertmanagertypes
 
 import (
 	"database/sql/driver"
@@ -7,88 +7,30 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-type RepeatType struct {
-	valuer.String
+type Schedule struct {
+	Timezone   string      `json:"timezone" required:"true"`
+	StartTime  time.Time   `json:"startTime,omitempty"`
+	EndTime    time.Time   `json:"endTime,omitzero"`
+	Recurrence *Recurrence `json:"recurrence"`
 }
 
-var (
-	RepeatTypeDaily   = RepeatType{valuer.NewString("daily")}
-	RepeatTypeWeekly  = RepeatType{valuer.NewString("weekly")}
-	RepeatTypeMonthly = RepeatType{valuer.NewString("monthly")}
-)
-
-// Enum implements jsonschema.Enum; returns the acceptable values for RepeatType.
-func (RepeatType) Enum() []any {
-	return []any{
-		RepeatTypeDaily,
-		RepeatTypeWeekly,
-		RepeatTypeMonthly,
-	}
-}
-
-type RepeatOn struct {
-	valuer.String
-}
-
-var (
-	RepeatOnSunday    = RepeatOn{valuer.NewString("sunday")}
-	RepeatOnMonday    = RepeatOn{valuer.NewString("monday")}
-	RepeatOnTuesday   = RepeatOn{valuer.NewString("tuesday")}
-	RepeatOnWednesday = RepeatOn{valuer.NewString("wednesday")}
-	RepeatOnThursday  = RepeatOn{valuer.NewString("thursday")}
-	RepeatOnFriday    = RepeatOn{valuer.NewString("friday")}
-	RepeatOnSaturday  = RepeatOn{valuer.NewString("saturday")}
-)
-
-// Enum implements jsonschema.Enum; returns the acceptable values for RepeatOn.
-func (RepeatOn) Enum() []any {
-	return []any{
-		RepeatOnSunday,
-		RepeatOnMonday,
-		RepeatOnTuesday,
-		RepeatOnWednesday,
-		RepeatOnThursday,
-		RepeatOnFriday,
-		RepeatOnSaturday,
-	}
-}
-
-var RepeatOnAllMap = map[RepeatOn]time.Weekday{
-	RepeatOnSunday:    time.Sunday,
-	RepeatOnMonday:    time.Monday,
-	RepeatOnTuesday:   time.Tuesday,
-	RepeatOnWednesday: time.Wednesday,
-	RepeatOnThursday:  time.Thursday,
-	RepeatOnFriday:    time.Friday,
-	RepeatOnSaturday:  time.Saturday,
-}
-
-type Recurrence struct {
-	StartTime  time.Time           `json:"startTime" required:"true"`
-	EndTime    *time.Time          `json:"endTime,omitempty"`
-	Duration   valuer.TextDuration `json:"duration" required:"true"`
-	RepeatType RepeatType          `json:"repeatType" required:"true"`
-	RepeatOn   []RepeatOn          `json:"repeatOn"`
-}
-
-func (r *Recurrence) Scan(src interface{}) error {
+func (s *Schedule) Scan(src interface{}) error {
 	switch data := src.(type) {
 	case []byte:
-		return json.Unmarshal(data, r)
+		return json.Unmarshal(data, s)
 	case string:
-		return json.Unmarshal([]byte(data), r)
+		return json.Unmarshal([]byte(data), s)
 	case nil:
 		return nil
 	default:
-		return errors.Newf(errors.TypeInternal, errors.CodeInternal, "recurrence: (unsupported \"%s\")", reflect.TypeOf(data).String())
+		return errors.Newf(errors.TypeInternal, errors.CodeInternal, "schedule: (unsupported \"%s\")", reflect.TypeOf(data).String())
 	}
 }
 
-func (r *Recurrence) Value() (driver.Value, error) {
-	return json.Marshal(r)
+func (s *Schedule) Value() (driver.Value, error) {
+	return json.Marshal(s)
 }
 
 func (s Schedule) MarshalJSON() ([]byte, error) {
@@ -124,13 +66,13 @@ func (s Schedule) MarshalJSON() ([]byte, error) {
 
 	return json.Marshal(&struct {
 		Timezone   string      `json:"timezone"`
-		StartTime  string      `json:"startTime"`
-		EndTime    string      `json:"endTime"`
+		StartTime  time.Time   `json:"startTime"`
+		EndTime    time.Time   `json:"endTime,omitzero"`
 		Recurrence *Recurrence `json:"recurrence,omitempty"`
 	}{
 		Timezone:   s.Timezone,
-		StartTime:  startTime.Format(time.RFC3339),
-		EndTime:    endTime.Format(time.RFC3339),
+		StartTime:  startTime,
+		EndTime:    endTime,
 		Recurrence: recurrence,
 	})
 }

pkg/types/ruletypes/schedule.go

@@ -1,34 +0,0 @@
-package ruletypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"reflect"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-type Schedule struct {
-	Timezone   string      `json:"timezone" required:"true"`
-	StartTime  time.Time   `json:"startTime,omitempty"`
-	EndTime    time.Time   `json:"endTime,omitempty"`
-	Recurrence *Recurrence `json:"recurrence"`
-}
-
-func (s *Schedule) Scan(src interface{}) error {
-	switch data := src.(type) {
-	case []byte:
-		return json.Unmarshal(data, s)
-	case string:
-		return json.Unmarshal([]byte(data), s)
-	case nil:
-		return nil
-	default:
-		return errors.Newf(errors.TypeInternal, errors.CodeInternal, "schedule: (unsupported \"%s\")", reflect.TypeOf(data).String())
-	}
-}
-
-func (s *Schedule) Value() (driver.Value, error) {
-	return json.Marshal(s)
-}