refactor(ruler): rename downtime_schedules tag to downtimeschedules

Mark CreateRule, EditRule, PatchRule, TestNotification, and DeleteRule
with TODOs to accept typed params instead of raw JSON strings. Requires
changing the storage model since the manager stores raw JSON as Data.

cmd/community/server.go

@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/SigNoz/signoz/cmd"
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authn"
@@ -14,6 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz/openfgaauthz"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaschema"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaserver"
+	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
@@ -26,14 +28,20 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
+	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/SigNoz/signoz/pkg/zeus/noopzeus"
@@ -107,6 +115,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(_ sqlstore.SQLStore, _ global.Global, _ zeus.Zeus, _ gateway.Gateway, _ licensing.Licensing, _ serviceaccount.Module, _ cloudintegration.Config) (cloudintegration.Module, error) {
 			return implcloudintegration.NewModule(), nil
 		},
+		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
+			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, nil, nil))
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))

cmd/enterprise/server.go

@@ -22,14 +22,17 @@ import (
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
 	eequerier "github.com/SigNoz/signoz/ee/querier"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
+	eerules "github.com/SigNoz/signoz/ee/query-service/rules"
 	"github.com/SigNoz/signoz/ee/sqlschema/postgressqlschema"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
 	enterprisezeus "github.com/SigNoz/signoz/ee/zeus"
 	"github.com/SigNoz/signoz/ee/zeus/httpzeus"
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authn"
 	"github.com/SigNoz/signoz/pkg/authz"
+	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
@@ -40,15 +43,21 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
+	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstorehook"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
@@ -166,6 +175,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return implcloudintegration.NewModule(pkgcloudintegration.NewStore(sqlStore), global, zeus, gateway, licensing, serviceAccount, cloudProvidersMap, config)
 		},
+		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
+			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, eerules.PrepareTaskFunc, eerules.TestNotification))
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))

docs/api/openapi.yml

@@ -3618,6 +3618,20 @@ components:
       - start
       - end
       type: object
+    RuletypesAlertCompositeQuery:
+      properties:
+        panelType:
+          type: string
+        queries:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelope'
+          nullable: true
+          type: array
+        queryType:
+          type: string
+        unit:
+          type: string
+      type: object
     RuletypesAlertState:
       enum:
       - inactive
@@ -3627,6 +3641,271 @@ components:
       - nodata
       - disabled
       type: string
+    RuletypesCompareOperator:
+      enum:
+      - above
+      - below
+      - equal
+      - not_equal
+      - outside_bounds
+      type: string
+    RuletypesEvaluationEnvelope:
+      properties:
+        kind:
+          type: string
+        spec: {}
+      type: object
+    RuletypesGettablePlannedMaintenance:
+      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:
+          type: string
+        name:
+          type: string
+        schedule:
+          $ref: '#/components/schemas/RuletypesSchedule'
+        status:
+          type: string
+        updatedAt:
+          format: date-time
+          type: string
+        updatedBy:
+          type: string
+      type: object
+    RuletypesGettableRule:
+      properties:
+        alert:
+          type: string
+        alertType:
+          type: string
+        annotations:
+          additionalProperties:
+            type: string
+          type: object
+        condition:
+          $ref: '#/components/schemas/RuletypesRuleCondition'
+        createAt:
+          format: date-time
+          nullable: true
+          type: string
+        createBy:
+          nullable: true
+          type: string
+        description:
+          type: string
+        disabled:
+          type: boolean
+        evalWindow:
+          type: string
+        evaluation:
+          $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
+        frequency:
+          type: string
+        id:
+          type: string
+        labels:
+          additionalProperties:
+            type: string
+          type: object
+        notificationSettings:
+          $ref: '#/components/schemas/RuletypesNotificationSettings'
+        preferredChannels:
+          items:
+            type: string
+          type: array
+        ruleType:
+          $ref: '#/components/schemas/RuletypesRuleType'
+        schemaVersion:
+          type: string
+        source:
+          type: string
+        state:
+          $ref: '#/components/schemas/RuletypesAlertState'
+        updateAt:
+          format: date-time
+          nullable: true
+          type: string
+        updateBy:
+          nullable: true
+          type: string
+        version:
+          type: string
+      type: object
+    RuletypesGettableRules:
+      properties:
+        rules:
+          items:
+            $ref: '#/components/schemas/RuletypesGettableRule'
+          nullable: true
+          type: array
+      type: object
+    RuletypesMatchType:
+      enum:
+      - at_least_once
+      - all_the_times
+      - on_average
+      - in_total
+      - last
+      type: string
+    RuletypesNotificationSettings:
+      properties:
+        groupBy:
+          items:
+            type: string
+          type: array
+        newGroupEvalDelay:
+          type: string
+        renotify:
+          $ref: '#/components/schemas/RuletypesRenotify'
+        usePolicy:
+          type: boolean
+      type: object
+    RuletypesPostableRule:
+      properties:
+        alert:
+          type: string
+        alertType:
+          type: string
+        annotations:
+          additionalProperties:
+            type: string
+          type: object
+        condition:
+          $ref: '#/components/schemas/RuletypesRuleCondition'
+        description:
+          type: string
+        disabled:
+          type: boolean
+        evalWindow:
+          type: string
+        evaluation:
+          $ref: '#/components/schemas/RuletypesEvaluationEnvelope'
+        frequency:
+          type: string
+        labels:
+          additionalProperties:
+            type: string
+          type: object
+        notificationSettings:
+          $ref: '#/components/schemas/RuletypesNotificationSettings'
+        preferredChannels:
+          items:
+            type: string
+          type: array
+        ruleType:
+          $ref: '#/components/schemas/RuletypesRuleType'
+        schemaVersion:
+          type: string
+        source:
+          type: string
+        version:
+          type: string
+      type: object
+    RuletypesRecurrence:
+      properties:
+        duration:
+          type: string
+        endTime:
+          format: date-time
+          nullable: true
+          type: string
+        repeatOn:
+          items:
+            type: string
+          nullable: true
+          type: array
+        repeatType:
+          type: string
+        startTime:
+          format: date-time
+          type: string
+      type: object
+    RuletypesRenotify:
+      properties:
+        alertStates:
+          items:
+            $ref: '#/components/schemas/RuletypesAlertState'
+          type: array
+        enabled:
+          type: boolean
+        interval:
+          type: string
+      type: object
+    RuletypesRuleCondition:
+      properties:
+        absentFor:
+          minimum: 0
+          type: integer
+        alertOnAbsent:
+          type: boolean
+        algorithm:
+          type: string
+        compositeQuery:
+          $ref: '#/components/schemas/RuletypesAlertCompositeQuery'
+        matchType:
+          $ref: '#/components/schemas/RuletypesMatchType'
+        op:
+          $ref: '#/components/schemas/RuletypesCompareOperator'
+        requireMinPoints:
+          type: boolean
+        requiredNumPoints:
+          type: integer
+        seasonality:
+          $ref: '#/components/schemas/RuletypesSeasonality'
+        selectedQueryName:
+          type: string
+        target:
+          nullable: true
+          type: number
+        targetUnit:
+          type: string
+        thresholds:
+          $ref: '#/components/schemas/RuletypesRuleThresholdData'
+      type: object
+    RuletypesRuleThresholdData:
+      properties:
+        kind:
+          type: string
+        spec: {}
+      type: object
+    RuletypesRuleType:
+      enum:
+      - threshold_rule
+      - 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
+      type: object
+    RuletypesSeasonality:
+      enum:
+      - hourly
+      - daily
+      - weekly
+      type: string
     ServiceaccounttypesGettableFactorAPIKey:
       properties:
         createdAt:
@@ -5818,6 +6097,257 @@ paths:
       summary: Update auth domain
       tags:
       - authdomains
+  /api/v1/downtime_schedules:
+    get:
+      deprecated: false
+      description: This endpoint lists all planned maintenance / downtime schedules
+      operationId: ListDowntimeSchedules
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    items:
+                      $ref: '#/components/schemas/RuletypesGettablePlannedMaintenance'
+                    type: array
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List downtime schedules
+      tags:
+      - downtimeschedules
+    post:
+      deprecated: false
+      description: This endpoint creates a new planned maintenance / downtime schedule
+      operationId: CreateDowntimeSchedule
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesGettablePlannedMaintenance'
+      responses:
+        "200":
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Create downtime schedule
+      tags:
+      - downtimeschedules
+  /api/v1/downtime_schedules/{id}:
+    delete:
+      deprecated: false
+      description: This endpoint deletes a downtime schedule by ID
+      operationId: DeleteDowntimeScheduleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Delete downtime schedule
+      tags:
+      - downtimeschedules
+    get:
+      deprecated: false
+      description: This endpoint returns a downtime schedule by ID
+      operationId: GetDowntimeScheduleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettablePlannedMaintenance'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Get downtime schedule by ID
+      tags:
+      - downtimeschedules
+    put:
+      deprecated: false
+      description: This endpoint updates a downtime schedule by ID
+      operationId: UpdateDowntimeScheduleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesGettablePlannedMaintenance'
+      responses:
+        "204":
+          description: No Content
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Update downtime schedule
+      tags:
+      - downtimeschedules
   /api/v1/export_raw_data:
     post:
       deprecated: false
@@ -7415,6 +7945,385 @@ paths:
       summary: Update route policy
       tags:
       - routepolicies
+  /api/v1/rules:
+    get:
+      deprecated: false
+      description: This endpoint lists all alert rules with their current evaluation
+        state
+      operationId: ListRules
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRules'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List alert rules
+      tags:
+      - rules
+    post:
+      deprecated: false
+      description: This endpoint creates a new alert rule
+      operationId: CreateRule
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRule'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Create alert rule
+      tags:
+      - rules
+  /api/v1/rules/{id}:
+    delete:
+      deprecated: false
+      description: This endpoint deletes an alert rule by ID
+      operationId: DeleteRuleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Delete alert rule
+      tags:
+      - rules
+    get:
+      deprecated: false
+      description: This endpoint returns an alert rule by ID
+      operationId: GetRuleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Get alert rule by ID
+      tags:
+      - rules
+    patch:
+      deprecated: false
+      description: This endpoint applies a partial update to an alert rule by ID
+      operationId: PatchRuleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRule'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Patch alert rule
+      tags:
+      - rules
+    put:
+      deprecated: false
+      description: This endpoint updates an alert rule by ID
+      operationId: UpdateRuleByID
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRule'
+      responses:
+        "204":
+          description: No Content
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Update alert rule
+      tags:
+      - rules
+  /api/v1/rules/test:
+    post:
+      deprecated: false
+      description: This endpoint fires a test notification for the given rule definition
+      operationId: TestRule
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRule'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                type: string
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Test alert rule
+      tags:
+      - rules
   /api/v1/service_accounts:
     get:
       deprecated: false
@@ -8217,6 +9126,55 @@ paths:
       summary: Test notification channel (deprecated)
       tags:
       - channels
+  /api/v1/testRule:
+    post:
+      deprecated: true
+      description: 'Deprecated: use /api/v1/rules/test instead'
+      operationId: TestRuleDeprecated
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRule'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                type: string
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - EDITOR
+      - tokenizer:
+        - EDITOR
+      summary: Test alert rule (deprecated)
+      tags:
+      - rules
   /api/v1/user:
     get:
       deprecated: false

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

@@ -14,7 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	rules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/version"
@@ -23,7 +22,6 @@ import (
 
 type APIHandlerOptions struct {
 	DataConnector                 interfaces.Reader
-	RulesManager                  *rules.Manager
 	UsageManager                  *usage.Manager
 	IntegrationsController        *integrations.Controller
 	CloudIntegrationsController   *cloudintegrations.Controller
@@ -43,7 +41,6 @@ type APIHandler struct {
 func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.Config) (*APIHandler, error) {
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
-		RuleManager:                   opts.RulesManager,
 		IntegrationsController:        opts.IntegrationsController,
 		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
@@ -64,10 +61,6 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.
 	return ah, nil
 }
 
-func (ah *APIHandler) RM() *rules.Manager {
-	return ah.opts.RulesManager
-}
-
 func (ah *APIHandler) UM() *usage.Manager {
 	return ah.opts.UsageManager
 }

ee/query-service/app/server.go

@@ -12,10 +12,6 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 
 	"github.com/gorilla/handlers"
 
@@ -23,18 +19,10 @@ import (
 	"github.com/soheilhy/cmux"
 
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
-	"github.com/SigNoz/signoz/ee/query-service/rules"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/signoz"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/web"
 
 	"log/slog"
@@ -49,7 +37,6 @@ import (
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
-	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
 
@@ -57,7 +44,6 @@ import (
 type Server struct {
 	config      signoz.Config
 	signoz      *signoz.SigNoz
-	ruleManager *baserules.Manager
 
 	// public http router
 	httpConn     net.Listener
@@ -97,24 +83,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		nil,
 	)
 
-	rm, err := makeRulesManager(
-		signoz.Cache,
-		signoz.Alertmanager,
-		signoz.SQLStore,
-		signoz.TelemetryStore,
-		signoz.TelemetryMetadataStore,
-		signoz.Prometheus,
-		signoz.Modules.OrgGetter,
-		signoz.Modules.RuleStateHistory,
-		signoz.Querier,
-		signoz.Instrumentation.ToProviderSettings(),
-		signoz.QueryParser,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
 	// initiate opamp
 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)
 
@@ -163,7 +131,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	apiOpts := api.APIHandlerOptions{
 		DataConnector:                 reader,
-		RulesManager:                  rm,
 		UsageManager:                  usageManager,
 		IntegrationsController:        integrationsController,
 		CloudIntegrationsController:   cloudIntegrationsController,
@@ -180,8 +147,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	s := &Server{
 		config:             config,
-		signoz:             signoz,
-		ruleManager:        rm,
+		signoz:       signoz,
 		httpHostPort:       baseconst.HTTPHostPort,
 		unavailableChannel: make(chan healthcheck.Status),
 		usageManager:       usageManager,
@@ -288,8 +254,6 @@ func (s *Server) initListeners() error {
 
 // Start listening on http and private http port concurrently
 func (s *Server) Start(ctx context.Context) error {
-	s.ruleManager.Start(ctx)
-
 	err := s.initListeners()
 	if err != nil {
 		return err
@@ -333,47 +297,9 @@ func (s *Server) Stop(ctx context.Context) error {
 
 	s.opampServer.Stop()
 
-	if s.ruleManager != nil {
-		s.ruleManager.Stop(ctx)
-	}
-
 	// stop usage manager
 	s.usageManager.Stop(ctx)
 
 	return nil
 }
 
-func makeRulesManager(cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, ruleStateHistoryModule rulestatehistory.Module, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
-	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
-	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
-	// create manager opts
-	managerOpts := &baserules.ManagerOptions{
-		TelemetryStore:         telemetryStore,
-		MetadataStore:          metadataStore,
-		Prometheus:             prometheus,
-		Context:                context.Background(),
-		Querier:                querier,
-		Logger:                 providerSettings.Logger,
-		Cache:                  cache,
-		EvalDelay:              baseconst.GetEvalDelay(),
-		PrepareTaskFunc:        rules.PrepareTaskFunc,
-		PrepareTestRuleFunc:    rules.TestNotification,
-		Alertmanager:           alertmanager,
-		OrgGetter:              orgGetter,
-		RuleStore:              ruleStore,
-		MaintenanceStore:       maintenanceStore,
-		SQLStore:               sqlstore,
-		QueryParser:            queryParser,
-		RuleStateHistoryModule: ruleStateHistoryModule,
-	}
-
-	// create Manager
-	manager, err := baserules.NewManager(managerOpts)
-	if err != nil {
-		return nil, fmt.Errorf("rule manager error: %v", err)
-	}
-
-	slog.Info("rules manager is ready")
-
-	return manager, nil
-}

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

@@ -0,0 +1,480 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseMutationOptions,
+	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useMutation, useQuery } from 'react-query';
+
+import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type {
+	DeleteDowntimeScheduleByIDPathParameters,
+	GetDowntimeScheduleByID200,
+	GetDowntimeScheduleByIDPathParameters,
+	ListDowntimeSchedules200,
+	RenderErrorResponseDTO,
+	RuletypesGettablePlannedMaintenanceDTO,
+	UpdateDowntimeScheduleByIDPathParameters,
+} from '../sigNoz.schemas';
+
+/**
+ * This endpoint lists all planned maintenance / downtime schedules
+ * @summary List downtime schedules
+ */
+export const listDowntimeSchedules = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<ListDowntimeSchedules200>({
+		url: `/api/v1/downtime_schedules`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListDowntimeSchedulesQueryKey = () => {
+	return [`/api/v1/downtime_schedules`] as const;
+};
+
+export const getListDowntimeSchedulesQueryOptions = <
+	TData = Awaited<ReturnType<typeof listDowntimeSchedules>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listDowntimeSchedules>>,
+		TError,
+		TData
+	>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListDowntimeSchedulesQueryKey();
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof listDowntimeSchedules>>
+	> = ({ signal }) => listDowntimeSchedules(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listDowntimeSchedules>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListDowntimeSchedulesQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listDowntimeSchedules>>
+>;
+export type ListDowntimeSchedulesQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List downtime schedules
+ */
+
+export function useListDowntimeSchedules<
+	TData = Awaited<ReturnType<typeof listDowntimeSchedules>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listDowntimeSchedules>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListDowntimeSchedulesQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List downtime schedules
+ */
+export const invalidateListDowntimeSchedules = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListDowntimeSchedulesQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint creates a new planned maintenance / downtime schedule
+ * @summary Create downtime schedule
+ */
+export const createDowntimeSchedule = (
+	ruletypesGettablePlannedMaintenanceDTO: BodyType<RuletypesGettablePlannedMaintenanceDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/downtime_schedules`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesGettablePlannedMaintenanceDTO,
+		signal,
+	});
+};
+
+export const getCreateDowntimeScheduleMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createDowntimeSchedule>>,
+		TError,
+		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createDowntimeSchedule>>,
+	TError,
+	{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
+	TContext
+> => {
+	const mutationKey = ['createDowntimeSchedule'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof createDowntimeSchedule>>,
+		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createDowntimeSchedule(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateDowntimeScheduleMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createDowntimeSchedule>>
+>;
+export type CreateDowntimeScheduleMutationBody = BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+export type CreateDowntimeScheduleMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create downtime schedule
+ */
+export const useCreateDowntimeSchedule = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createDowntimeSchedule>>,
+		TError,
+		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createDowntimeSchedule>>,
+	TError,
+	{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateDowntimeScheduleMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint deletes a downtime schedule by ID
+ * @summary Delete downtime schedule
+ */
+export const deleteDowntimeScheduleByID = ({
+	id,
+}: DeleteDowntimeScheduleByIDPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/downtime_schedules/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteDowntimeScheduleByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
+		TError,
+		{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
+	TError,
+	{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteDowntimeScheduleByID'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
+		{ pathParams: DeleteDowntimeScheduleByIDPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteDowntimeScheduleByID(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteDowntimeScheduleByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>
+>;
+
+export type DeleteDowntimeScheduleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete downtime schedule
+ */
+export const useDeleteDowntimeScheduleByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
+		TError,
+		{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
+	TError,
+	{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteDowntimeScheduleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns a downtime schedule by ID
+ * @summary Get downtime schedule by ID
+ */
+export const getDowntimeScheduleByID = (
+	{ id }: GetDowntimeScheduleByIDPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetDowntimeScheduleByID200>({
+		url: `/api/v1/downtime_schedules/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetDowntimeScheduleByIDQueryKey = ({
+	id,
+}: GetDowntimeScheduleByIDPathParameters) => {
+	return [`/api/v1/downtime_schedules/${id}`] as const;
+};
+
+export const getGetDowntimeScheduleByIDQueryOptions = <
+	TData = Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetDowntimeScheduleByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getGetDowntimeScheduleByIDQueryKey({ id });
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof getDowntimeScheduleByID>>
+	> = ({ signal }) => getDowntimeScheduleByID({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetDowntimeScheduleByIDQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getDowntimeScheduleByID>>
+>;
+export type GetDowntimeScheduleByIDQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get downtime schedule by ID
+ */
+
+export function useGetDowntimeScheduleByID<
+	TData = Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetDowntimeScheduleByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetDowntimeScheduleByIDQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get downtime schedule by ID
+ */
+export const invalidateGetDowntimeScheduleByID = async (
+	queryClient: QueryClient,
+	{ id }: GetDowntimeScheduleByIDPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetDowntimeScheduleByIDQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint updates a downtime schedule by ID
+ * @summary Update downtime schedule
+ */
+export const updateDowntimeScheduleByID = (
+	{ id }: UpdateDowntimeScheduleByIDPathParameters,
+	ruletypesGettablePlannedMaintenanceDTO: BodyType<RuletypesGettablePlannedMaintenanceDTO>,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/downtime_schedules/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesGettablePlannedMaintenanceDTO,
+	});
+};
+
+export const getUpdateDowntimeScheduleByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
+		TError,
+		{
+			pathParams: UpdateDowntimeScheduleByIDPathParameters;
+			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
+	TError,
+	{
+		pathParams: UpdateDowntimeScheduleByIDPathParameters;
+		data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateDowntimeScheduleByID'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
+		{
+			pathParams: UpdateDowntimeScheduleByIDPathParameters;
+			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateDowntimeScheduleByID(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateDowntimeScheduleByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>
+>;
+export type UpdateDowntimeScheduleByIDMutationBody = BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+export type UpdateDowntimeScheduleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update downtime schedule
+ */
+export const useUpdateDowntimeScheduleByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
+		TError,
+		{
+			pathParams: UpdateDowntimeScheduleByIDPathParameters;
+			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
+	TError,
+	{
+		pathParams: UpdateDowntimeScheduleByIDPathParameters;
+		data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateDowntimeScheduleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};

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

@@ -6,17 +6,24 @@
  */
 import type {
 	InvalidateOptions,
+	MutationFunction,
 	QueryClient,
 	QueryFunction,
 	QueryKey,
+	UseMutationOptions,
+	UseMutationResult,
 	UseQueryOptions,
 	UseQueryResult,
 } from 'react-query';
-import { useQuery } from 'react-query';
+import { useMutation, useQuery } from 'react-query';
 
-import type { ErrorType } from '../../../generatedAPIInstance';
+import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
+	CreateRule200,
+	DeleteRuleByIDPathParameters,
+	GetRuleByID200,
+	GetRuleByIDPathParameters,
 	GetRuleHistoryFilterKeys200,
 	GetRuleHistoryFilterKeysParams,
 	GetRuleHistoryFilterKeysPathParameters,
@@ -35,9 +42,715 @@ import type {
 	GetRuleHistoryTopContributors200,
 	GetRuleHistoryTopContributorsParams,
 	GetRuleHistoryTopContributorsPathParameters,
+	ListRules200,
+	PatchRuleByID200,
+	PatchRuleByIDPathParameters,
 	RenderErrorResponseDTO,
+	RuletypesPostableRuleDTO,
+	UpdateRuleByIDPathParameters,
 } from '../sigNoz.schemas';
 
+/**
+ * This endpoint lists all alert rules with their current evaluation state
+ * @summary List alert rules
+ */
+export const listRules = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<ListRules200>({
+		url: `/api/v1/rules`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListRulesQueryKey = () => {
+	return [`/api/v1/rules`] as const;
+};
+
+export const getListRulesQueryOptions = <
+	TData = Awaited<ReturnType<typeof listRules>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof listRules>>, TError, TData>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListRulesQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof listRules>>> = ({
+		signal,
+	}) => listRules(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listRules>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListRulesQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listRules>>
+>;
+export type ListRulesQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List alert rules
+ */
+
+export function useListRules<
+	TData = Awaited<ReturnType<typeof listRules>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof listRules>>, TError, TData>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListRulesQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List alert rules
+ */
+export const invalidateListRules = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListRulesQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint creates a new alert rule
+ * @summary Create alert rule
+ */
+export const createRule = (
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateRule200>({
+		url: `/api/v1/rules`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleDTO,
+		signal,
+	});
+};
+
+export const getCreateRuleMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRule>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createRule>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationKey = ['createRule'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof createRule>>,
+		{ data: BodyType<RuletypesPostableRuleDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createRule(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateRuleMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createRule>>
+>;
+export type CreateRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
+export type CreateRuleMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create alert rule
+ */
+export const useCreateRule = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRule>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createRule>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateRuleMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint deletes an alert rule by ID
+ * @summary Delete alert rule
+ */
+export const deleteRuleByID = ({ id }: DeleteRuleByIDPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/rules/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteRuleByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRuleByID>>,
+		TError,
+		{ pathParams: DeleteRuleByIDPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteRuleByID>>,
+	TError,
+	{ pathParams: DeleteRuleByIDPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteRuleByID'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof deleteRuleByID>>,
+		{ pathParams: DeleteRuleByIDPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteRuleByID(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteRuleByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteRuleByID>>
+>;
+
+export type DeleteRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete alert rule
+ */
+export const useDeleteRuleByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRuleByID>>,
+		TError,
+		{ pathParams: DeleteRuleByIDPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteRuleByID>>,
+	TError,
+	{ pathParams: DeleteRuleByIDPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns an alert rule by ID
+ * @summary Get alert rule by ID
+ */
+export const getRuleByID = (
+	{ id }: GetRuleByIDPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetRuleByID200>({
+		url: `/api/v1/rules/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetRuleByIDQueryKey = ({ id }: GetRuleByIDPathParameters) => {
+	return [`/api/v1/rules/${id}`] as const;
+};
+
+export const getGetRuleByIDQueryOptions = <
+	TData = Awaited<ReturnType<typeof getRuleByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetRuleByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getRuleByID>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetRuleByIDQueryKey({ id });
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getRuleByID>>> = ({
+		signal,
+	}) => getRuleByID({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getRuleByID>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetRuleByIDQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getRuleByID>>
+>;
+export type GetRuleByIDQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get alert rule by ID
+ */
+
+export function useGetRuleByID<
+	TData = Awaited<ReturnType<typeof getRuleByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetRuleByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getRuleByID>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetRuleByIDQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get alert rule by ID
+ */
+export const invalidateGetRuleByID = async (
+	queryClient: QueryClient,
+	{ id }: GetRuleByIDPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetRuleByIDQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint applies a partial update to an alert rule by ID
+ * @summary Patch alert rule
+ */
+export const patchRuleByID = (
+	{ id }: PatchRuleByIDPathParameters,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
+) => {
+	return GeneratedAPIInstance<PatchRuleByID200>({
+		url: `/api/v1/rules/${id}`,
+		method: 'PATCH',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleDTO,
+	});
+};
+
+export const getPatchRuleByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof patchRuleByID>>,
+		TError,
+		{
+			pathParams: PatchRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof patchRuleByID>>,
+	TError,
+	{
+		pathParams: PatchRuleByIDPathParameters;
+		data: BodyType<RuletypesPostableRuleDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['patchRuleByID'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof patchRuleByID>>,
+		{
+			pathParams: PatchRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return patchRuleByID(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type PatchRuleByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof patchRuleByID>>
+>;
+export type PatchRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
+export type PatchRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Patch alert rule
+ */
+export const usePatchRuleByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof patchRuleByID>>,
+		TError,
+		{
+			pathParams: PatchRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof patchRuleByID>>,
+	TError,
+	{
+		pathParams: PatchRuleByIDPathParameters;
+		data: BodyType<RuletypesPostableRuleDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getPatchRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint updates an alert rule by ID
+ * @summary Update alert rule
+ */
+export const updateRuleByID = (
+	{ id }: UpdateRuleByIDPathParameters,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/rules/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleDTO,
+	});
+};
+
+export const getUpdateRuleByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRuleByID>>,
+		TError,
+		{
+			pathParams: UpdateRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateRuleByID>>,
+	TError,
+	{
+		pathParams: UpdateRuleByIDPathParameters;
+		data: BodyType<RuletypesPostableRuleDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateRuleByID'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof updateRuleByID>>,
+		{
+			pathParams: UpdateRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateRuleByID(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateRuleByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateRuleByID>>
+>;
+export type UpdateRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
+export type UpdateRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update alert rule
+ */
+export const useUpdateRuleByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRuleByID>>,
+		TError,
+		{
+			pathParams: UpdateRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateRuleByID>>,
+	TError,
+	{
+		pathParams: UpdateRuleByIDPathParameters;
+		data: BodyType<RuletypesPostableRuleDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint fires a test notification for the given rule definition
+ * @summary Test alert rule
+ */
+export const testRule = (
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v1/rules/test`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleDTO,
+		signal,
+	});
+};
+
+export const getTestRuleMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testRule>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof testRule>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationKey = ['testRule'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof testRule>>,
+		{ data: BodyType<RuletypesPostableRuleDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return testRule(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type TestRuleMutationResult = NonNullable<
+	Awaited<ReturnType<typeof testRule>>
+>;
+export type TestRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
+export type TestRuleMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Test alert rule
+ */
+export const useTestRule = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testRule>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof testRule>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationOptions = getTestRuleMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Deprecated: use /api/v1/rules/test instead
+ * @deprecated
+ * @summary Test alert rule (deprecated)
+ */
+export const testRuleDeprecated = (
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v1/testRule`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleDTO,
+		signal,
+	});
+};
+
+export const getTestRuleDeprecatedMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testRuleDeprecated>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof testRuleDeprecated>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationKey = ['testRuleDeprecated'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+		  'mutationKey' in options.mutation &&
+		  options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof testRuleDeprecated>>,
+		{ data: BodyType<RuletypesPostableRuleDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return testRuleDeprecated(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type TestRuleDeprecatedMutationResult = NonNullable<
+	Awaited<ReturnType<typeof testRuleDeprecated>>
+>;
+export type TestRuleDeprecatedMutationBody = BodyType<RuletypesPostableRuleDTO>;
+export type TestRuleDeprecatedMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @deprecated
+ * @summary Test alert rule (deprecated)
+ */
+export const useTestRuleDeprecated = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testRuleDeprecated>>,
+		TError,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof testRuleDeprecated>>,
+	TError,
+	{ data: BodyType<RuletypesPostableRuleDTO> },
+	TContext
+> => {
+	const mutationOptions = getTestRuleDeprecatedMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
 /**
  * Returns distinct label keys from rule history entries for the selected range.
  * @summary Get rule history filter keys

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

@@ -4529,6 +4529,26 @@ export interface RulestatehistorytypesGettableRuleStateWindowDTO {
 	state: RuletypesAlertStateDTO;
 }
 
+export interface RuletypesAlertCompositeQueryDTO {
+	/**
+	 * @type string
+	 */
+	panelType?: string;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	queries?: Querybuildertypesv5QueryEnvelopeDTO[] | null;
+	/**
+	 * @type string
+	 */
+	queryType?: string;
+	/**
+	 * @type string
+	 */
+	unit?: string;
+}
+
 export enum RuletypesAlertStateDTO {
 	inactive = 'inactive',
 	pending = 'pending',
@@ -4537,6 +4557,364 @@ export enum RuletypesAlertStateDTO {
 	nodata = 'nodata',
 	disabled = 'disabled',
 }
+export enum RuletypesCompareOperatorDTO {
+	above = 'above',
+	below = 'below',
+	equal = 'equal',
+	not_equal = 'not_equal',
+	outside_bounds = 'outside_bounds',
+}
+export interface RuletypesEvaluationEnvelopeDTO {
+	/**
+	 * @type string
+	 */
+	kind?: string;
+	spec?: unknown;
+}
+
+export interface RuletypesGettablePlannedMaintenanceDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	alertIds?: string[] | null;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type string
+	 */
+	id?: string;
+	/**
+	 * @type string
+	 */
+	kind?: string;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	schedule?: RuletypesScheduleDTO;
+	/**
+	 * @type string
+	 */
+	status?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+}
+
+export type RuletypesGettableRuleDTOAnnotations = { [key: string]: string };
+
+export type RuletypesGettableRuleDTOLabels = { [key: string]: string };
+
+export interface RuletypesGettableRuleDTO {
+	/**
+	 * @type string
+	 */
+	alert?: string;
+	/**
+	 * @type string
+	 */
+	alertType?: string;
+	/**
+	 * @type object
+	 */
+	annotations?: RuletypesGettableRuleDTOAnnotations;
+	condition?: RuletypesRuleConditionDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 * @nullable true
+	 */
+	createAt?: Date | null;
+	/**
+	 * @type string
+	 * @nullable true
+	 */
+	createBy?: string | null;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type boolean
+	 */
+	disabled?: boolean;
+	/**
+	 * @type string
+	 */
+	evalWindow?: string;
+	evaluation?: RuletypesEvaluationEnvelopeDTO;
+	/**
+	 * @type string
+	 */
+	frequency?: string;
+	/**
+	 * @type string
+	 */
+	id?: string;
+	/**
+	 * @type object
+	 */
+	labels?: RuletypesGettableRuleDTOLabels;
+	notificationSettings?: RuletypesNotificationSettingsDTO;
+	/**
+	 * @type array
+	 */
+	preferredChannels?: string[];
+	ruleType?: RuletypesRuleTypeDTO;
+	/**
+	 * @type string
+	 */
+	schemaVersion?: string;
+	/**
+	 * @type string
+	 */
+	source?: string;
+	state?: RuletypesAlertStateDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 * @nullable true
+	 */
+	updateAt?: Date | null;
+	/**
+	 * @type string
+	 * @nullable true
+	 */
+	updateBy?: string | null;
+	/**
+	 * @type string
+	 */
+	version?: string;
+}
+
+export interface RuletypesGettableRulesDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	rules?: RuletypesGettableRuleDTO[] | null;
+}
+
+export enum RuletypesMatchTypeDTO {
+	at_least_once = 'at_least_once',
+	all_the_times = 'all_the_times',
+	on_average = 'on_average',
+	in_total = 'in_total',
+	last = 'last',
+}
+export interface RuletypesNotificationSettingsDTO {
+	/**
+	 * @type array
+	 */
+	groupBy?: string[];
+	/**
+	 * @type string
+	 */
+	newGroupEvalDelay?: string;
+	renotify?: RuletypesRenotifyDTO;
+	/**
+	 * @type boolean
+	 */
+	usePolicy?: boolean;
+}
+
+export type RuletypesPostableRuleDTOAnnotations = { [key: string]: string };
+
+export type RuletypesPostableRuleDTOLabels = { [key: string]: string };
+
+export interface RuletypesPostableRuleDTO {
+	/**
+	 * @type string
+	 */
+	alert?: string;
+	/**
+	 * @type string
+	 */
+	alertType?: string;
+	/**
+	 * @type object
+	 */
+	annotations?: RuletypesPostableRuleDTOAnnotations;
+	condition?: RuletypesRuleConditionDTO;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type boolean
+	 */
+	disabled?: boolean;
+	/**
+	 * @type string
+	 */
+	evalWindow?: string;
+	evaluation?: RuletypesEvaluationEnvelopeDTO;
+	/**
+	 * @type string
+	 */
+	frequency?: string;
+	/**
+	 * @type object
+	 */
+	labels?: RuletypesPostableRuleDTOLabels;
+	notificationSettings?: RuletypesNotificationSettingsDTO;
+	/**
+	 * @type array
+	 */
+	preferredChannels?: string[];
+	ruleType?: RuletypesRuleTypeDTO;
+	/**
+	 * @type string
+	 */
+	schemaVersion?: string;
+	/**
+	 * @type string
+	 */
+	source?: string;
+	/**
+	 * @type string
+	 */
+	version?: string;
+}
+
+export interface RuletypesRecurrenceDTO {
+	/**
+	 * @type string
+	 */
+	duration?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 * @nullable true
+	 */
+	endTime?: Date | null;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	repeatOn?: string[] | null;
+	/**
+	 * @type string
+	 */
+	repeatType?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	startTime?: Date;
+}
+
+export interface RuletypesRenotifyDTO {
+	/**
+	 * @type array
+	 */
+	alertStates?: RuletypesAlertStateDTO[];
+	/**
+	 * @type boolean
+	 */
+	enabled?: boolean;
+	/**
+	 * @type string
+	 */
+	interval?: string;
+}
+
+export interface RuletypesRuleConditionDTO {
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	absentFor?: number;
+	/**
+	 * @type boolean
+	 */
+	alertOnAbsent?: boolean;
+	/**
+	 * @type string
+	 */
+	algorithm?: string;
+	compositeQuery?: RuletypesAlertCompositeQueryDTO;
+	matchType?: RuletypesMatchTypeDTO;
+	op?: RuletypesCompareOperatorDTO;
+	/**
+	 * @type boolean
+	 */
+	requireMinPoints?: boolean;
+	/**
+	 * @type integer
+	 */
+	requiredNumPoints?: number;
+	seasonality?: RuletypesSeasonalityDTO;
+	/**
+	 * @type string
+	 */
+	selectedQueryName?: string;
+	/**
+	 * @type number
+	 * @nullable true
+	 */
+	target?: number | null;
+	/**
+	 * @type string
+	 */
+	targetUnit?: string;
+	thresholds?: RuletypesRuleThresholdDataDTO;
+}
+
+export interface RuletypesRuleThresholdDataDTO {
+	/**
+	 * @type string
+	 */
+	kind?: string;
+	spec?: unknown;
+}
+
+export enum RuletypesRuleTypeDTO {
+	threshold_rule = 'threshold_rule',
+	promql_rule = 'promql_rule',
+	anomaly_rule = 'anomaly_rule',
+}
+export interface RuletypesScheduleDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	endTime?: Date;
+	recurrence?: RuletypesRecurrenceDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	startTime?: Date;
+	/**
+	 * @type string
+	 */
+	timezone?: string;
+}
+
+export enum RuletypesSeasonalityDTO {
+	hourly = 'hourly',
+	daily = 'daily',
+	weekly = 'weekly',
+}
 export interface ServiceaccounttypesGettableFactorAPIKeyDTO {
 	/**
 	 * @type string
@@ -5463,6 +5841,34 @@ export type DeleteAuthDomainPathParameters = {
 export type UpdateAuthDomainPathParameters = {
 	id: string;
 };
+export type ListDowntimeSchedules200 = {
+	/**
+	 * @type array
+	 */
+	data: RuletypesGettablePlannedMaintenanceDTO[];
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type DeleteDowntimeScheduleByIDPathParameters = {
+	id: string;
+};
+export type GetDowntimeScheduleByIDPathParameters = {
+	id: string;
+};
+export type GetDowntimeScheduleByID200 = {
+	data: RuletypesGettablePlannedMaintenanceDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type UpdateDowntimeScheduleByIDPathParameters = {
+	id: string;
+};
 export type HandleExportRawDataPOSTParams = {
 	/**
 	 * @enum csv,jsonl
@@ -5790,6 +6196,50 @@ export type UpdateRoutePolicy200 = {
 	status: string;
 };
 
+export type ListRules200 = {
+	data: RuletypesGettableRulesDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type CreateRule200 = {
+	data: RuletypesGettableRuleDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type DeleteRuleByIDPathParameters = {
+	id: string;
+};
+export type GetRuleByIDPathParameters = {
+	id: string;
+};
+export type GetRuleByID200 = {
+	data: RuletypesGettableRuleDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type PatchRuleByIDPathParameters = {
+	id: string;
+};
+export type PatchRuleByID200 = {
+	data: RuletypesGettableRuleDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type UpdateRuleByIDPathParameters = {
+	id: string;
+};
 export type ListServiceAccounts200 = {
 	/**
 	 * @type array

frontend/src/constants/localStorage.ts

@@ -37,4 +37,5 @@ export enum LOCALSTORAGE {
 	SHOW_FREQUENCY_CHART = 'SHOW_FREQUENCY_CHART',
 	DISSMISSED_COST_METER_INFO = 'DISMISSED_COST_METER_INFO',
 	DISMISSED_API_KEYS_DEPRECATION_BANNER = 'DISMISSED_API_KEYS_DEPRECATION_BANNER',
+	LICENSE_KEY_CALLOUT_DISMISSED = 'LICENSE_KEY_CALLOUT_DISMISSED',
 }

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -38,6 +38,7 @@ import {
 } from 'types/api/settings/getRetention';
 import { USER_ROLES } from 'types/roles';
 
+import LicenseRowDismissibleCallout from './LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissibleCallout';
 import Retention from './Retention';
 import StatusMessage from './StatusMessage';
 import { ActionItemsContainer, ErrorText, ErrorTextContainer } from './styles';
@@ -683,7 +684,12 @@ function GeneralSettings({
 					{showCustomDomainSettings && activeLicense?.key && (
 						<div className="custom-domain-card-divider" />
 					)}
-					{activeLicense?.key && <LicenseKeyRow />}
+					{activeLicense?.key && (
+						<>
+							<LicenseKeyRow />
+							<LicenseRowDismissibleCallout />
+						</>
+					)}
 				</div>
 			)}
 

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissible.styles.scss

@@ -0,0 +1,31 @@
+.license-key-callout {
+	margin: var(--spacing-4) var(--spacing-6);
+	width: auto;
+
+	.license-key-callout__description {
+		display: flex;
+		align-items: baseline;
+		gap: var(--spacing-2);
+		min-width: 0;
+		flex-wrap: wrap;
+		font-size: 13px;
+	}
+
+	.license-key-callout__link {
+		display: inline-flex;
+		align-items: center;
+		padding: var(--spacing-1) var(--spacing-3);
+		border-radius: 2px;
+		background: var(--callout-primary-background);
+		color: var(--callout-primary-description);
+		font-family: 'SF Mono', 'Fira Code', 'Fira Mono', monospace;
+		font-size: var(--paragraph-base-400-font-size);
+		text-decoration: none;
+
+		&:hover {
+			background: var(--callout-primary-border);
+			color: var(--callout-primary-icon);
+			text-decoration: none;
+		}
+	}
+}

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissibleCallout.tsx

@@ -0,0 +1,83 @@
+import { useState } from 'react';
+import { Link } from 'react-router-dom';
+import { Callout } from '@signozhq/callout';
+import getLocalStorageApi from 'api/browser/localstorage/get';
+import setLocalStorageApi from 'api/browser/localstorage/set';
+import { FeatureKeys } from 'constants/features';
+import { LOCALSTORAGE } from 'constants/localStorage';
+import ROUTES from 'constants/routes';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
+import { useAppContext } from 'providers/App/App';
+import { USER_ROLES } from 'types/roles';
+
+import './LicenseRowDismissible.styles.scss';
+
+function LicenseRowDismissibleCallout(): JSX.Element | null {
+	const [isCalloutDismissed, setIsCalloutDismissed] = useState<boolean>(
+		() =>
+			getLocalStorageApi(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED) === 'true',
+	);
+
+	const { user, featureFlags } = useAppContext();
+	const { isCloudUser } = useGetTenantLicense();
+
+	const isAdmin = user.role === USER_ROLES.ADMIN;
+	const isEditor = user.role === USER_ROLES.EDITOR;
+
+	const isGatewayEnabled =
+		featureFlags?.find((feature) => feature.name === FeatureKeys.GATEWAY)
+			?.active || false;
+
+	const hasServiceAccountsAccess = isAdmin;
+
+	const hasIngestionAccess =
+		(isCloudUser && !isGatewayEnabled) ||
+		(isGatewayEnabled && (isAdmin || isEditor));
+
+	const handleDismissCallout = (): void => {
+		setLocalStorageApi(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED, 'true');
+		setIsCalloutDismissed(true);
+	};
+
+	return !isCalloutDismissed ? (
+		<Callout
+			type="info"
+			size="small"
+			showIcon
+			dismissable
+			onClose={handleDismissCallout}
+			className="license-key-callout"
+			description={
+				<div className="license-key-callout__description">
+					This is <strong>NOT</strong> your ingestion or Service account key.
+					{(hasServiceAccountsAccess || hasIngestionAccess) && (
+						<>
+							{' '}
+							Find your{' '}
+							{hasServiceAccountsAccess && (
+								<Link
+									to={ROUTES.SERVICE_ACCOUNTS_SETTINGS}
+									className="license-key-callout__link"
+								>
+									Service account here
+								</Link>
+							)}
+							{hasServiceAccountsAccess && hasIngestionAccess && ' and '}
+							{hasIngestionAccess && (
+								<Link
+									to={ROUTES.INGESTION_SETTINGS}
+									className="license-key-callout__link"
+								>
+									Ingestion key here
+								</Link>
+							)}
+							.
+						</>
+					)}
+				</div>
+			}
+		/>
+	) : null;
+}
+
+export default LicenseRowDismissibleCallout;

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/__tests__/LicenseRowDismissibleCallout.test.tsx

@@ -0,0 +1,229 @@
+import { FeatureKeys } from 'constants/features';
+import { LOCALSTORAGE } from 'constants/localStorage';
+import ROUTES from 'constants/routes';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
+import { render, screen, userEvent } from 'tests/test-utils';
+import { USER_ROLES } from 'types/roles';
+
+import LicenseRowDismissibleCallout from '../LicenseRowDismissibleCallout';
+
+const getDescription = (): HTMLElement =>
+	screen.getByText(
+		(_, el) =>
+			el?.classList?.contains('license-key-callout__description') ?? false,
+	);
+
+const queryDescription = (): HTMLElement | null =>
+	screen.queryByText(
+		(_, el) =>
+			el?.classList?.contains('license-key-callout__description') ?? false,
+	);
+
+jest.mock('hooks/useGetTenantLicense', () => ({
+	useGetTenantLicense: jest.fn(),
+}));
+
+const mockLicense = (isCloudUser: boolean): void => {
+	(useGetTenantLicense as jest.Mock).mockReturnValue({
+		isCloudUser,
+		isEnterpriseSelfHostedUser: !isCloudUser,
+		isCommunityUser: false,
+		isCommunityEnterpriseUser: false,
+	});
+};
+
+const renderCallout = (
+	role: string,
+	isCloudUser: boolean,
+	gatewayActive: boolean,
+): void => {
+	mockLicense(isCloudUser);
+	render(
+		<LicenseRowDismissibleCallout />,
+		{},
+		{
+			role,
+			appContextOverrides: {
+				featureFlags: [
+					{
+						name: FeatureKeys.GATEWAY,
+						active: gatewayActive,
+						usage: 0,
+						usage_limit: -1,
+						route: '',
+					},
+				],
+			},
+		},
+	);
+};
+
+describe('LicenseRowDismissibleCallout', () => {
+	beforeEach(() => {
+		localStorage.clear();
+		jest.clearAllMocks();
+	});
+
+	describe('callout content per access level', () => {
+		it.each([
+			{
+				scenario: 'viewer, non-cloud, gateway off — base text only, no links',
+				role: USER_ROLES.VIEWER,
+				isCloudUser: false,
+				gatewayActive: false,
+				serviceAccountLink: false,
+				ingestionLink: false,
+				expectedText: 'This is NOT your ingestion or Service account key.',
+			},
+			{
+				scenario: 'admin, non-cloud, gateway off — service accounts link only',
+				role: USER_ROLES.ADMIN,
+				isCloudUser: false,
+				gatewayActive: false,
+				serviceAccountLink: true,
+				ingestionLink: false,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Service account here.',
+			},
+			{
+				scenario: 'viewer, cloud, gateway off — ingestion link only',
+				role: USER_ROLES.VIEWER,
+				isCloudUser: true,
+				gatewayActive: false,
+				serviceAccountLink: false,
+				ingestionLink: true,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
+			},
+			{
+				scenario: 'admin, cloud, gateway off — both links',
+				role: USER_ROLES.ADMIN,
+				isCloudUser: true,
+				gatewayActive: false,
+				serviceAccountLink: true,
+				ingestionLink: true,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Service account here and Ingestion key here.',
+			},
+			{
+				scenario: 'admin, non-cloud, gateway on — both links',
+				role: USER_ROLES.ADMIN,
+				isCloudUser: false,
+				gatewayActive: true,
+				serviceAccountLink: true,
+				ingestionLink: true,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Service account here and Ingestion key here.',
+			},
+			{
+				scenario: 'editor, non-cloud, gateway on — ingestion link only',
+				role: USER_ROLES.EDITOR,
+				isCloudUser: false,
+				gatewayActive: true,
+				serviceAccountLink: false,
+				ingestionLink: true,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
+			},
+			{
+				scenario: 'editor, cloud, gateway off — ingestion link only',
+				role: USER_ROLES.EDITOR,
+				isCloudUser: true,
+				gatewayActive: false,
+				serviceAccountLink: false,
+				ingestionLink: true,
+				expectedText:
+					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
+			},
+		])(
+			'$scenario',
+			({
+				role,
+				isCloudUser,
+				gatewayActive,
+				serviceAccountLink,
+				ingestionLink,
+				expectedText,
+			}) => {
+				renderCallout(role, isCloudUser, gatewayActive);
+
+				const description = getDescription();
+				expect(description).toBeInTheDocument();
+				expect(description).toHaveTextContent(expectedText);
+
+				if (serviceAccountLink) {
+					expect(
+						screen.getByRole('link', { name: /Service account here/ }),
+					).toBeInTheDocument();
+				} else {
+					expect(
+						screen.queryByRole('link', { name: /Service account here/ }),
+					).not.toBeInTheDocument();
+				}
+
+				if (ingestionLink) {
+					expect(
+						screen.getByRole('link', { name: /Ingestion key here/ }),
+					).toBeInTheDocument();
+				} else {
+					expect(
+						screen.queryByRole('link', { name: /Ingestion key here/ }),
+					).not.toBeInTheDocument();
+				}
+			},
+		);
+	});
+
+	describe('Link routing', () => {
+		it('should link to service accounts settings', () => {
+			renderCallout(USER_ROLES.ADMIN, false, false);
+
+			const link = screen.getByRole('link', {
+				name: /Service account here/,
+			}) as HTMLAnchorElement;
+
+			expect(link.getAttribute('href')).toBe(ROUTES.SERVICE_ACCOUNTS_SETTINGS);
+		});
+
+		it('should link to ingestion settings', () => {
+			renderCallout(USER_ROLES.VIEWER, true, false);
+
+			const link = screen.getByRole('link', {
+				name: /Ingestion key here/,
+			}) as HTMLAnchorElement;
+
+			expect(link.getAttribute('href')).toBe(ROUTES.INGESTION_SETTINGS);
+		});
+	});
+
+	describe('Dismissal functionality', () => {
+		it('should hide callout when dismiss button is clicked', async () => {
+			const user = userEvent.setup();
+			renderCallout(USER_ROLES.ADMIN, false, false);
+
+			expect(getDescription()).toBeInTheDocument();
+
+			await user.click(screen.getByRole('button'));
+
+			expect(queryDescription()).not.toBeInTheDocument();
+		});
+
+		it('should persist dismissal in localStorage', async () => {
+			const user = userEvent.setup();
+			renderCallout(USER_ROLES.ADMIN, false, false);
+
+			await user.click(screen.getByRole('button'));
+
+			expect(
+				localStorage.getItem(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED),
+			).toBe('true');
+		});
+
+		it('should not render when localStorage dismissal is set', () => {
+			localStorage.setItem(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED, 'true');
+			renderCallout(USER_ROLES.ADMIN, false, false);
+
+			expect(queryDescription()).not.toBeInTheDocument();
+		});
+	});
+});

go.mod

@@ -64,7 +64,6 @@ require (
 	github.com/uptrace/bun/dialect/pgdialect v1.2.9
 	github.com/uptrace/bun/dialect/sqlitedialect v1.2.9
 	github.com/uptrace/bun/extra/bunotel v1.2.9
-	github.com/yuin/goldmark v1.7.16
 	go.opentelemetry.io/collector/confmap v1.51.0
 	go.opentelemetry.io/collector/otelcol v0.144.0
 	go.opentelemetry.io/collector/pdata v1.51.0

go.sum

@@ -1144,8 +1144,6 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
-github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 github.com/zeebo/assert v1.3.1 h1:vukIABvugfNMZMQO1ABsyQDJDTVQbn+LWSMy1ol1h6A=

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go

@@ -1,292 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"context"
-	"log/slog"
-	"sort"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/prometheus/alertmanager/notify"
-	"github.com/prometheus/alertmanager/template"
-	"github.com/prometheus/alertmanager/types"
-	"github.com/prometheus/common/model"
-)
-
-// AlertManagerTemplater processes alert notification templates.
-type AlertManagerTemplater interface {
-	// ProcessTemplates expands the title and body templates from input
-	// against the provided alerts and returns the expanded templates.
-	ProcessTemplates(ctx context.Context, input TemplateInput, alerts []*types.Alert) (*ExpandedTemplates, error)
-	// BuildNotificationTemplateData builds the NotificationTemplateData from context and alerts.
-	// This exposes the structured alert data that gets used in the notification templates.
-	BuildNotificationTemplateData(ctx context.Context, alerts []*types.Alert) *NotificationTemplateData
-}
-
-type alertManagerTemplater struct {
-	tmpl   *template.Template
-	logger *slog.Logger
-}
-
-func New(tmpl *template.Template, logger *slog.Logger) AlertManagerTemplater {
-	return &alertManagerTemplater{tmpl: tmpl, logger: logger}
-}
-
-// ProcessTemplates expands the title and body templates from input
-// against the provided alerts and returns the expanded templates.
-func (at *alertManagerTemplater) ProcessTemplates(
-	ctx context.Context,
-	input TemplateInput,
-	alerts []*types.Alert,
-) (*ExpandedTemplates, error) {
-	ntd := at.buildNotificationTemplateData(ctx, alerts)
-	missingVars := make(map[string]bool)
-
-	title, titleMissingVars, err := at.expandTitle(input.TitleTemplate, ntd)
-	if err != nil {
-		return nil, err
-	}
-	// if title template results in empty string, use default template
-	// this happens for rules where custom title annotation was not set
-	if title == "" && input.DefaultTitleTemplate != "" {
-		title, err = at.expandDefaultTemplate(ctx, input.DefaultTitleTemplate, alerts)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		mergeMissingVars(missingVars, titleMissingVars)
-	}
-
-	// isDefaultTemplated tracks whether the body is templated using default templates
-	isDefaultTemplated := false
-	body, bodyMissingVars, err := at.expandBody(input.BodyTemplate, ntd)
-	if err != nil {
-		return nil, err
-	}
-	// if body template results in nil, use default template
-	// this happens for rules where custom body annotation was not set
-	if body == nil {
-		isDefaultTemplated = true
-		defaultBody, err := at.expandDefaultTemplate(ctx, input.DefaultBodyTemplate, alerts)
-		if err != nil {
-			return nil, err
-		}
-		body = []string{defaultBody} // default template combines all alerts message into a single body
-	} else {
-		mergeMissingVars(missingVars, bodyMissingVars)
-	}
-
-	// convert the internal map to a sorted slice for returning missing variables
-	missingVarsList := make([]string, 0, len(missingVars))
-	for k := range missingVars {
-		missingVarsList = append(missingVarsList, k)
-	}
-	sort.Strings(missingVarsList)
-
-	return &ExpandedTemplates{
-		Title:                  title,
-		Body:                   body,
-		MissingVars:            missingVarsList,
-		IsDefaultTemplatedBody: isDefaultTemplated,
-	}, nil
-}
-
-// BuildNotificationTemplateData builds the NotificationTemplateData from context and alerts.
-func (at *alertManagerTemplater) BuildNotificationTemplateData(
-	ctx context.Context,
-	alerts []*types.Alert,
-) *NotificationTemplateData {
-	return at.buildNotificationTemplateData(ctx, alerts)
-}
-
-// expandDefaultTemplate uses go-template to expand the default template.
-func (at *alertManagerTemplater) expandDefaultTemplate(
-	ctx context.Context,
-	tmplStr string,
-	alerts []*types.Alert,
-) (string, error) {
-	// if even the default template is empty, return empty string
-	// this is possible if user added channel with blank template
-	if tmplStr == "" {
-		at.logger.WarnContext(ctx, "default template is empty")
-		return "", nil
-	}
-	data := notify.GetTemplateData(ctx, at.tmpl, alerts, at.logger)
-	result, err := at.tmpl.ExecuteTextString(tmplStr, data)
-	if err != nil {
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute default template: %s", err.Error())
-	}
-	return result, nil
-}
-
-// mergeMissingVars adds all keys from src into dst.
-func mergeMissingVars(dst, src map[string]bool) {
-	for k := range src {
-		dst[k] = true
-	}
-}
-
-// expandTitle expands the title template. Returns empty string if the template is empty.
-func (at *alertManagerTemplater) expandTitle(
-	titleTemplate string,
-	ntd *NotificationTemplateData,
-) (string, map[string]bool, error) {
-	if titleTemplate == "" {
-		return "", nil, nil
-	}
-	processRes, err := PreProcessTemplateAndData(titleTemplate, ntd)
-	if err != nil {
-		return "", nil, err
-	}
-	result, err := at.tmpl.ExecuteTextString(processRes.Template, processRes.Data)
-	if err != nil {
-		return "", nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom title template: %s", err.Error())
-	}
-	return strings.TrimSpace(result), processRes.UnknownVars, nil
-}
-
-// expandBody expands the body template for each individual alert. Returns nil if the template is empty.
-func (at *alertManagerTemplater) expandBody(
-	bodyTemplate string,
-	ntd *NotificationTemplateData,
-) ([]string, map[string]bool, error) {
-	if bodyTemplate == "" {
-		return nil, nil, nil
-	}
-	var sb []string
-	missingVars := make(map[string]bool)
-	for i := range ntd.Alerts {
-		processRes, err := PreProcessTemplateAndData(bodyTemplate, &ntd.Alerts[i])
-		if err != nil {
-			return nil, nil, err
-		}
-		part, err := at.tmpl.ExecuteTextString(processRes.Template, processRes.Data)
-		if err != nil {
-			return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom body template: %s", err.Error())
-		}
-		// add unknown variables and templated text to the result
-		for k := range processRes.UnknownVars {
-			missingVars[k] = true
-		}
-		if strings.TrimSpace(part) != "" {
-			sb = append(sb, strings.TrimSpace(part))
-		}
-	}
-	return sb, missingVars, nil
-}
-
-// buildNotificationTemplateData creates the NotificationTemplateData using
-// info from context and the raw alerts.
-func (at *alertManagerTemplater) buildNotificationTemplateData(
-	ctx context.Context,
-	alerts []*types.Alert,
-) *NotificationTemplateData {
-	// extract the required data from the context
-	receiver, ok := notify.ReceiverName(ctx)
-	if !ok {
-		at.logger.WarnContext(ctx, "missing receiver name in context")
-	}
-
-	groupLabels, ok := notify.GroupLabels(ctx)
-	if !ok {
-		at.logger.WarnContext(ctx, "missing group labels in context")
-	}
-
-	// extract the external URL from the template
-	externalURL := ""
-	if at.tmpl.ExternalURL != nil {
-		externalURL = at.tmpl.ExternalURL.String()
-	}
-
-	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
-	commonLabels := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
-
-	// aggregate labels and annotations from all alerts
-	labels := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
-	annotations := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
-
-	// build the alert data slice
-	alertDataSlice := make([]AlertData, 0, len(alerts))
-	for _, a := range alerts {
-		ad := buildAlertData(a, receiver)
-		alertDataSlice = append(alertDataSlice, ad)
-	}
-
-	// count the number of firing and resolved alerts
-	var firing, resolved int
-	for _, ad := range alertDataSlice {
-		if ad.IsFiring {
-			firing++
-		} else if ad.IsResolved {
-			resolved++
-		}
-	}
-
-	// extract the rule-level convenience fields from common labels
-	alertName := commonLabels[ruletypes.LabelAlertName]
-	ruleID := commonLabels[ruletypes.LabelRuleID]
-	ruleLink := commonLabels[ruletypes.LabelRuleSource]
-
-	// build the group labels
-	gl := make(template.KV, len(groupLabels))
-	for k, v := range groupLabels {
-		gl[string(k)] = string(v)
-	}
-
-	// build the notification template data
-	return &NotificationTemplateData{
-		Receiver:          receiver,
-		Status:            string(types.Alerts(alerts...).Status()),
-		AlertName:         alertName,
-		RuleID:            ruleID,
-		RuleLink:          ruleLink,
-		TotalFiring:       firing,
-		TotalResolved:     resolved,
-		Alerts:            alertDataSlice,
-		GroupLabels:       gl,
-		CommonLabels:      commonLabels,
-		CommonAnnotations: commonAnnotations,
-		ExternalURL:       externalURL,
-		Labels:            labels,
-		Annotations:       annotations,
-	}
-}
-
-// buildAlertData converts a single *types.Alert into an AlertData.
-func buildAlertData(a *types.Alert, receiver string) AlertData {
-	labels := make(template.KV, len(a.Labels))
-	for k, v := range a.Labels {
-		labels[string(k)] = string(v)
-	}
-
-	annotations := make(template.KV, len(a.Annotations))
-	for k, v := range a.Annotations {
-		annotations[string(k)] = string(v)
-	}
-
-	return AlertData{
-		Receiver:      receiver,
-		Status:        string(a.Status()),
-		Labels:        labels,
-		Annotations:   annotations,
-		StartsAt:      a.StartsAt,
-		EndsAt:        a.EndsAt,
-		GeneratorURL:  a.GeneratorURL,
-		Fingerprint:   a.Fingerprint().String(),
-		AlertName:     labels[ruletypes.LabelAlertName],
-		RuleID:        labels[ruletypes.LabelRuleID],
-		RuleLink:      labels[ruletypes.LabelRuleSource],
-		Severity:      labels[ruletypes.LabelSeverityName],
-		LogLink:       annotations[ruletypes.AnnotationRelatedLogs],
-		TraceLink:     annotations[ruletypes.AnnotationRelatedTraces],
-		Value:         annotations[ruletypes.AnnotationValue],
-		Threshold:     annotations[ruletypes.AnnotationThresholdValue],
-		CompareOp:     annotations[ruletypes.AnnotationCompareOp],
-		MatchType:     annotations[ruletypes.AnnotationMatchType],
-		IsFiring:      a.Status() == model.AlertFiring,
-		IsResolved:    a.Status() == model.AlertResolved,
-		IsMissingData: labels[ruletypes.LabelNoData] == "true",
-		IsRecovering:  labels[ruletypes.LabelIsRecovering] == "true",
-	}
-}

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate_test.go

@@ -1,283 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"context"
-	"log/slog"
-	"sort"
-	"testing"
-	"time"
-
-	test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/prometheus/common/model"
-	"github.com/stretchr/testify/require"
-
-	"github.com/prometheus/alertmanager/notify"
-	"github.com/prometheus/alertmanager/types"
-)
-
-// testSetup returns an AlertTemplater and a context pre-populated with group key,
-// receiver name, and group labels for use in tests.
-func testSetup(t *testing.T) (AlertManagerTemplater, context.Context) {
-	t.Helper()
-	tmpl := test.CreateTmpl(t)
-	ctx := context.Background()
-	ctx = notify.WithGroupKey(ctx, "test-group")
-	ctx = notify.WithReceiverName(ctx, "slack")
-	ctx = notify.WithGroupLabels(ctx, model.LabelSet{"alertname": "TestAlert", "severity": "critical"})
-	logger := slog.New(slog.DiscardHandler)
-	return New(tmpl, logger), ctx
-}
-
-func createAlert(labels, annotations map[string]string, isFiring bool) *types.Alert {
-	ls := model.LabelSet{}
-	for k, v := range labels {
-		ls[model.LabelName(k)] = model.LabelValue(v)
-	}
-	ann := model.LabelSet{}
-	for k, v := range annotations {
-		ann[model.LabelName(k)] = model.LabelValue(v)
-	}
-	startsAt := time.Now()
-	var endsAt time.Time
-	if isFiring {
-		endsAt = startsAt.Add(time.Hour)
-	} else {
-		startsAt = startsAt.Add(-2 * time.Hour)
-		endsAt = startsAt.Add(-time.Hour)
-	}
-	return &types.Alert{Alert: model.Alert{Labels: ls, Annotations: ann, StartsAt: startsAt, EndsAt: endsAt}}
-}
-
-func TestExpandTemplates(t *testing.T) {
-	at, ctx := testSetup(t)
-
-	tests := []struct {
-		name              string
-		alerts            []*types.Alert
-		input             TemplateInput
-		wantTitle         string
-		wantBody          []string
-		wantMissingVars   []string
-		errorContains     string
-		wantIsDefaultBody bool
-	}{
-		{
-			// High request throughput on a service — service is a custom label.
-			// $labels.service extracts the label value; $annotations.description pulls the annotation.
-			name: "new template: high request throughput for a service",
-			alerts: []*types.Alert{
-				createAlert(
-					map[string]string{
-						ruletypes.LabelAlertName:    "HighRequestThroughput",
-						ruletypes.LabelSeverityName: "warning",
-						"service":                   "payment-service",
-					},
-					map[string]string{"description": "Request rate exceeded 10k/s"},
-					true,
-				),
-			},
-			input: TemplateInput{
-				TitleTemplate: "High request throughput for $service",
-				BodyTemplate: `The service $service is getting high request. Please investigate.
-Severity: $severity
-Status: $status
-Service: $service
-Description: $description`,
-			},
-			wantTitle: "High request throughput for payment-service",
-			wantBody: []string{`The service payment-service is getting high request. Please investigate.
-Severity: warning
-Status: firing
-Service: payment-service
-Description: Request rate exceeded 10k/s`},
-			wantIsDefaultBody: false,
-		},
-		{
-			// Disk usage alert using old Go template syntax throughout.
-			// No custom templates — both title and body use the default fallback path.
-			name: "old template: disk usage high on database host",
-			alerts: []*types.Alert{
-				createAlert(
-					map[string]string{ruletypes.LabelAlertName: "DiskUsageHigh",
-						ruletypes.LabelSeverityName: "critical",
-						"instance":                  "db-primary-01",
-					},
-					map[string]string{
-						"summary":        "Disk usage high on database host",
-						"description":    "Disk usage is high on the database host",
-						"related_logs":   "https://logs.example.com/search?q=DiskUsageHigh",
-						"related_traces": "https://traces.example.com/search?q=DiskUsageHigh",
-					},
-					true,
-				),
-			},
-			input: TemplateInput{
-				DefaultTitleTemplate: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
-     {{- if gt (len .CommonLabels) (len .GroupLabels) -}}
-       {{" "}}(
-       {{- with .CommonLabels.Remove .GroupLabels.Names }}
-         {{- range $index, $label := .SortedPairs -}}
-           {{ if $index }}, {{ end }}
-           {{- $label.Name }}="{{ $label.Value -}}"
-         {{- end }}
-       {{- end -}}
-       )
-     {{- end }}`,
-				DefaultBodyTemplate: `{{ range .Alerts -}}
-     *Alert:* {{ .Labels.alertname }}{{ if .Labels.severity }} - {{ .Labels.severity }}{{ end }}
-
-     *Summary:* {{ .Annotations.summary }}
-     *Description:* {{ .Annotations.description }}
-     *RelatedLogs:* {{ if gt (len .Annotations.related_logs) 0 -}} View in <{{ .Annotations.related_logs }}|logs explorer> {{- end}}
-     *RelatedTraces:* {{ if gt (len .Annotations.related_traces) 0 -}} View in <{{ .Annotations.related_traces }}|traces explorer> {{- end}}
-
-     *Details:*
-       {{ range .Labels.SortedPairs }} • *{{ .Name }}:* {{ .Value }}
-       {{ end }}
-     {{ end }}`,
-			},
-			wantTitle: "[FIRING:1] DiskUsageHigh for  (instance=\"db-primary-01\")",
-			wantBody: []string{`*Alert:* DiskUsageHigh - critical
-
-     *Summary:* Disk usage high on database host
-     *Description:* Disk usage is high on the database host
-     *RelatedLogs:* View in <https://logs.example.com/search?q=DiskUsageHigh|logs explorer>
-     *RelatedTraces:* View in <https://traces.example.com/search?q=DiskUsageHigh|traces explorer>
-
-     *Details:*
-        • *alertname:* DiskUsageHigh
-        • *instance:* db-primary-01
-        • *severity:* critical
-       
-     `},
-			wantIsDefaultBody: true,
-		},
-		{
-			// Pod crash loop on multiple pods — body is expanded once per alert
-			// and joined with "\n\n", with the pod name pulled from labels.
-			name: "new template: pod crash loop on multiple pods, body per-alert",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-1"}, nil, true),
-				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-2"}, nil, true),
-				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-3"}, nil, true),
-			},
-			input: TemplateInput{
-				TitleTemplate: "$rule_name: $total_firing pods affected",
-				BodyTemplate:  "$labels.pod is crash looping",
-			},
-			wantTitle:         "PodCrashLoop: 3 pods affected",
-			wantBody:          []string{"api-worker-1 is crash looping", "api-worker-2 is crash looping", "api-worker-3 is crash looping"},
-			wantIsDefaultBody: false,
-		},
-		{
-			// Incident partially resolved — one service still down, one recovered.
-			// Title shows the aggregate counts; body shows per-service status.
-			name: "new template: service degradation with mixed firing and resolved alerts",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "ServiceDown", "service": "auth-service"}, nil, true),
-				createAlert(map[string]string{ruletypes.LabelAlertName: "ServiceDown", "service": "payment-service"}, nil, false),
-			},
-			input: TemplateInput{
-				TitleTemplate: "$total_firing firing, $total_resolved resolved",
-				BodyTemplate:  "$labels.service ($status)",
-			},
-			wantTitle:         "1 firing, 1 resolved",
-			wantBody:          []string{"auth-service (firing)", "payment-service (resolved)"},
-			wantIsDefaultBody: false,
-		},
-		{
-			// $environment is not a known AlertData or NotificationTemplateData field,
-			// so it lands in MissingVars and renders as "<no value>" in the output.
-			name: "missing vars: unknown $environment variable in title",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, true),
-			},
-			input: TemplateInput{
-				TitleTemplate: "[$environment] $rule_name",
-			},
-			wantTitle:         "[<no value>] HighCPU",
-			wantMissingVars:   []string{"environment"},
-			wantIsDefaultBody: true,
-		},
-		{
-			// $runbook_url is not a known field — someone tried to embed a runbook link
-			// directly as a variable instead of via annotations.
-			name: "missing vars: unknown $runbook_url variable in body",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "PodOOMKilled", ruletypes.LabelSeverityName: "warning"}, nil, true),
-			},
-			input: TemplateInput{
-				BodyTemplate: "$rule_name: see runbook at $runbook_url",
-			},
-			wantBody:        []string{"PodOOMKilled: see runbook at <no value>"},
-			wantMissingVars: []string{"runbook_url"},
-		},
-		{
-			// Both title and body use unknown variables; MissingVars is the union of both.
-			name: "missing vars: unknown variables in both title and body",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "HighMemory", ruletypes.LabelSeverityName: "critical"}, nil, true),
-			},
-			input: TemplateInput{
-				TitleTemplate: "[$environment] $rule_name and [{{ $service }}]",
-				BodyTemplate:  "$rule_name: see runbook at $runbook_url",
-			},
-			wantTitle:       "[<no value>] HighMemory and [<no value>]",
-			wantBody:        []string{"HighMemory: see runbook at <no value>"},
-			wantMissingVars: []string{"environment", "runbook_url", "service"},
-		},
-		{
-			// Custom title template that expands to only whitespace triggers the fallback,
-			// so the default title template is used instead.
-			name: "fallback: whitespace-only custom title falls back to default",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, false),
-			},
-			input: TemplateInput{
-				TitleTemplate:        "   ",
-				DefaultTitleTemplate: "{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})",
-				DefaultBodyTemplate:  "Runbook: https://runbook.example.com",
-			},
-			wantTitle:         "HighCPU (RESOLVED)",
-			wantBody:          []string{"Runbook: https://runbook.example.com"},
-			wantIsDefaultBody: true,
-		},
-		{
-			name: "using non-existing function in template",
-			alerts: []*types.Alert{
-				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, true),
-			},
-			input: TemplateInput{
-				TitleTemplate: "$rule_name ({{$severity | toUpperAndTrim}}) for $alertname",
-			},
-			errorContains: "function \"toUpperAndTrim\" not defined",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := at.ProcessTemplates(ctx, tc.input, tc.alerts)
-			if tc.errorContains != "" {
-				require.ErrorContains(t, err, tc.errorContains)
-				return
-			}
-			require.NoError(t, err)
-
-			if tc.wantTitle != "" {
-				require.Equal(t, tc.wantTitle, got.Title)
-			}
-			if tc.wantBody != nil {
-				require.Equal(t, tc.wantBody, got.Body)
-			}
-			require.Equal(t, tc.wantIsDefaultBody, got.IsDefaultTemplatedBody)
-
-			if len(tc.wantMissingVars) == 0 {
-				require.Empty(t, got.MissingVars)
-			} else {
-				sort.Strings(tc.wantMissingVars)
-				require.Equal(t, tc.wantMissingVars, got.MissingVars)
-			}
-		})
-	}
-}

pkg/alertmanager/alertmanagertemplate/preprocessor.go

@@ -1,271 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/go-viper/mapstructure/v2"
-)
-
-// fieldMapping represents a mapping from a JSON tag name to its struct field name.
-type fieldMapping struct {
-	VarName   string // JSON tag name (e.g., "receiver", "rule_name")
-	FieldName string // Struct field name (e.g., "Receiver", "AlertName")
-}
-
-// extractFieldMappings uses reflection to extract field mappings from a struct.
-func extractFieldMappings(data any) []fieldMapping {
-	val := reflect.ValueOf(data)
-	// Handle pointer types
-	if val.Kind() == reflect.Ptr {
-		if val.IsNil() {
-			return nil
-		}
-		val = val.Elem()
-	}
-	// return nil if the given data is not a struct
-	if val.Kind() != reflect.Struct {
-		return nil
-	}
-	typ := val.Type()
-
-	var mappings []fieldMapping
-	for i := 0; i < typ.NumField(); i++ {
-		field := typ.Field(i)
-		// Skip unexported fields
-		if !field.IsExported() {
-			continue
-		}
-		// Get JSON tag name
-		jsonTag := field.Tag.Get("json")
-		if jsonTag == "" || jsonTag == "-" {
-			continue
-		}
-		// Extract the name part (before any comma options like omitempty)
-		varName := strings.Split(jsonTag, ",")[0]
-		if varName == "" {
-			continue
-		}
-		varFieldName := field.Tag.Get("mapstructure")
-		if varFieldName == "" {
-			varFieldName = field.Name
-		}
-		// Skip complex types: slices and interfaces
-		kind := field.Type.Kind()
-		if kind == reflect.Slice || kind == reflect.Interface {
-			continue
-		}
-		// For struct types, we skip all but with few exceptions like time.Time
-		if kind == reflect.Struct {
-			// Allow time.Time which is commonly used
-			if field.Type.String() != "time.Time" {
-				continue
-			}
-		}
-
-		mappings = append(mappings, fieldMapping{
-			VarName:   varName,
-			FieldName: varFieldName,
-		})
-	}
-
-	return mappings
-}
-
-// prepareVariableName prepares the variable name to be used in go-text-template
-// it replaces every unwanted character like dots, spaces, etc. with an underscore
-// for example, "http.request.method" becomes "http_request_method".
-func prepareVariableName(key string) string {
-	var b strings.Builder
-	b.Grow(len(key))
-
-	for i, r := range key {
-		switch {
-		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r == '_': // valid variable name characters
-			b.WriteRune(r)
-		case r >= '0' && r <= '9':
-			if b.Len() == 0 {
-				// leading digit — replace with underscore
-				b.WriteByte('_')
-			} else {
-				b.WriteRune(r)
-			}
-		default:
-			// dots, hyphens, spaces, etc. → underscore
-			b.WriteByte('_')
-		}
-		_ = i
-	}
-	return b.String()
-}
-
-// extractNestedFieldsDefinitions adds the labels and annotations keys from the data struct to the template variable definitions
-// it takes the known data struct and extracts the labels and annotations maps and adds their keys to template variable definitions to be used in the template.
-func extractNestedFieldsDefinitions(data any) map[string]string {
-	variables := make(map[string]string)
-
-	addLabelsAndAnnotations := func(labels, annotations map[string]string) {
-		for k := range annotations {
-			variables[prepareVariableName(k)] = fmt.Sprintf("index .annotations \"%s\"", k)
-		}
-		for k := range labels {
-			variables[prepareVariableName(k)] = fmt.Sprintf("index .labels \"%s\"", k)
-		}
-	}
-
-	switch data := data.(type) {
-	case *NotificationTemplateData:
-		addLabelsAndAnnotations(data.Labels, data.Annotations)
-	case *AlertData:
-		addLabelsAndAnnotations(data.Labels, data.Annotations)
-	default:
-		return variables
-	}
-
-	return variables
-}
-
-// prepareDataForTemplating prepares the data for templating by adding the labels and annotations values to the resulting map
-// so they can be accessed directly from root level, the predefined values take precedence over the labels and annotations values
-// for example, if labels have a value called rule_name, which collides with the rule_name field in the data struct, the value from the data struct will take precedence.
-func prepareDataForTemplating(data any) (map[string]interface{}, error) {
-	var result map[string]interface{}
-	if err := mapstructure.Decode(data, &result); err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to prepare data for templating")
-	}
-
-	addLabelsAndAnnotationsValues := func(labels, annotations map[string]string) {
-		for k, v := range labels {
-			k = prepareVariableName(k)
-			if _, ok := result[k]; !ok {
-				result[k] = v
-			}
-		}
-		for k, v := range annotations {
-			k = prepareVariableName(k)
-			if _, ok := result[k]; !ok {
-				result[k] = v
-			}
-		}
-	}
-
-	switch data := data.(type) {
-	case *NotificationTemplateData:
-		addLabelsAndAnnotationsValues(data.Labels, data.Annotations)
-	case *AlertData:
-		addLabelsAndAnnotationsValues(data.Labels, data.Annotations)
-	default:
-		return result, nil
-	}
-
-	return result, nil
-}
-
-// generateVariableDefinitions creates `{{ $varname := "" }}` declarations for each variable name.
-func generateVariableDefinitions(varNames map[string]string) string {
-	if len(varNames) == 0 {
-		return ""
-	}
-	var sb strings.Builder
-	for name := range varNames {
-		fmt.Fprintf(&sb, `{{ $%s := %s }}`, name, varNames[name])
-	}
-	return sb.String()
-}
-
-// buildVariableDefinitions constructs the full variable definition preamble for a template.
-// containing all known and unknown variables, the reason to include unknown variables is to
-// populate them with "<no value>" in template so go-text-template don't throw errors
-// when these variables are used in the template.
-func buildVariableDefinitions(tmpl string, data any) (string, map[string]bool, error) {
-	// Extract the initial fields from the data struct and add to the definitions
-	mappings := extractFieldMappings(data)
-
-	// Add variables from struct root level fields to the definitions
-	variables := make(map[string]string)
-	for _, m := range mappings {
-		variables[m.VarName] = fmt.Sprintf(".%s", m.FieldName)
-	}
-
-	// Extract the nested fields definitions from the data struct, like labels, annotations, etc.
-	// once extracted we add them to the variables map along with the field address
-	nestedVariables := extractNestedFieldsDefinitions(data)
-	for k, v := range nestedVariables {
-		variables[k] = v
-	}
-
-	// variables that are used throughout the template
-	usedVars, err := ExtractUsedVariables(tmpl)
-	if err != nil {
-		return "", nil, err
-	}
-
-	// Compute unknown variables: used in template but not covered by a field mapping
-	probableUnknownVars := make(map[string]bool)
-	for name := range usedVars {
-		_, ok := variables[name]
-		if !ok {
-			probableUnknownVars[name] = true
-		}
-	}
-
-	// Add missing variables to the definitions with "<no value>"
-	// missingkey=zero is used to replace the missing value with "<no value>"
-	// but it only works when getting map values like {{ .keyfrommap }} from map and in struct this breaks
-	// with missing variable errors, we add missing variables in map so when directly variables
-	// are accessed directly in template block like {{ $variable }} it's handled and doesn't throw errors.
-	for name := range probableUnknownVars {
-		variables[name] = `"<no value>"`
-	}
-
-	return generateVariableDefinitions(variables), probableUnknownVars, nil
-}
-
-type ProcessingResult struct {
-	Template string
-	Data     map[string]interface{}
-	// UnknownVars is the set of possible unknown variables exptracted using regex
-	UnknownVars map[string]bool
-}
-
-// PreProcessTemplateAndData prepares a template string and struct data for Go template execution.
-//
-//	Input:  "$receiver has $rule_name in $status state"
-//	Output: "{{ $receiver := .Receiver }}...{{ $receiver }} has {{ $rule_name }} in {{ $status }} state"
-func PreProcessTemplateAndData(tmpl string, data any) (*ProcessingResult, error) {
-	// Handle empty template
-	unknownVars := make(map[string]bool)
-	if tmpl == "" {
-		result, err := prepareDataForTemplating(data)
-		if err != nil {
-			return nil, err
-		}
-		return &ProcessingResult{Data: result, UnknownVars: unknownVars}, nil
-	}
-
-	// Build variable definitions: known struct fields + fallback empty-string declarations
-	definitions, unknownVars, err := buildVariableDefinitions(tmpl, data)
-	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to build template definitions")
-	}
-
-	// Attach definitions prefix so WrapDollarVariables can parse the AST without "undefined variable" errors.
-	finalTmpl := definitions + tmpl
-
-	// Call WrapDollarVariables to transform bare $variable references to go-text-template format
-	// with {{ $variable }} syntax from $variable syntax
-	wrappedTmpl, err := WrapDollarVariables(finalTmpl)
-	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to prepare template for templating")
-	}
-
-	// Convert struct to map using mapstructure to be used for template execution
-	result, err := prepareDataForTemplating(data)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ProcessingResult{Template: wrappedTmpl, Data: result, UnknownVars: unknownVars}, nil
-}

pkg/alertmanager/alertmanagertemplate/preprocessor_test.go

@@ -1,327 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"testing"
-	"time"
-
-	"github.com/prometheus/alertmanager/template"
-	"github.com/stretchr/testify/require"
-)
-
-func TestExtractFieldMappings(t *testing.T) {
-	// Struct with various field types to test extraction logic
-	type TestStruct struct {
-		Name            string    `json:"name"`
-		Status          string    `json:"status"`
-		ActiveUserCount int       `json:"user_count" mapstructure:"active_user_count"`
-		IsActive        bool      `json:"is_active"`
-		CreatedAt       time.Time `json:"created_at"` // time.Time allowed
-		Items           []string  `json:"items"`      // slice skipped
-		unexported      string    // unexported skipped (no tag needed)
-		NoTag           string    // no json tag skipped
-		SkippedTag      string    `json:"-"` // json:"-" skipped
-	}
-
-	testCases := []struct {
-		name     string
-		data     any
-		expected []fieldMapping
-	}{
-		{
-			name: "struct with mixed field types",
-			data: TestStruct{Name: "test", ActiveUserCount: 5, unexported: ""},
-			expected: []fieldMapping{
-				{VarName: "name", FieldName: "Name"},
-				{VarName: "status", FieldName: "Status"},
-				{VarName: "user_count", FieldName: "active_user_count"},
-				{VarName: "is_active", FieldName: "IsActive"},
-				{VarName: "created_at", FieldName: "CreatedAt"},
-			},
-		},
-		{
-			name:     "nil data",
-			data:     nil,
-			expected: nil,
-		},
-		{
-			name:     "non-struct type",
-			data:     "string",
-			expected: nil,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := extractFieldMappings(tc.data)
-			require.Equal(t, tc.expected, result)
-		})
-	}
-}
-
-func TestBuildVariableDefinitions(t *testing.T) {
-	testCases := []struct {
-		name         string
-		tmpl         string
-		data         any
-		expectedVars []string // substrings that must appear in result
-		expectError  bool
-	}{
-		{
-			name: "empty template still returns struct field definitions",
-			tmpl: "",
-			data: &NotificationTemplateData{Receiver: "test"},
-			expectedVars: []string{
-				"{{ $receiver := .receiver }}",
-				"{{ $status := .status }}",
-			},
-		},
-		{
-			name: "mix of known and unknown vars",
-			tmpl: "$rule_name: $custom_label",
-			data: &AlertData{AlertName: "test", Status: "ok", Severity: "critical"},
-			expectedVars: []string{
-				"{{ $rule_name := .rule_name }}",
-				"{{ $status := .status }}",
-				"{{ $severity := .severity }}",
-				`{{ $custom_label := "<no value>" }}`,
-			},
-		},
-		{
-			name: "nested fields definitions coming from NotificationTemplateData",
-			tmpl: "$severity for $service",
-			data: &NotificationTemplateData{Labels: template.KV{
-				"severity":              "critical",
-				"service":               "test",
-				"cloud.region.instance": "ap-south-1",
-			}},
-			expectedVars: []string{
-				"{{ $severity := index .labels \"severity\" }}",
-				"{{ $service := index .labels \"service\" }}",
-				"{{ $cloud_region_instance := index .labels \"cloud.region.instance\" }}",
-			},
-		},
-		{
-			name: "nested fields definitions coming from AlertData",
-			tmpl: "$severity for $service",
-			data: &AlertData{Labels: template.KV{
-				"severity": "critical",
-				"service":  "test",
-			}},
-			expectedVars: []string{
-				"{{ $severity := index .labels \"severity\" }}",
-				"{{ $service := index .labels \"service\" }}",
-			},
-		},
-		{
-			name:        "invalid template syntax returns error",
-			tmpl:        "{{invalid",
-			data:        &NotificationTemplateData{},
-			expectError: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result, _, err := buildVariableDefinitions(tc.tmpl, tc.data)
-			if tc.expectError {
-				require.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-			if len(tc.expectedVars) == 0 {
-				require.Empty(t, result)
-				return
-			}
-			for _, expected := range tc.expectedVars {
-				require.Contains(t, result, expected)
-			}
-		})
-	}
-}
-
-func TestPreProcessTemplateAndData(t *testing.T) {
-	testCases := []struct {
-		name                     string
-		tmpl                     string
-		data                     any
-		expectedTemplateContains []string
-		expectedData             map[string]any
-		expectedUnknownVars      map[string]bool
-		expectError              bool
-	}{
-		{
-			name: "NotificationTemplateData with dollar variables and labels with dots and hyphens",
-			tmpl: "[$status] $rule_name (ID: $rule_id) - Firing: $total_firing, Resolved: $total_resolved, Severity: $severity\nHTTP method is: $http_request_method\nRequest path is: $http_request_path",
-			data: &NotificationTemplateData{
-				Receiver:  "pagerduty",
-				Status:    "firing",
-				AlertName: "HighMemory",
-				RuleID:    "rule-123",
-				Labels: template.KV{
-					"severity":            "critical",
-					"http.request.method": "GET",
-					"http-request-path":   "/api/v1/metrics",
-				},
-				TotalFiring:   3,
-				TotalResolved: 1,
-			},
-			expectedTemplateContains: []string{
-				"{{$status := .status}}",
-				"{{$rule_name := .rule_name}}",
-				"{{$rule_id := .rule_id}}",
-				"{{$total_firing := .total_firing}}",
-				"{{$total_resolved := .total_resolved}}",
-				"{{$severity := index .labels \"severity\"}}",
-				"[{{ .status }}] {{ .rule_name }} (ID: {{ .rule_id }}) - Firing: {{ .total_firing }}, Resolved: {{ .total_resolved }}",
-				"{{$http_request_method := index .labels \"http.request.method\"}}",
-				"{{$http_request_path := index .labels \"http-request-path\"}}",
-			},
-			expectedData: map[string]any{
-				"status":              "firing",
-				"rule_name":           "HighMemory",
-				"rule_id":             "rule-123",
-				"total_firing":        3,
-				"total_resolved":      1,
-				"severity":            "critical",
-				"http_request_method": "GET",
-				"http_request_path":   "/api/v1/metrics",
-			},
-			expectedUnknownVars: map[string]bool{},
-		},
-		{
-			name: "AlertData with dollar variables",
-			tmpl: "$rule_name: Value $value exceeded $threshold (Status: $status, Severity: $severity, Description: $description)",
-			data: &AlertData{
-				Receiver:  "webhook",
-				Status:    "resolved",
-				AlertName: "DiskFull",
-				RuleID:    "disk-001",
-				Severity:  "warning",
-				Annotations: template.KV{
-					"description": "Disk full and cannot be written to",
-				},
-				Value:      "85%",
-				Threshold:  "80%",
-				IsFiring:   false,
-				IsResolved: true,
-			},
-			expectedTemplateContains: []string{
-				"{{$rule_name := .rule_name}}",
-				"{{$value := .value}}",
-				"{{$threshold := .threshold}}",
-				"{{$status := .status}}",
-				"{{$severity := .severity}}",
-				"{{$description := index .annotations \"description\"}}",
-				"{{ .rule_name }}: Value {{ .value }} exceeded {{ .threshold }} (Status: {{ .status }}, Severity: {{ .severity }}, Description: {{ .description }})",
-			},
-			expectedData: map[string]any{
-				"status":      "resolved",
-				"rule_name":   "DiskFull",
-				"rule_id":     "disk-001",
-				"severity":    "warning",
-				"value":       "85%",
-				"threshold":   "80%",
-				"description": "Disk full and cannot be written to",
-			},
-			expectedUnknownVars: map[string]bool{},
-		},
-		{
-			name: "mixed dollar and dot notation with both labels and annotations",
-			tmpl: "Alert $rule_name has {{.total_firing}} firing alerts",
-			data: &NotificationTemplateData{
-				AlertName:   "HighCPU",
-				TotalFiring: 5,
-				Labels: template.KV{
-					"value":      "<MASKED VALUE>",
-					"cpu.number": "10",
-				},
-				Annotations: template.KV{
-					"value": "85%",
-				},
-			},
-			expectedTemplateContains: []string{
-				"{{$rule_name := .rule_name}}",
-				"{{$value := index .labels \"value\"}}",
-				"Alert {{ .rule_name }} has {{.total_firing}} firing alerts",
-				"{{$cpu_number := index .labels \"cpu.number\"}}",
-			},
-			expectedData: map[string]any{
-				"rule_name":    "HighCPU",
-				"total_firing": 5,
-				"value":        "<MASKED VALUE>",
-				"cpu_number":   "10",
-			},
-			expectedUnknownVars: map[string]bool{},
-		},
-		{
-			name: "empty template",
-			tmpl: "",
-			data: &NotificationTemplateData{Receiver: "slack"},
-		},
-		{
-			name:        "invalid template syntax",
-			tmpl:        "{{invalid",
-			data:        &NotificationTemplateData{},
-			expectError: true,
-		},
-		{
-			name: "unknown dollar var in text renders empty",
-			tmpl: "alert $custom_note fired",
-			data: &NotificationTemplateData{AlertName: "HighCPU"},
-			expectedTemplateContains: []string{
-				`{{$custom_note := "<no value>"}}`,
-				"alert {{ .custom_note }} fired",
-			},
-			expectedUnknownVars: map[string]bool{"custom_note": true},
-		},
-		{
-			name: "unknown dollar var in action block renders empty",
-			tmpl: "alert {{ $custom_note }} fired",
-			data: &NotificationTemplateData{AlertName: "HighCPU"},
-			expectedTemplateContains: []string{
-				`{{$custom_note := "<no value>"}}`,
-				`alert {{$custom_note}} fired`,
-			},
-			expectedUnknownVars: map[string]bool{"custom_note": true},
-		},
-		{
-			name: "mix of known and unknown vars",
-			tmpl: "$rule_name: $custom_label",
-			data: &NotificationTemplateData{AlertName: "HighCPU"},
-			expectedTemplateContains: []string{
-				"{{$rule_name := .rule_name}}",
-				`{{$custom_label := "<no value>"}}`,
-				"{{ .rule_name }}: {{ .custom_label }}",
-			},
-			expectedData:        map[string]any{"rule_name": "HighCPU"},
-			expectedUnknownVars: map[string]bool{"custom_label": true},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result, err := PreProcessTemplateAndData(tc.tmpl, tc.data)
-
-			if tc.expectError {
-				require.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-
-			if tc.tmpl == "" {
-				require.Equal(t, "", result.Template)
-				return
-			}
-
-			for _, substr := range tc.expectedTemplateContains {
-				require.Contains(t, result.Template, substr)
-			}
-			for k, v := range tc.expectedData {
-				require.Equal(t, v, result.Data[k])
-			}
-			if tc.expectedUnknownVars != nil {
-				require.Equal(t, tc.expectedUnknownVars, result.UnknownVars)
-			}
-		})
-	}
-}

pkg/alertmanager/alertmanagertemplate/types.go

@@ -1,90 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"time"
-
-	"github.com/prometheus/alertmanager/template"
-)
-
-// TemplateInput carries the title/body templates
-// and their defaults to apply in case the custom templates
-// are result in empty strings.
-type TemplateInput struct {
-	TitleTemplate        string
-	BodyTemplate         string
-	DefaultTitleTemplate string
-	DefaultBodyTemplate  string
-}
-
-// ExpandedTemplates is the result of ExpandTemplates.
-type ExpandedTemplates struct {
-	Title string
-	// Body is notification array of body for each alert
-	Body []string
-	// IsDefaultTemplatedBody is true if the body templates are templated using
-	// default templates, false when custom templates were used for templating.
-	IsDefaultTemplatedBody bool
-	MissingVars            []string // union of unknown vars from title + body templates
-}
-
-// AlertData holds per-alert data used when expanding body templates.
-type AlertData struct {
-	Receiver     string      `json:"receiver" mapstructure:"receiver"`
-	Status       string      `json:"status" mapstructure:"status"`
-	Labels       template.KV `json:"labels" mapstructure:"labels"`
-	Annotations  template.KV `json:"annotations" mapstructure:"annotations"`
-	StartsAt     time.Time   `json:"starts_at" mapstructure:"starts_at"`
-	EndsAt       time.Time   `json:"ends_at" mapstructure:"ends_at"`
-	GeneratorURL string      `json:"generator_url" mapstructure:"generator_url"`
-	Fingerprint  string      `json:"fingerprint" mapstructure:"fingerprint"`
-
-	// Convenience fields extracted from well-known labels/annotations.
-	AlertName string `json:"rule_name" mapstructure:"rule_name"`
-	RuleID    string `json:"rule_id" mapstructure:"rule_id"`
-	RuleLink  string `json:"rule_link" mapstructure:"rule_link"`
-	Severity  string `json:"severity" mapstructure:"severity"`
-
-	// Alert internal data fields
-	Value     string `json:"value" mapstructure:"value"`
-	Threshold string `json:"threshold" mapstructure:"threshold"`
-	CompareOp string `json:"compare_op" mapstructure:"compare_op"`
-	MatchType string `json:"match_type" mapstructure:"match_type"`
-
-	// Link annotations added by the rule evaluator.
-	LogLink   string `json:"log_link" mapstructure:"log_link"`
-	TraceLink string `json:"trace_link" mapstructure:"trace_link"`
-
-	// Status booleans for easy conditional templating.
-	IsFiring      bool `json:"is_firing" mapstructure:"is_firing"`
-	IsResolved    bool `json:"is_resolved" mapstructure:"is_resolved"`
-	IsMissingData bool `json:"is_missing_data" mapstructure:"is_missing_data"`
-	IsRecovering  bool `json:"is_recovering" mapstructure:"is_recovering"`
-}
-
-// NotificationTemplateData is the top-level data struct provided to custom templates.
-type NotificationTemplateData struct {
-	Receiver string `json:"receiver" mapstructure:"receiver"`
-	Status   string `json:"status" mapstructure:"status"`
-
-	// Convenience fields for title templates.
-	AlertName     string `json:"rule_name" mapstructure:"rule_name"`
-	RuleID        string `json:"rule_id" mapstructure:"rule_id"`
-	RuleLink      string `json:"rule_link" mapstructure:"rule_link"`
-	TotalFiring   int    `json:"total_firing" mapstructure:"total_firing"`
-	TotalResolved int    `json:"total_resolved" mapstructure:"total_resolved"`
-
-	// Per-alert data, also available as filtered sub-slices.
-	Alerts []AlertData `json:"-" mapstructure:"-"`
-
-	// Cross-alert aggregates, computed as intersection across all alerts.
-	GroupLabels       template.KV `json:"group_labels" mapstructure:"group_labels"`
-	CommonLabels      template.KV `json:"common_labels" mapstructure:"common_labels"`
-	CommonAnnotations template.KV `json:"common_annotations" mapstructure:"common_annotations"`
-	ExternalURL       string      `json:"external_url" mapstructure:"external_url"`
-	// Labels and Annotations that are collection of labels
-	// and annotations from all alerts, it includes only the common labels and annotations
-	// and for non-common labels and annotations, it picks some first few labels/annotations
-	// and joins them with ", " to avoid blank values in the template
-	Labels      template.KV `json:"labels" mapstructure:"labels"`
-	Annotations template.KV `json:"annotations" mapstructure:"annotations"`
-}

pkg/alertmanager/alertmanagertemplate/utils.go

@@ -1,230 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"fmt"
-	"reflect"
-	"regexp"
-	"strings"
-	"text/template/parse"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/prometheus/alertmanager/template"
-	"github.com/prometheus/alertmanager/types"
-	"github.com/prometheus/common/model"
-)
-
-// maxAggregatedValues is the maximum number of unique values to include
-// when aggregating non-common label/annotation values across alerts.
-const maxAggregatedValues = 5
-
-// bareVariableRegex matches bare $variable references including dotted paths like $service.name.
-var bareVariableRegex = regexp.MustCompile(`\$(\w+(?:\.\w+)*)`)
-
-// bareVariableRegexFirstSeg matches only the base $variable name, stopping before any dotted path.
-// e.g. "$labels.severity" matches "$labels", "$name" matches "$name".
-var bareVariableRegexFirstSeg = regexp.MustCompile(`\$\w+`)
-
-// ExtractTemplatesFromAnnotations computes the common annotations across all alerts
-// and returns the values for the title_template and body_template annotation keys as title and body templates.
-func ExtractTemplatesFromAnnotations(alerts []*types.Alert) (titleTemplate, bodyTemplate string) {
-	if len(alerts) == 0 {
-		return "", ""
-	}
-
-	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
-	return commonAnnotations[ruletypes.AnnotationTitleTemplate], commonAnnotations[ruletypes.AnnotationBodyTemplate]
-}
-
-// WrapDollarVariables wraps bare $variable references in Go template syntax.
-// Example transformations:
-//   - "$name is $status" -> "{{ $name }} is {{ $status }}"
-//   - "$labels.severity" -> "{{ index .labels \"severity\" }}"
-//   - "$labels.http.status" -> "{{ index .labels \"http.status\" }}"
-//   - "$annotations.summary" -> "{{ index .annotations \"summary\" }}"
-//   - "$service.name" -> "{{ index . \"service.name\" }}"
-//   - "$name is {{ .Status }}" -> "{{ $name }} is {{ .Status }}"
-func WrapDollarVariables(src string) (string, error) {
-	if src == "" {
-		return src, nil
-	}
-
-	// Create a new parse.Tree directly
-	tree := parse.New("template")
-	tree.Mode = parse.SkipFuncCheck
-
-	// Parse the template
-	_, err := tree.Parse(src, "{{", "}}", make(map[string]*parse.Tree), nil)
-	if err != nil {
-		return "", err
-	}
-
-	// Walk the AST and transform TextNodes
-	walkAndWrapTextNodes(tree.Root)
-
-	// Return the reassembled template
-	return tree.Root.String(), nil
-}
-
-// walkAndWrapTextNodes recursively walks the parse tree trying to find a text node.
-// Once a text node is found, it wraps the bare $variable and changes it to index-based
-// element access from the data map, like '.key' or '.key.subkey'.
-func walkAndWrapTextNodes(node parse.Node) {
-	if reflect.ValueOf(node).IsNil() {
-		return
-	}
-
-	switch n := node.(type) {
-	// `$name is {{.Status}}` is a list node with one text and one action node
-	case *parse.ListNode:
-		// Recurse into all child nodes
-		if n.Nodes != nil {
-			for _, child := range n.Nodes {
-				walkAndWrapTextNodes(child)
-			}
-		}
-
-	// `$name is ` is a text node with plain text in root
-	// we try to find the $name variable and wrap it with template block
-	// like `{{ .name }}`, for labels and annotations we use the index to access the value
-	// so `$labels.service` becomes `{{ index .labels "service" }}`
-	case *parse.TextNode:
-		// Transform $variable based on its pattern
-		n.Text = bareVariableRegex.ReplaceAllFunc(n.Text, func(match []byte) []byte {
-			// Extract variable name without the $
-			varName := string(match[1:])
-
-			// Check if variable contains dots
-			if strings.Contains(varName, ".") {
-				// Check for reserved prefixes: labels.* or annotations.*
-				if strings.HasPrefix(varName, "labels.") {
-					key := strings.TrimPrefix(varName, "labels.")
-					return []byte(fmt.Sprintf(`{{ index .labels "%s" }}`, key))
-				}
-				if strings.HasPrefix(varName, "annotations.") {
-					key := strings.TrimPrefix(varName, "annotations.")
-					return []byte(fmt.Sprintf(`{{ index .annotations "%s" }}`, key))
-				}
-				// Other dotted variables: index into root context
-				return []byte(fmt.Sprintf(`{{ index . "%s" }}`, varName))
-			}
-
-			// Simple variables: use dot notation to directly access the field
-			// without raising any error due to missing variables
-			return []byte(fmt.Sprintf("{{ .%s }}", varName))
-		})
-
-	// `{{if pipeline}} T1 {{else}} T0 {{end}}` is a if node with T1 part of List and T0 part of ElseList
-	case *parse.IfNode:
-		// Recurse into both branches
-		walkAndWrapTextNodes(n.List)
-		walkAndWrapTextNodes(n.ElseList)
-
-	// `{{range pipeline}} T1 {{else}} T0 {{end}}` is a range node with T1 part of List and T0 part of ElseList
-	case *parse.RangeNode:
-		// Recurse into both branches
-		walkAndWrapTextNodes(n.List)
-		walkAndWrapTextNodes(n.ElseList)
-
-		// All other node types (ActionNode, PipeNode, VariableNode, etc.) are already
-		// inside {{ }} action blocks and don't need transformation
-
-		// Support for `with` can be added later when we start supporting it in editor block
-	}
-}
-
-// ExtractUsedVariables returns the set of all $variable referenced in template
-// — text nodes, action blocks, branch conditions, and loop declarations — regardless of scope.
-// After finding all variables, we find those that are not part of our alert data and handle them so the
-// text/template parser does not reject undefined $variables.
-func ExtractUsedVariables(src string) (map[string]bool, error) {
-	if src == "" {
-		return map[string]bool{}, nil
-	}
-
-	// Regex-scan raw template string to collect all $var base names.
-	// bareVariableRegexFirstSeg stops before dots, so "$labels.severity" yields "$labels".
-	used := make(map[string]bool)
-	for _, m := range bareVariableRegexFirstSeg.FindAll([]byte(src), -1) {
-		used[string(m[1:])] = true // strip leading "$"
-	}
-
-	// Build a preamble that pre-declares every found variable.
-	// This prevents "undefined variable" parse errors for $vars used in action
-	// blocks while still letting genuine syntax errors propagate.
-	var preamble strings.Builder
-	for name := range used {
-		fmt.Fprintf(&preamble, `{{$%s := ""}}`, name)
-	}
-
-	// Validate template syntax.
-	tree := parse.New("template")
-	tree.Mode = parse.SkipFuncCheck
-	if _, err := tree.Parse(preamble.String()+src, "{{", "}}", make(map[string]*parse.Tree), nil); err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInternal, "failed to extract used variables")
-	}
-
-	return used, nil
-}
-
-// aggregateKV aggregates key-value pairs (labels or annotations) from all alerts into a single template.KV.
-// The result is used to populate the labels and annotations in the notification template data.
-func aggregateKV(alerts []*types.Alert, extractFn func(*types.Alert) model.LabelSet) template.KV {
-	// track unique values per key in order of first appearance
-	valuesPerKey := make(map[string][]string)
-	// track which values have been seen for deduplication
-	seenValues := make(map[string]map[string]bool)
-
-	for _, alert := range alerts {
-		kvPairs := extractFn(alert)
-		for k, v := range kvPairs {
-			key := string(k)
-			value := string(v)
-
-			if seenValues[key] == nil {
-				seenValues[key] = make(map[string]bool)
-			}
-
-			// only add if not already seen and under the limit of maxAggregatedValues
-			if !seenValues[key][value] && len(valuesPerKey[key]) < maxAggregatedValues {
-				seenValues[key][value] = true
-				valuesPerKey[key] = append(valuesPerKey[key], value)
-			}
-		}
-	}
-
-	// build the result by joining values
-	result := make(template.KV, len(valuesPerKey))
-	for key, values := range valuesPerKey {
-		result[key] = strings.Join(values, ", ")
-	}
-
-	return result
-}
-
-// extractCommonKV returns the intersection of key-value pairs across all alerts.
-// A key/value pair is included only if it appears identically on every alert.
-func extractCommonKV(alerts []*types.Alert, extractFn func(*types.Alert) model.LabelSet) template.KV {
-	if len(alerts) == 0 {
-		return template.KV{}
-	}
-
-	common := make(template.KV, len(extractFn(alerts[0])))
-	for k, v := range extractFn(alerts[0]) {
-		common[string(k)] = string(v)
-	}
-
-	for _, a := range alerts[1:] {
-		kv := extractFn(a)
-		for k := range common {
-			if string(kv[model.LabelName(k)]) != common[k] {
-				delete(common, k)
-			}
-		}
-		if len(common) == 0 {
-			break
-		}
-	}
-
-	return common
-}

pkg/alertmanager/alertmanagertemplate/utils_test.go

@@ -1,348 +0,0 @@
-package alertmanagertemplate
-
-import (
-	"testing"
-
-	"github.com/prometheus/alertmanager/template"
-	"github.com/prometheus/alertmanager/types"
-	"github.com/prometheus/common/model"
-	"github.com/stretchr/testify/require"
-)
-
-func TestWrapBareVars(t *testing.T) {
-	testCases := []struct {
-		name        string
-		input       string
-		expected    string
-		expectError bool
-	}{
-		{
-			name:     "mixed variables with actions",
-			input:    "$name is {{.Status}}",
-			expected: "{{ .name }} is {{.Status}}",
-		},
-		{
-			name: "nested variables in range",
-			input: `{{range .items}}
-				$title
-				{{end}}`,
-			expected: `{{range .items}}
-				{{ .title }}
-				{{end}}`,
-		},
-		{
-			name:     "nested variables in if else",
-			input:    "{{if .ok}}$a{{else}}$b{{end}}",
-			expected: "{{if .ok}}{{ .a }}{{else}}{{ .b }}{{end}}",
-		},
-		// Labels prefix: index into .labels map
-		{
-			name:     "labels variables prefix simple",
-			input:    "$labels.service",
-			expected: `{{ index .labels "service" }}`,
-		},
-		{
-			name:     "labels variables prefix nested with multiple dots",
-			input:    "$labels.http.status",
-			expected: `{{ index .labels "http.status" }}`,
-		},
-		{
-			name:     "multiple labels variables simple and nested",
-			input:    "$labels.service and $labels.instance.id",
-			expected: `{{ index .labels "service" }} and {{ index .labels "instance.id" }}`,
-		},
-		// Annotations prefix: index into .annotations map
-		{
-			name:     "annotations variables prefix simple",
-			input:    "$annotations.summary",
-			expected: `{{ index .annotations "summary" }}`,
-		},
-		{
-			name:     "annotations variables prefix nested with multiple dots",
-			input:    "$annotations.alert.url",
-			expected: `{{ index .annotations "alert.url" }}`,
-		},
-		// Other dotted paths: index into root context
-		{
-			name:     "other variables with multiple dots",
-			input:    "$service.name",
-			expected: `{{ index . "service.name" }}`,
-		},
-		{
-			name:     "other variables with multiple dots nested",
-			input:    "$http.status.code",
-			expected: `{{ index . "http.status.code" }}`,
-		},
-		// Hybrid: all types combined
-		{
-			name:     "hybrid - all variables types",
-			input:    "Alert: $alert_name Labels: $labels.severity Annotations: $annotations.desc Service: $service.name Count: $error_count",
-			expected: `Alert: {{ .alert_name }} Labels: {{ index .labels "severity" }} Annotations: {{ index .annotations "desc" }} Service: {{ index . "service.name" }} Count: {{ .error_count }}`,
-		},
-		{
-			name:     "already wrapped should not be changed",
-			input:    "{{$status := .status}}{{.name}} is {{$status | toUpper}}",
-			expected: "{{$status := .status}}{{.name}} is {{$status | toUpper}}",
-		},
-		{
-			name:     "no variables should not be changed",
-			input:    "Hello world",
-			expected: "Hello world",
-		},
-		{
-			name:     "empty string",
-			input:    "",
-			expected: "",
-		},
-		{
-			name:     "deeply nested",
-			input:    "{{range .items}}{{if .ok}}$deep{{end}}{{end}}",
-			expected: "{{range .items}}{{if .ok}}{{ .deep }}{{end}}{{end}}",
-		},
-		{
-			name: "complex example",
-			input: `Hello $name, your score is $score.
-				{{if .isAdmin}}
-					Welcome back $name, you have {{.unreadCount}} messages.
-				{{end}}`,
-			expected: `Hello {{ .name }}, your score is {{ .score }}.
-				{{if .isAdmin}}
-					Welcome back {{ .name }}, you have {{.unreadCount}} messages.
-				{{end}}`,
-		},
-		{
-			name:     "with custom function",
-			input:    "$name triggered at {{urlescape .url}}",
-			expected: "{{ .name }} triggered at {{urlescape .url}}",
-		},
-		{
-			name:        "invalid template",
-			input:       "{{invalid",
-			expectError: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result, err := WrapDollarVariables(tc.input)
-
-			if tc.expectError {
-				require.Error(t, err, "should error on invalid template syntax")
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, tc.expected, result)
-			}
-		})
-	}
-}
-
-func TestExtractUsedVariables(t *testing.T) {
-	testCases := []struct {
-		name        string
-		input       string
-		expected    map[string]bool
-		expectError bool
-	}{
-		{
-			name:     "simple usage in text",
-			input:    "$name is $status",
-			expected: map[string]bool{"name": true, "status": true},
-		},
-		{
-			name:     "declared in action block",
-			input:    "{{ $name := .name }}",
-			expected: map[string]bool{"name": true},
-		},
-		{
-			name:     "range loop vars",
-			input:    "{{ range $i, $v := .items }}{{ end }}",
-			expected: map[string]bool{"i": true, "v": true},
-		},
-		{
-			name:     "mixed text and action",
-			input:    "$x and {{ $y }}",
-			expected: map[string]bool{"x": true, "y": true},
-		},
-		{
-			name:     "dotted path in text extracts base only",
-			input:    "$labels.severity",
-			expected: map[string]bool{"labels": true},
-		},
-		{
-			name:     "nested if else",
-			input:    "{{ if .ok }}{{ $a }}{{ else }}{{ $b }}{{ end }}",
-			expected: map[string]bool{"a": true, "b": true},
-		},
-		{
-			name:     "empty string",
-			input:    "",
-			expected: map[string]bool{},
-		},
-		{
-			name:     "no variables",
-			input:    "Hello world",
-			expected: map[string]bool{},
-		},
-		{
-			name:        "invalid template returns error",
-			input:       "{{invalid",
-			expectError: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result, err := ExtractUsedVariables(tc.input)
-
-			if tc.expectError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, tc.expected, result)
-			}
-		})
-	}
-}
-
-func TestAggregateKV(t *testing.T) {
-	extractLabels := func(a *types.Alert) model.LabelSet { return a.Labels }
-
-	testCases := []struct {
-		name      string
-		alerts    []*types.Alert
-		extractFn func(*types.Alert) model.LabelSet
-		expected  template.KV
-	}{
-		{
-			name:      "empty alerts slice",
-			alerts:    []*types.Alert{},
-			extractFn: extractLabels,
-			expected:  template.KV{},
-		},
-		{
-			name: "single alert",
-			alerts: []*types.Alert{
-				{
-					Alert: model.Alert{
-						Labels: model.LabelSet{
-							"env":     "production",
-							"service": "backend",
-						},
-					},
-				},
-			},
-			extractFn: extractLabels,
-			expected: template.KV{
-				"env":     "production",
-				"service": "backend",
-			},
-		},
-		{
-			name: "varying values with duplicates deduped",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "backend"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "api"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "frontend"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "api"}}},
-			},
-			extractFn: extractLabels,
-			expected: template.KV{
-				"env":     "production",
-				"service": "backend, api, frontend",
-			},
-		},
-		{
-			name: "more than 5 unique values truncates to 5",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc1"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc2"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc3"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc4"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc5"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc6"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc7"}}},
-			},
-			extractFn: extractLabels,
-			expected: template.KV{
-				"service": "svc1, svc2, svc3, svc4, svc5",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := aggregateKV(tc.alerts, tc.extractFn)
-			require.Equal(t, tc.expected, result)
-		})
-	}
-}
-
-func TestExtractCommonKV(t *testing.T) {
-	extractLabels := func(a *types.Alert) model.LabelSet { return a.Labels }
-	extractAnnotations := func(a *types.Alert) model.LabelSet { return a.Annotations }
-
-	testCases := []struct {
-		name      string
-		alerts    []*types.Alert
-		extractFn func(*types.Alert) model.LabelSet
-		expected  template.KV
-	}{
-		{
-			name:      "empty alerts slice",
-			alerts:    []*types.Alert{},
-			extractFn: extractLabels,
-			expected:  template.KV{},
-		},
-		{
-			name: "single alert returns all labels",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "api"}}},
-			},
-			extractFn: extractLabels,
-			expected:  template.KV{"env": "prod", "service": "api"},
-		},
-		{
-			name: "multiple alerts with fully common labels",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "region": "us-east"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "region": "us-east"}}},
-			},
-			extractFn: extractLabels,
-			expected:  template.KV{"env": "prod", "region": "us-east"},
-		},
-		{
-			name: "multiple alerts with partially common labels",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "api"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "worker"}}},
-			},
-			extractFn: extractLabels,
-			expected:  template.KV{"env": "prod"},
-		},
-		{
-			name: "multiple alerts with no common labels",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "api"}}},
-				{Alert: model.Alert{Labels: model.LabelSet{"service": "worker"}}},
-			},
-			extractFn: extractLabels,
-			expected:  template.KV{},
-		},
-		{
-			name: "annotations extract common annotations",
-			alerts: []*types.Alert{
-				{Alert: model.Alert{Annotations: model.LabelSet{"summary": "high cpu", "runbook": "http://x"}}},
-				{Alert: model.Alert{Annotations: model.LabelSet{"summary": "high cpu", "runbook": "http://y"}}},
-			},
-			extractFn: extractAnnotations,
-			expected:  template.KV{"summary": "high cpu"},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := extractCommonKV(tc.alerts, tc.extractFn)
-			require.Equal(t, tc.expected, result)
-		})
-	}
-}

pkg/apiserver/signozapiserver/provider.go

@@ -26,6 +26,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/ruler"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -59,6 +60,7 @@ type provider struct {
 	cloudIntegrationHandler cloudintegration.Handler
 	ruleStateHistoryHandler rulestatehistory.Handler
 	alertmanagerHandler     alertmanager.Handler
+	rulerHandler            ruler.Handler
 }
 
 func NewFactory(
@@ -86,6 +88,7 @@ func NewFactory(
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
 	alertmanagerHandler alertmanager.Handler,
+	rulerHandler ruler.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
 		return newProvider(
@@ -116,6 +119,7 @@ func NewFactory(
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
 			alertmanagerHandler,
+			rulerHandler,
 		)
 	})
 }
@@ -148,6 +152,7 @@ func newProvider(
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
 	alertmanagerHandler alertmanager.Handler,
+	rulerHandler ruler.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -178,6 +183,7 @@ func newProvider(
 		cloudIntegrationHandler: cloudIntegrationHandler,
 		ruleStateHistoryHandler: ruleStateHistoryHandler,
 		alertmanagerHandler:     alertmanagerHandler,
+		rulerHandler:            rulerHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -282,6 +288,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addRulerRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/apiserver/signozapiserver/ruler.go

@@ -0,0 +1,197 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addRulerRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/rules", handler.New(provider.authZ.ViewAccess(provider.rulerHandler.ListRules), handler.OpenAPIDef{
+		ID:                  "ListRules",
+		Tags:                []string{"rules"},
+		Summary:             "List alert rules",
+		Description:         "This endpoint lists all alert rules with their current evaluation state",
+		Response:            new(ruletypes.GettableRules),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules/{id}", handler.New(provider.authZ.ViewAccess(provider.rulerHandler.GetRuleByID), handler.OpenAPIDef{
+		ID:                  "GetRuleByID",
+		Tags:                []string{"rules"},
+		Summary:             "Get alert rule by ID",
+		Description:         "This endpoint returns an alert rule by ID",
+		Response:            new(ruletypes.GettableRule),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules", handler.New(provider.authZ.EditAccess(provider.rulerHandler.CreateRule), handler.OpenAPIDef{
+		ID:                  "CreateRule",
+		Tags:                []string{"rules"},
+		Summary:             "Create alert rule",
+		Description:         "This endpoint creates a new alert rule",
+		Request:             new(ruletypes.PostableRule),
+		RequestContentType:  "application/json",
+		Response:            new(ruletypes.GettableRule),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules/{id}", handler.New(provider.authZ.EditAccess(provider.rulerHandler.UpdateRuleByID), handler.OpenAPIDef{
+		ID:                  "UpdateRuleByID",
+		Tags:                []string{"rules"},
+		Summary:             "Update alert rule",
+		Description:         "This endpoint updates an alert rule by ID",
+		Request:             new(ruletypes.PostableRule),
+		RequestContentType:  "application/json",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPut).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules/{id}", handler.New(provider.authZ.EditAccess(provider.rulerHandler.DeleteRuleByID), handler.OpenAPIDef{
+		ID:                  "DeleteRuleByID",
+		Tags:                []string{"rules"},
+		Summary:             "Delete alert rule",
+		Description:         "This endpoint deletes an alert rule by ID",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules/{id}", handler.New(provider.authZ.EditAccess(provider.rulerHandler.PatchRuleByID), handler.OpenAPIDef{
+		ID:                  "PatchRuleByID",
+		Tags:                []string{"rules"},
+		Summary:             "Patch alert rule",
+		Description:         "This endpoint applies a partial update to an alert rule by ID",
+		Request:             new(ruletypes.PostableRule),
+		RequestContentType:  "application/json",
+		Response:            new(ruletypes.GettableRule),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPatch).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/rules/test", handler.New(provider.authZ.EditAccess(provider.rulerHandler.TestRule), handler.OpenAPIDef{
+		ID:                  "TestRule",
+		Tags:                []string{"rules"},
+		Summary:             "Test alert rule",
+		Description:         "This endpoint fires a test notification for the given rule definition",
+		Request:             new(ruletypes.PostableRule),
+		RequestContentType:  "application/json",
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/testRule", handler.New(provider.authZ.EditAccess(provider.rulerHandler.TestRule), handler.OpenAPIDef{
+		ID:                  "TestRuleDeprecated",
+		Tags:                []string{"rules"},
+		Summary:             "Test alert rule (deprecated)",
+		Description:         "Deprecated: use /api/v1/rules/test instead",
+		Request:             new(ruletypes.PostableRule),
+		RequestContentType:  "application/json",
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		Deprecated:          true,
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/downtime_schedules", handler.New(provider.authZ.ViewAccess(provider.rulerHandler.ListDowntimeSchedules), handler.OpenAPIDef{
+		ID:                  "ListDowntimeSchedules",
+		Tags:                []string{"downtimeschedules"},
+		Summary:             "List downtime schedules",
+		Description:         "This endpoint lists all planned maintenance / downtime schedules",
+		Response:            make([]*ruletypes.GettablePlannedMaintenance, 0),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/downtime_schedules/{id}", handler.New(provider.authZ.ViewAccess(provider.rulerHandler.GetDowntimeScheduleByID), handler.OpenAPIDef{
+		ID:                  "GetDowntimeScheduleByID",
+		Tags:                []string{"downtimeschedules"},
+		Summary:             "Get downtime schedule by ID",
+		Description:         "This endpoint returns a downtime schedule by ID",
+		Response:            new(ruletypes.GettablePlannedMaintenance),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/downtime_schedules", handler.New(provider.authZ.EditAccess(provider.rulerHandler.CreateDowntimeSchedule), handler.OpenAPIDef{
+		ID:                  "CreateDowntimeSchedule",
+		Tags:                []string{"downtimeschedules"},
+		Summary:             "Create downtime schedule",
+		Description:         "This endpoint creates a new planned maintenance / downtime schedule",
+		Request:             new(ruletypes.GettablePlannedMaintenance),
+		RequestContentType:  "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/downtime_schedules/{id}", handler.New(provider.authZ.EditAccess(provider.rulerHandler.UpdateDowntimeScheduleByID), handler.OpenAPIDef{
+		ID:                  "UpdateDowntimeScheduleByID",
+		Tags:                []string{"downtimeschedules"},
+		Summary:             "Update downtime schedule",
+		Description:         "This endpoint updates a downtime schedule by ID",
+		Request:             new(ruletypes.GettablePlannedMaintenance),
+		RequestContentType:  "application/json",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPut).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/downtime_schedules/{id}", handler.New(provider.authZ.EditAccess(provider.rulerHandler.DeleteDowntimeScheduleByID), handler.OpenAPIDef{
+		ID:                  "DeleteDowntimeScheduleByID",
+		Tags:                []string{"downtimeschedules"},
+		Summary:             "Delete downtime schedule",
+		Description:         "This endpoint deletes a downtime schedule by ID",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/query-service/app/http_handler.go

@@ -3,7 +3,6 @@ package app
 import (
 	"bytes"
 	"context"
-	"database/sql"
 	"encoding/json"
 	"fmt"
 
@@ -12,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/thirdpartyapi"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 
-	"io"
 	"log/slog"
 	"math"
 	"net/http"
@@ -78,7 +76,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/query-service/rules"
+	"github.com/SigNoz/signoz/pkg/ruler"
 	"github.com/SigNoz/signoz/pkg/version"
 )
 
@@ -98,7 +96,7 @@ func NewRouter() *mux.Router {
 type APIHandler struct {
 	logger       *slog.Logger
 	reader       interfaces.Reader
-	ruleManager  *rules.Manager
+	ruleManager  ruler.Ruler
 	querier      interfaces.Querier
 	querierV2    interfaces.Querier
 	queryBuilder *queryBuilder.QueryBuilder
@@ -150,9 +148,6 @@ type APIHandlerOpts struct {
 	// business data reader e.g. clickhouse
 	Reader interfaces.Reader
 
-	// rule manager handles rule crud operations
-	RuleManager *rules.Manager
-
 	// Integrations
 	IntegrationsController *integrations.Controller
 
@@ -208,7 +203,7 @@ func NewAPIHandler(opts APIHandlerOpts, config signoz.Config) (*APIHandler, erro
 		logger:                        slog.Default(),
 		reader:                        opts.Reader,
 		temporalityMap:                make(map[string]map[v3.Temporality]bool),
-		ruleManager:                   opts.RuleManager,
+		ruleManager:                   opts.Signoz.Ruler,
 		IntegrationsController:        opts.IntegrationsController,
 		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
@@ -496,24 +491,11 @@ func (aH *APIHandler) Respond(w http.ResponseWriter, data interface{}) {
 func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/query_range", am.ViewAccess(aH.queryRangeMetrics)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/query", am.ViewAccess(aH.queryMetrics)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/rules", am.ViewAccess(aH.listRules)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/rules/{id}", am.ViewAccess(aH.getRule)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/rules", am.EditAccess(aH.createRule)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.editRule)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.deleteRule)).Methods(http.MethodDelete)
-	router.HandleFunc("/api/v1/rules/{id}", am.EditAccess(aH.patchRule)).Methods(http.MethodPatch)
-	router.HandleFunc("/api/v1/testRule", am.EditAccess(aH.testRule)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/rules/{id}/history/stats", am.ViewAccess(aH.getRuleStats)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/rules/{id}/history/timeline", am.ViewAccess(aH.getRuleStateHistory)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/rules/{id}/history/top_contributors", am.ViewAccess(aH.getRuleStateHistoryTopContributors)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/rules/{id}/history/overall_status", am.ViewAccess(aH.getOverallStateTransitions)).Methods(http.MethodPost)
 
-	router.HandleFunc("/api/v1/downtime_schedules", am.ViewAccess(aH.listDowntimeSchedules)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/downtime_schedules/{id}", am.ViewAccess(aH.getDowntimeSchedule)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/downtime_schedules", am.EditAccess(aH.createDowntimeSchedule)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/downtime_schedules/{id}", am.EditAccess(aH.editDowntimeSchedule)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/downtime_schedules/{id}", am.EditAccess(aH.deleteDowntimeSchedule)).Methods(http.MethodDelete)
-
 	router.HandleFunc("/api/v1/dashboards", am.ViewAccess(aH.List)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/dashboards", am.EditAccess(aH.Signoz.Handlers.Dashboard.Create)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/dashboards/{id}", am.ViewAccess(aH.Get)).Methods(http.MethodGet)
@@ -603,26 +585,6 @@ func Intersection(a, b []int) (c []int) {
 	return
 }
 
-func (aH *APIHandler) getRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	ruleResponse, err := aH.ruleManager.GetRule(r.Context(), id)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
-		return
-	}
-	aH.Respond(w, ruleResponse)
-}
-
 // populateTemporality adds the temporality to the query if it is not present
 func (aH *APIHandler) PopulateTemporality(ctx context.Context, orgID valuer.UUID, qp *v3.QueryRangeParamsV3) error {
 
@@ -678,129 +640,6 @@ func (aH *APIHandler) PopulateTemporality(ctx context.Context, orgID valuer.UUID
 	return nil
 }
 
-func (aH *APIHandler) listDowntimeSchedules(w http.ResponseWriter, r *http.Request) {
-	claims, errv2 := authtypes.ClaimsFromContext(r.Context())
-	if errv2 != nil {
-		render.Error(w, errv2)
-		return
-	}
-
-	schedules, err := aH.ruleManager.MaintenanceStore().GetAllPlannedMaintenance(r.Context(), claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	// The schedules are stored as JSON in the database, so we need to filter them here
-	// Since the number of schedules is expected to be small, this should be fine
-
-	if r.URL.Query().Get("active") != "" {
-		activeSchedules := make([]*ruletypes.GettablePlannedMaintenance, 0)
-		active, _ := strconv.ParseBool(r.URL.Query().Get("active"))
-		for _, schedule := range schedules {
-			now := time.Now().In(time.FixedZone(schedule.Schedule.Timezone, 0))
-			if schedule.IsActive(now) == active {
-				activeSchedules = append(activeSchedules, schedule)
-			}
-		}
-		schedules = activeSchedules
-	}
-
-	if r.URL.Query().Get("recurring") != "" {
-		recurringSchedules := make([]*ruletypes.GettablePlannedMaintenance, 0)
-		recurring, _ := strconv.ParseBool(r.URL.Query().Get("recurring"))
-		for _, schedule := range schedules {
-			if schedule.IsRecurring() == recurring {
-				recurringSchedules = append(recurringSchedules, schedule)
-			}
-		}
-		schedules = recurringSchedules
-	}
-
-	aH.Respond(w, schedules)
-}
-
-func (aH *APIHandler) getDowntimeSchedule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error()))
-		return
-	}
-
-	schedule, err := aH.ruleManager.MaintenanceStore().GetPlannedMaintenanceByID(r.Context(), id)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	aH.Respond(w, schedule)
-}
-
-func (aH *APIHandler) createDowntimeSchedule(w http.ResponseWriter, r *http.Request) {
-	var schedule ruletypes.GettablePlannedMaintenance
-	err := json.NewDecoder(r.Body).Decode(&schedule)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-	if err := schedule.Validate(); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	_, err = aH.ruleManager.MaintenanceStore().CreatePlannedMaintenance(r.Context(), schedule)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	aH.Respond(w, nil)
-}
-
-func (aH *APIHandler) editDowntimeSchedule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error()))
-		return
-	}
-
-	var schedule ruletypes.GettablePlannedMaintenance
-	err = json.NewDecoder(r.Body).Decode(&schedule)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	if err := schedule.Validate(); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	err = aH.ruleManager.MaintenanceStore().EditPlannedMaintenance(r.Context(), schedule, id)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	aH.Respond(w, nil)
-}
-
-func (aH *APIHandler) deleteDowntimeSchedule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error()))
-		return
-	}
-
-	err = aH.ruleManager.MaintenanceStore().DeletePlannedMaintenance(r.Context(), id)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	aH.Respond(w, nil)
-}
-
 func (aH *APIHandler) getRuleStats(w http.ResponseWriter, r *http.Request) {
 	ruleID := mux.Vars(r)["id"]
 	params := model.QueryRuleStateHistory{}
@@ -1012,19 +851,6 @@ func (aH *APIHandler) getRuleStateHistoryTopContributors(w http.ResponseWriter,
 	aH.Respond(w, res)
 }
 
-func (aH *APIHandler) listRules(w http.ResponseWriter, r *http.Request) {
-
-	rules, err := aH.ruleManager.ListRuleStates(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
-		return
-	}
-
-	// todo(amol): need to add sorter
-
-	aH.Respond(w, rules)
-}
-
 func prepareQuery(r *http.Request) (string, error) {
 	var postData *model.DashboardVars
 
@@ -1226,142 +1052,6 @@ func (aH *APIHandler) queryDashboardVarsV2(w http.ResponseWriter, r *http.Reques
 	aH.Respond(w, dashboardVars)
 }
 
-func (aH *APIHandler) testRule(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for test rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
-	defer cancel()
-
-	alertCount, err := aH.ruleManager.TestNotification(ctx, orgID, string(body))
-	if err != nil {
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	response := map[string]interface{}{
-		"alertCount": alertCount,
-		"message":    "notification sent",
-	}
-	aH.Respond(w, response)
-}
-
-func (aH *APIHandler) deleteRule(w http.ResponseWriter, r *http.Request) {
-
-	id := mux.Vars(r)["id"]
-
-	err := aH.ruleManager.DeleteRule(r.Context(), id)
-
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, "rule successfully deleted")
-
-}
-
-// patchRule updates only requested changes in the rule
-func (aH *APIHandler) patchRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for patch rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	gettableRule, err := aH.ruleManager.PatchRule(r.Context(), string(body), id)
-
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, gettableRule)
-}
-
-func (aH *APIHandler) editRule(w http.ResponseWriter, r *http.Request) {
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for edit rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	err = aH.ruleManager.EditRule(r.Context(), string(body), id)
-
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
-			return
-		}
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, "rule successfully edited")
-
-}
-
-func (aH *APIHandler) createRule(w http.ResponseWriter, r *http.Request) {
-
-	defer r.Body.Close()
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for create rule", errors.Attr(err))
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
-		return
-	}
-
-	rule, err := aH.ruleManager.CreateRule(r.Context(), string(body))
-	if err != nil {
-		RespondError(w, toApiError(err), nil)
-		return
-	}
-
-	aH.Respond(w, rule)
-
-}
-
 func (aH *APIHandler) queryRangeMetrics(w http.ResponseWriter, r *http.Request) {
 
 	query, apiErrorObj := parseQueryRangeRequest(r)

pkg/query-service/app/server.go

@@ -9,24 +9,16 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 
 	"github.com/gorilla/handlers"
 
 	"github.com/rs/cors"
 	"github.com/soheilhy/cmux"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
 	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
@@ -34,10 +26,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/app/opamp"
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
-	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/signoz"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/web"
 
 	"log/slog"
@@ -47,15 +36,13 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
-	"github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
 
 // Server runs HTTP, Mux and a grpc server
 type Server struct {
-	config      signoz.Config
-	signoz      *signoz.SigNoz
-	ruleManager *rules.Manager
+	config signoz.Config
+	signoz *signoz.SigNoz
 
 	// public http router
 	httpConn     net.Listener
@@ -102,24 +89,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		nil,
 	)
 
-	rm, err := makeRulesManager(
-		reader,
-		signoz.Cache,
-		signoz.Alertmanager,
-		signoz.SQLStore,
-		signoz.TelemetryStore,
-		signoz.TelemetryMetadataStore,
-		signoz.Prometheus,
-		signoz.Modules.OrgGetter,
-		signoz.Modules.RuleStateHistory,
-		signoz.Querier,
-		signoz.Instrumentation.ToProviderSettings(),
-		signoz.QueryParser,
-	)
-	if err != nil {
-		return nil, err
-	}
-
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
 		signoz.SQLStore,
 		integrationsController.GetPipelinesForInstalledIntegrations,
@@ -131,7 +100,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	apiHandler, err := NewAPIHandler(APIHandlerOpts{
 		Reader:                        reader,
-		RuleManager:                   rm,
 		IntegrationsController:        integrationsController,
 		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
@@ -146,8 +114,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	s := &Server{
 		config:             config,
-		signoz:             signoz,
-		ruleManager:        rm,
+		signoz:       signoz,
 		httpHostPort:       constants.HTTPHostPort,
 		unavailableChannel: make(chan healthcheck.Status),
 	}
@@ -270,8 +237,6 @@ func (s *Server) initListeners() error {
 
 // Start listening on http and private http port concurrently
 func (s *Server) Start(ctx context.Context) error {
-	s.ruleManager.Start(ctx)
-
 	err := s.initListeners()
 	if err != nil {
 		return err
@@ -315,55 +280,6 @@ func (s *Server) Stop(ctx context.Context) error {
 
 	s.opampServer.Stop()
 
-	if s.ruleManager != nil {
-		s.ruleManager.Stop(ctx)
-	}
-
 	return nil
 }
 
-func makeRulesManager(
-	ch interfaces.Reader,
-	cache cache.Cache,
-	alertmanager alertmanager.Alertmanager,
-	sqlstore sqlstore.SQLStore,
-	telemetryStore telemetrystore.TelemetryStore,
-	metadataStore telemetrytypes.MetadataStore,
-	prometheus prometheus.Prometheus,
-	orgGetter organization.Getter,
-	ruleStateHistoryModule rulestatehistory.Module,
-	querier querier.Querier,
-	providerSettings factory.ProviderSettings,
-	queryParser queryparser.QueryParser,
-) (*rules.Manager, error) {
-	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
-	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
-	// create manager opts
-	managerOpts := &rules.ManagerOptions{
-		TelemetryStore:         telemetryStore,
-		MetadataStore:          metadataStore,
-		Prometheus:             prometheus,
-		Context:                context.Background(),
-		Querier:                querier,
-		Logger:                 providerSettings.Logger,
-		Cache:                  cache,
-		EvalDelay:              constants.GetEvalDelay(),
-		OrgGetter:              orgGetter,
-		Alertmanager:           alertmanager,
-		RuleStore:              ruleStore,
-		MaintenanceStore:       maintenanceStore,
-		SQLStore:               sqlstore,
-		QueryParser:            queryParser,
-		RuleStateHistoryModule: ruleStateHistoryModule,
-	}
-
-	// create Manager
-	manager, err := rules.NewManager(managerOpts)
-	if err != nil {
-		return nil, fmt.Errorf("rule manager error: %v", err)
-	}
-
-	slog.Info("rules manager is ready")
-
-	return manager, nil
-}

pkg/ruler/config.go

@@ -1,10 +1,13 @@
 package ruler
 
 import (
+	"time"
+
 	"github.com/SigNoz/signoz/pkg/factory"
 )
 
 type Config struct {
+	EvalDelay time.Duration `mapstructure:"eval_delay"`
 }
 
 func NewConfigFactory() factory.ConfigFactory {
@@ -12,7 +15,9 @@ func NewConfigFactory() factory.ConfigFactory {
 }
 
 func newConfig() factory.Config {
-	return Config{}
+	return Config{
+		EvalDelay: 2 * time.Minute,
+	}
 }
 
 func (c Config) Validate() error {

pkg/ruler/handler.go

@@ -0,0 +1,19 @@
+package ruler
+
+import "net/http"
+
+type Handler interface {
+	ListRules(http.ResponseWriter, *http.Request)
+	GetRuleByID(http.ResponseWriter, *http.Request)
+	CreateRule(http.ResponseWriter, *http.Request)
+	UpdateRuleByID(http.ResponseWriter, *http.Request)
+	DeleteRuleByID(http.ResponseWriter, *http.Request)
+	PatchRuleByID(http.ResponseWriter, *http.Request)
+	TestRule(http.ResponseWriter, *http.Request)
+
+	ListDowntimeSchedules(http.ResponseWriter, *http.Request)
+	GetDowntimeScheduleByID(http.ResponseWriter, *http.Request)
+	CreateDowntimeSchedule(http.ResponseWriter, *http.Request)
+	UpdateDowntimeScheduleByID(http.ResponseWriter, *http.Request)
+	DeleteDowntimeScheduleByID(http.ResponseWriter, *http.Request)
+}

pkg/ruler/ruler.go

@@ -1,7 +1,48 @@
 package ruler
 
-import "github.com/SigNoz/signoz/pkg/statsreporter"
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/statsreporter"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
 
 type Ruler interface {
+	factory.Service
 	statsreporter.StatsCollector
+
+	// ListRuleStates returns all rules with their current evaluation state.
+	ListRuleStates(ctx context.Context) (*ruletypes.GettableRules, error)
+
+	// GetRule returns a single rule by ID.
+	GetRule(ctx context.Context, id valuer.UUID) (*ruletypes.GettableRule, error)
+
+	// CreateRule persists a new rule from a JSON string and starts its evaluator.
+	// TODO: accept PostableRule instead of raw string; the manager currently unmarshals
+	// internally because it stores the raw JSON as Data. Requires changing the storage
+	// model to store structured data.
+	CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error)
+
+	// EditRule replaces the rule identified by id with the given JSON string.
+	// TODO: same as CreateRule — accept PostableRule instead of raw string.
+	EditRule(ctx context.Context, ruleStr string, id valuer.UUID) error
+
+	// DeleteRule removes the rule identified by the string ID.
+	// TODO: accept valuer.UUID instead of string for consistency with other methods.
+	DeleteRule(ctx context.Context, idStr string) error
+
+	// PatchRule applies a partial update to the rule identified by id.
+	// TODO: same as CreateRule — accept PostableRule instead of raw string.
+	PatchRule(ctx context.Context, ruleStr string, id valuer.UUID) (*ruletypes.GettableRule, error)
+
+	// TestNotification fires a test alert for the rule defined in ruleStr.
+	// TODO: same as CreateRule — accept PostableRule instead of raw string.
+	TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error)
+
+	// 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
 }

pkg/ruler/signozruler/handler.go

@@ -0,0 +1,311 @@
+package signozruler
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"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/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/gorilla/mux"
+)
+
+type handler struct {
+	ruler ruler.Ruler
+}
+
+func NewHandler(ruler ruler.Ruler) ruler.Handler {
+	return &handler{ruler: ruler}
+}
+
+func (handler *handler) ListRules(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	rules, err := handler.ruler.ListRuleStates(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, rules)
+}
+
+func (handler *handler) GetRuleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	rule, err := handler.ruler.GetRule(ctx, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, rule)
+}
+
+func (handler *handler) CreateRule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	rule, err := handler.ruler.CreateRule(ctx, string(body))
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, rule)
+}
+
+func (handler *handler) UpdateRuleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	err = handler.ruler.EditRule(ctx, string(body), id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) DeleteRuleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	idStr := mux.Vars(req)["id"]
+
+	err := handler.ruler.DeleteRule(ctx, idStr)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) PatchRuleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	rule, err := handler.ruler.PatchRule(ctx, string(body), id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, rule)
+}
+
+func (handler *handler) TestRule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 1*time.Minute)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	alertCount, err := handler.ruler.TestNotification(ctx, orgID, string(body))
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, map[string]any{"alertCount": alertCount, "message": "notification sent"})
+}
+
+func (handler *handler) ListDowntimeSchedules(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	schedules, err := handler.ruler.MaintenanceStore().GetAllPlannedMaintenance(ctx, claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if req.URL.Query().Get("active") != "" {
+		activeSchedules := make([]*ruletypes.GettablePlannedMaintenance, 0)
+		active, _ := strconv.ParseBool(req.URL.Query().Get("active"))
+		for _, schedule := range schedules {
+			now := time.Now().In(time.FixedZone(schedule.Schedule.Timezone, 0))
+			if schedule.IsActive(now) == active {
+				activeSchedules = append(activeSchedules, schedule)
+			}
+		}
+		schedules = activeSchedules
+	}
+
+	if req.URL.Query().Get("recurring") != "" {
+		recurringSchedules := make([]*ruletypes.GettablePlannedMaintenance, 0)
+		recurring, _ := strconv.ParseBool(req.URL.Query().Get("recurring"))
+		for _, schedule := range schedules {
+			if schedule.IsRecurring() == recurring {
+				recurringSchedules = append(recurringSchedules, schedule)
+			}
+		}
+		schedules = recurringSchedules
+	}
+
+	render.Success(rw, http.StatusOK, schedules)
+}
+
+func (handler *handler) GetDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	schedule, err := handler.ruler.MaintenanceStore().GetPlannedMaintenanceByID(ctx, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, schedule)
+}
+
+func (handler *handler) CreateDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	var schedule ruletypes.GettablePlannedMaintenance
+	if err := binding.JSON.BindBody(req.Body, &schedule); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := schedule.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	_, err := handler.ruler.MaintenanceStore().CreatePlannedMaintenance(ctx, schedule)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, nil)
+}
+
+func (handler *handler) UpdateDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	var schedule ruletypes.GettablePlannedMaintenance
+	if err := binding.JSON.BindBody(req.Body, &schedule); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := schedule.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = handler.ruler.MaintenanceStore().EditPlannedMaintenance(ctx, schedule, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) DeleteDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	err = handler.ruler.MaintenanceStore().DeletePlannedMaintenance(ctx, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}

pkg/ruler/signozruler/provider.go

@@ -3,27 +3,87 @@ package signozruler
 import (
 	"context"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
+	"github.com/SigNoz/signoz/pkg/prometheus"
+	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/ruler"
 	"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/ruletypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 type provider struct {
+	manager   *rules.Manager
 	ruleStore ruletypes.RuleStore
+	stopC     chan struct{}
 }
 
-func NewFactory(sqlstore sqlstore.SQLStore, queryParser queryparser.QueryParser) factory.ProviderFactory[ruler.Ruler, ruler.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, settings factory.ProviderSettings, config ruler.Config) (ruler.Ruler, error) {
-		return New(ctx, settings, config, sqlstore, queryParser)
+func NewFactory(
+	cache cache.Cache,
+	alertmanager alertmanager.Alertmanager,
+	sqlstore sqlstore.SQLStore,
+	telemetryStore telemetrystore.TelemetryStore,
+	metadataStore telemetrytypes.MetadataStore,
+	prometheus prometheus.Prometheus,
+	orgGetter organization.Getter,
+	ruleStateHistoryModule rulestatehistory.Module,
+	querier querier.Querier,
+	queryParser queryparser.QueryParser,
+	prepareTaskFunc func(rules.PrepareTaskOptions) (rules.Task, error),
+	prepareTestRuleFunc func(rules.PrepareTestRuleOptions) (int, error),
+) 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)
+
+		managerOpts := &rules.ManagerOptions{
+			TelemetryStore:         telemetryStore,
+			MetadataStore:          metadataStore,
+			Prometheus:             prometheus,
+			Context:                context.Background(),
+			Querier:                querier,
+			Logger:                 providerSettings.Logger,
+			Cache:                  cache,
+			EvalDelay:              valuer.MustParseTextDuration(config.EvalDelay.String()),
+			PrepareTaskFunc:        prepareTaskFunc,
+			PrepareTestRuleFunc:    prepareTestRuleFunc,
+			Alertmanager:           alertmanager,
+			OrgGetter:              orgGetter,
+			RuleStore:              ruleStore,
+			MaintenanceStore:       maintenanceStore,
+			SQLStore:               sqlstore,
+			QueryParser:            queryParser,
+			RuleStateHistoryModule: ruleStateHistoryModule,
+		}
+
+		manager, err := rules.NewManager(managerOpts)
+		if err != nil {
+			return nil, err
+		}
+
+		return &provider{manager: manager, ruleStore: ruleStore, stopC: make(chan struct{})}, nil
 	})
 }
 
-func New(ctx context.Context, settings factory.ProviderSettings, config ruler.Config, sqlstore sqlstore.SQLStore, queryParser queryparser.QueryParser) (ruler.Ruler, error) {
-	return &provider{ruleStore: sqlrulestore.NewRuleStore(sqlstore, queryParser, settings)}, nil
+func (provider *provider) Start(ctx context.Context) error {
+	provider.manager.Start(ctx)
+	<-provider.stopC
+	return nil
+}
+
+func (provider *provider) Stop(ctx context.Context) error {
+	close(provider.stopC)
+	provider.manager.Stop(ctx)
+	return nil
 }
 
 func (provider *provider) Collect(ctx context.Context, orgID valuer.UUID) (map[string]any, error) {
@@ -34,3 +94,35 @@ func (provider *provider) Collect(ctx context.Context, orgID valuer.UUID) (map[s
 
 	return ruletypes.NewStatsFromRules(rules), nil
 }
+
+func (provider *provider) ListRuleStates(ctx context.Context) (*ruletypes.GettableRules, error) {
+	return provider.manager.ListRuleStates(ctx)
+}
+
+func (provider *provider) GetRule(ctx context.Context, id valuer.UUID) (*ruletypes.GettableRule, error) {
+	return provider.manager.GetRule(ctx, id)
+}
+
+func (provider *provider) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error) {
+	return provider.manager.CreateRule(ctx, ruleStr)
+}
+
+func (provider *provider) EditRule(ctx context.Context, ruleStr string, id valuer.UUID) error {
+	return provider.manager.EditRule(ctx, ruleStr, id)
+}
+
+func (provider *provider) DeleteRule(ctx context.Context, idStr string) error {
+	return provider.manager.DeleteRule(ctx, idStr)
+}
+
+func (provider *provider) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID) (*ruletypes.GettableRule, error) {
+	return provider.manager.PatchRule(ctx, ruleStr, id)
+}
+
+func (provider *provider) TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error) {
+	return provider.manager.TestNotification(ctx, orgID, ruleStr)
+}
+
+func (provider *provider) MaintenanceStore() ruletypes.MaintenanceStore {
+	return provider.manager.MaintenanceStore()
+}

pkg/signoz/handler.go

@@ -3,6 +3,8 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/signozauthzapi"
@@ -65,6 +67,7 @@ type Handlers struct {
 	CloudIntegrationHandler cloudintegration.Handler
 	RuleStateHistory        rulestatehistory.Handler
 	AlertmanagerHandler     alertmanager.Handler
+	RulerHandler            ruler.Handler
 }
 
 func NewHandlers(
@@ -81,6 +84,7 @@ func NewHandlers(
 	zeusService zeus.Zeus,
 	registryHandler factory.Handler,
 	alertmanagerService alertmanager.Alertmanager,
+	rulerService ruler.Ruler,
 ) Handlers {
 	return Handlers{
 		SavedView:               implsavedview.NewHandler(modules.SavedView),
@@ -104,5 +108,6 @@ func NewHandlers(
 		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
 		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
 		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
+		RulerHandler:            signozruler.NewHandler(rulerService),
 	}
 }

pkg/signoz/handler_test.go

@@ -56,7 +56,7 @@ func TestNewHandlers(t *testing.T) {
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
 	registryHandler := factory.NewHandler(nil)
-	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler, alertmanager)
+	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler, alertmanager, nil)
 	reflectVal := reflect.ValueOf(handlers)
 	for i := 0; i < reflectVal.NumField(); i++ {
 		f := reflectVal.Field(i)

pkg/signoz/openapi.go

@@ -31,6 +31,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/ruler"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/swaggest/jsonschema-go"
@@ -71,6 +72,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
 		struct{ alertmanager.Handler }{},
+		struct{ ruler.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -44,9 +44,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/querier/signozquerier"
-	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/sharder/noopsharder"
 	"github.com/SigNoz/signoz/pkg/sharder/singlesharder"
@@ -229,11 +226,7 @@ func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter orga
 	)
 }
 
-func NewRulerProviderFactories(sqlstore sqlstore.SQLStore, queryParser queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
-	return factory.MustNewNamedMap(
-		signozruler.NewFactory(sqlstore, queryParser),
-	)
-}
+
 
 func NewEmailingProviderFactories() factory.NamedMap[factory.ProviderFactory[emailing.Emailing, emailing.Config]] {
 	return factory.MustNewNamedMap(
@@ -289,6 +282,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
 			handlers.AlertmanagerHandler,
+			handlers.RulerHandler,
 		),
 	)
 }

pkg/signoz/provider_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
-	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlschema/sqlschematest"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -64,11 +63,6 @@ func TestNewProviderFactories(t *testing.T) {
 		NewAlertmanagerProviderFactories(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), orgGetter, notificationManager)
 	})
 
-	assert.NotPanics(t, func() {
-		queryParser := queryparser.New(instrumentationtest.New().ToProviderSettings())
-		NewRulerProviderFactories(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), queryParser)
-	})
-
 	assert.NotPanics(t, func() {
 		NewEmailingProviderFactories()
 	})

pkg/signoz/signoz.go

@@ -26,12 +26,14 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
+	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/sqlmigration"
 	"github.com/SigNoz/signoz/pkg/sqlmigrator"
@@ -75,6 +77,7 @@ type SigNoz struct {
 	Tokenizer              pkgtokenizer.Tokenizer
 	IdentNResolver         identn.IdentNResolver
 	Authz                  authz.AuthZ
+	Ruler                  ruler.Ruler
 	Modules                Modules
 	Handlers               Handlers
 	QueryParser            queryparser.QueryParser
@@ -103,6 +106,7 @@ func New(
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
 	querierHandlerCallback func(factory.ProviderSettings, querier.Querier, analytics.Analytics) querier.Handler,
 	cloudIntegrationCallback func(sqlstore.SQLStore, global.Global, zeus.Zeus, gateway.Gateway, licensing.Licensing, serviceaccount.Module, cloudintegration.Config) (cloudintegration.Module, error),
+	rulerProviderFactories func(cache.Cache, alertmanager.Alertmanager, sqlstore.SQLStore, telemetrystore.TelemetryStore, telemetrytypes.MetadataStore, prometheus.Prometheus, organization.Getter, rulestatehistory.Module, querier.Querier, queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]],
 ) (*SigNoz, error) {
 	// Initialize instrumentation
 	instrumentation, err := instrumentation.New(ctx, config.Instrumentation, version.Info, "signoz")
@@ -361,18 +365,6 @@ func New(
 		return nil, err
 	}
 
-	// Initialize ruler from the available ruler provider factories
-	ruler, err := factory.NewProviderFromNamedMap(
-		ctx,
-		providerSettings,
-		config.Ruler,
-		NewRulerProviderFactories(sqlstore, queryParser),
-		"signoz",
-	)
-	if err != nil {
-		return nil, err
-	}
-
 	gatewayFactory := gatewayProviderFactory(licensing)
 	gateway, err := gatewayFactory.New(ctx, providerSettings, config.Gateway)
 	if err != nil {
@@ -441,6 +433,12 @@ func New(
 	// Initialize all modules
 	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, userGetter, userRoleStore, serviceAccount, cloudIntegrationModule)
 
+	// Initialize ruler from the variant-specific provider factories
+	rulerInstance, err := factory.NewProviderFromNamedMap(ctx, providerSettings, config.Ruler, rulerProviderFactories(cache, alertmanager, sqlstore, telemetrystore, telemetryMetadataStore, prometheus, orgGetter, modules.RuleStateHistory, querier, queryParser), "signoz")
+	if err != nil {
+		return nil, err
+	}
+
 	// Initialize identN resolver
 	identNFactories := NewIdentNProviderFactories(tokenizer, serviceAccount, orgGetter, userGetter, config.User)
 	identNResolver, err := identn.NewIdentNResolver(ctx, providerSettings, config.IdentN, identNFactories)
@@ -456,7 +454,7 @@ func New(
 	// Create a list of all stats collectors
 	statsCollectors := []statsreporter.StatsCollector{
 		alertmanager,
-		ruler,
+		rulerInstance,
 		modules.Dashboard,
 		modules.SavedView,
 		modules.UserSetter,
@@ -493,6 +491,7 @@ func New(
 		factory.NewNamedService(factory.MustNewName("authz"), authz),
 		factory.NewNamedService(factory.MustNewName("user"), userService, factory.MustNewName("authz")),
 		factory.NewNamedService(factory.MustNewName("auditor"), auditor),
+		factory.NewNamedService(factory.MustNewName("ruler"), rulerInstance),
 	)
 	if err != nil {
 		return nil, err
@@ -500,7 +499,7 @@ func New(
 
 	// Initialize all handlers for the modules
 	registryHandler := factory.NewHandler(registry)
-	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler, alertmanager)
+	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler, alertmanager, rulerInstance)
 
 	// Initialize the API server (after registry so it can access service health)
 	apiserverInstance, err := factory.NewProviderFromNamedMap(
@@ -534,6 +533,7 @@ func New(
 		Tokenizer:              tokenizer,
 		IdentNResolver:         identNResolver,
 		Authz:                  authz,
+		Ruler:                  rulerInstance,
 		Modules:                modules,
 		Handlers:               handlers,
 		QueryParser:            queryParser,

pkg/templating/markdownrenderer/html.go

@@ -1,28 +0,0 @@
-package markdownrenderer
-
-import (
-	"bytes"
-	"context"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-// SoftLineBreakHTML is a HTML tag that is used to represent a soft line break.
-const SoftLineBreakHTML = `<p></p>`
-
-func (r *markdownRenderer) renderHTML(_ context.Context, markdown string) (string, error) {
-	var buf bytes.Buffer
-	if err := newHTMLRenderer().Convert([]byte(markdown), &buf); err != nil {
-		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to HTML")
-	}
-
-	// return buf.String(), nil
-
-	// TODO: check if there is another way to handle soft line breaks in HTML
-	// the idea with paragraph tags is that it will start the content in new
-	// line without using a line break tag, this works well in variety of cases
-	// but not all, for example, in case of code block, the paragraph tags will be added
-	// to the code block where newline is present.
-	return strings.ReplaceAll(buf.String(), "\n", SoftLineBreakHTML), nil
-}

pkg/templating/markdownrenderer/html_test.go

@@ -1,182 +0,0 @@
-package markdownrenderer
-
-import (
-	"context"
-	"log/slog"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var (
-	testMarkdown = `# 🔥 FIRING: High CPU Usage on api-gateway
-
-https://signoz.example.com/alerts/123
-https://runbooks.example.com/cpu-high
-
-## Alert Details
-
-**Status:** **FIRING** | *api-gateway* service is experiencing high CPU usage. ~~resolved~~ previously.
-
-Alert triggered because ` + "`cpu_usage_percent`" + ` exceeded threshold ` + "`90`" + `.
-
-[View Alert in SigNoz](https://signoz.example.com/alerts/123) | [View Logs](https://signoz.example.com/logs?service=api-gateway) | [View Traces](https://signoz.example.com/traces?service=api-gateway)
-
-![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")
-
-## Alert Labels
-
-| Label    | Value       |
-| -------- | ----------- |
-| service  | api-gateway |
-| instance | pod-5a8b3c  |
-| severity | critical    |
-| region   | us-east-1   |
-
-## Remediation Steps
-
-1. Check current CPU usage on the pod
-2. Review recent deployments for regressions
-3. Scale horizontally if load-related
-    1. Increase replica count
-    2. Verify HPA configuration
-
-## Affected Services
-
-* api-gateway
-* auth-service
-* payment-service
-    * payment-processor
-    * payment-validator
-
-## Incident Checklist
-
-- [x] Alert acknowledged
-- [x] On-call notified
-- [ ] Root cause identified
-- [ ] Fix deployed
-
-## Alert Rule Description
-
-> This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.
->
->> For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.
-
-## Triggered Query
-` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```" + `
-
-## Inline Details
-
-This alert was generated by SigNoz using ` + "`alertmanager`" + ` rules engine.
-`
-)
-
-func newTestRenderer() MarkdownRenderer {
-	return NewMarkdownRenderer(slog.New(slog.NewTextHandler(os.Stdout, nil)))
-}
-
-func TestRenderHTML_Composite(t *testing.T) {
-	renderer := newTestRenderer()
-
-	html, err := renderer.Render(context.Background(), testMarkdown, MarkdownFormatHTML)
-	require.NoError(t, err)
-
-	// Full expected output for exact match
-	expected := `<h1>🔥 FIRING: High CPU Usage on api-gateway</h1><p></p>` +
-		`<p><a href="https://signoz.example.com/alerts/123">https://signoz.example.com/alerts/123</a><p></p><a href="https://runbooks.example.com/cpu-high">https://runbooks.example.com/cpu-high</a></p><p></p>` +
-		`<h2>Alert Details</h2><p></p>` +
-		`<p><strong>Status:</strong> <strong>FIRING</strong> | <em>api-gateway</em> service is experiencing high CPU usage. <del>resolved</del> previously.</p><p></p>` +
-		`<p>Alert triggered because <code>cpu_usage_percent</code> exceeded threshold <code>90</code>.</p><p></p>` +
-		`<p><a href="https://signoz.example.com/alerts/123">View Alert in SigNoz</a> | <a href="https://signoz.example.com/logs?service=api-gateway">View Logs</a> | <a href="https://signoz.example.com/traces?service=api-gateway">View Traces</a></p><p></p>` +
-		`<p><img src="https://signoz.example.com/badges/critical.svg" alt="critical" title="Critical Alert"></p><p></p>` +
-		`<h2>Alert Labels</h2><p></p>` +
-		`<table><p></p><thead><p></p><tr><p></p><th>Label</th><p></p><th>Value</th><p></p></tr><p></p></thead><p></p>` +
-		`<tbody><p></p><tr><p></p><td>service</td><p></p><td>api-gateway</td><p></p></tr><p></p>` +
-		`<tr><p></p><td>instance</td><p></p><td>pod-5a8b3c</td><p></p></tr><p></p>` +
-		`<tr><p></p><td>severity</td><p></p><td>critical</td><p></p></tr><p></p>` +
-		`<tr><p></p><td>region</td><p></p><td>us-east-1</td><p></p></tr><p></p></tbody><p></p></table><p></p>` +
-		`<h2>Remediation Steps</h2><p></p>` +
-		`<ol><p></p><li>Check current CPU usage on the pod</li><p></p><li>Review recent deployments for regressions</li><p></p><li>Scale horizontally if load-related<p></p>` +
-		`<ol><p></p><li>Increase replica count</li><p></p><li>Verify HPA configuration</li><p></p></ol><p></p></li><p></p></ol><p></p>` +
-		`<h2>Affected Services</h2><p></p>` +
-		`<ul><p></p><li>api-gateway</li><p></p><li>auth-service</li><p></p><li>payment-service<p></p>` +
-		`<ul><p></p><li>payment-processor</li><p></p><li>payment-validator</li><p></p></ul><p></p></li><p></p></ul><p></p>` +
-		`<h2>Incident Checklist</h2><p></p>` +
-		`<ul><p></p><li><input checked="" disabled="" type="checkbox"> Alert acknowledged</li><p></p>` +
-		`<li><input checked="" disabled="" type="checkbox"> On-call notified</li><p></p>` +
-		`<li><input disabled="" type="checkbox"> Root cause identified</li><p></p>` +
-		`<li><input disabled="" type="checkbox"> Fix deployed</li><p></p></ul><p></p>` +
-		`<h2>Alert Rule Description</h2><p></p>` +
-		`<blockquote><p></p><p>This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.</p><p></p>` +
-		`<blockquote><p></p><p>For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.</p><p></p></blockquote><p></p></blockquote><p></p>` +
-		`<h2>Triggered Query</h2><p></p>` +
-		`<pre><code class="language-promql">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9<p></p></code></pre><p></p>` +
-		`<h2>Inline Details</h2><p></p>` +
-		`<p>This alert was generated by SigNoz using <code>alertmanager</code> rules engine.</p><p></p>`
-
-	assert.Equal(t, expected, html)
-}
-
-func TestRenderHTML_InlineFormatting(t *testing.T) {
-	renderer := newTestRenderer()
-
-	input := `# 🔥 FIRING: High CPU on api-gateway
-## Alert Status
-
-**FIRING** alert for *api-gateway* service — ~~resolved~~ previously.
-
-Metric ` + "`cpu_usage_percent`" + ` exceeded threshold. [View in SigNoz](https://signoz.example.com/alerts/123)
-
-![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")`
-
-	html, err := renderer.Render(context.Background(), input, MarkdownFormatHTML)
-	require.NoError(t, err)
-
-	expected := `<h1>🔥 FIRING: High CPU on api-gateway</h1><p></p><h2>Alert Status</h2><p></p>` +
-		`<p><strong>FIRING</strong> alert for <em>api-gateway</em> service — <del>resolved</del> previously.</p><p></p>` +
-		`<p>Metric <code>cpu_usage_percent</code> exceeded threshold. <a href="https://signoz.example.com/alerts/123">View in SigNoz</a></p><p></p>` +
-		`<p><img src="https://signoz.example.com/badges/critical.svg" alt="critical" title="Critical Alert"></p><p></p>`
-
-	assert.Equal(t, expected, html)
-}
-
-func TestRenderHTML_BlockElements(t *testing.T) {
-	renderer := newTestRenderer()
-
-	input := `1. Check CPU usage on the pod
-2. Review recent deployments
-3. Scale horizontally if needed
-
-* api-gateway
-* auth-service
-* payment-service
-
-- [x] Alert acknowledged
-- [ ] Root cause identified
-
-> This alert fires when CPU usage exceeds 90% for more than 5 minutes.
-
-| Label    | Value       |
-| -------- | ----------- |
-| service  | api-gateway |
-| severity | <no value>    |
-
-` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```"
-
-	html, err := renderer.Render(context.Background(), input, MarkdownFormatHTML)
-	require.NoError(t, err)
-
-	expected := `<ol><p></p><li>Check CPU usage on the pod</li><p></p><li>Review recent deployments</li><p></p><li>Scale horizontally if needed</li><p></p></ol><p></p>` +
-		`<ul><p></p><li>api-gateway</li><p></p><li>auth-service</li><p></p><li>payment-service</li><p></p></ul><p></p>` +
-		`<ul><p></p><li><input checked="" disabled="" type="checkbox"> Alert acknowledged</li><p></p>` +
-		`<li><input disabled="" type="checkbox"> Root cause identified</li><p></p></ul><p></p>` +
-		`<blockquote><p></p><p>This alert fires when CPU usage exceeds 90% for more than 5 minutes.</p><p></p></blockquote><p></p>` +
-		`<table><p></p><thead><p></p><tr><p></p><th>Label</th><p></p><th>Value</th><p></p></tr><p></p></thead><p></p>` +
-		`<tbody><p></p><tr><p></p><td>service</td><p></p><td>api-gateway</td><p></p></tr><p></p>` +
-		`<tr><p></p><td>severity</td><p></p><td>&lt;no value&gt;</td><p></p></tr><p></p></tbody><p></p></table><p></p>` +
-		`<pre><code class="language-promql">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9<p></p></code></pre><p></p>`
-
-	assert.Equal(t, expected, html)
-}

pkg/templating/markdownrenderer/markdownrenderer.go

@@ -1,75 +0,0 @@
-package markdownrenderer
-
-import (
-	"context"
-	"log/slog"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/templating/slackblockkitrenderer"
-	"github.com/SigNoz/signoz/pkg/templating/slackmrkdwnrenderer"
-	"github.com/SigNoz/signoz/pkg/templating/templatingextensions"
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-)
-
-// newHTMLRenderer creates a new goldmark.Markdown instance for HTML rendering.
-func newHTMLRenderer() goldmark.Markdown {
-	return goldmark.New(
-		goldmark.WithExtensions(extension.GFM),
-		goldmark.WithExtensions(templatingextensions.EscapeNoValue),
-	)
-}
-
-// newSlackBlockKitRenderer creates a new goldmark.Markdown instance for Slack Block Kit rendering.
-func newSlackBlockKitRenderer() goldmark.Markdown {
-	return goldmark.New(
-		goldmark.WithExtensions(slackblockkitrenderer.BlockKitV2),
-	)
-}
-
-// newSlackMrkdwnRenderer creates a new goldmark.Markdown instance for Slack mrkdwn rendering.
-func newSlackMrkdwnRenderer() goldmark.Markdown {
-	return goldmark.New(
-		goldmark.WithExtensions(slackmrkdwnrenderer.SlackMrkdwn),
-	)
-}
-
-type OutputFormat int
-
-const (
-	MarkdownFormatHTML OutputFormat = iota
-	MarkdownFormatSlackBlockKit
-	MarkdownFormatSlackMrkdwn
-	MarkdownFormatNoop
-)
-
-// MarkdownRenderer is the interface for rendering markdown to different formats.
-type MarkdownRenderer interface {
-	// Render renders the markdown to the given output format.
-	Render(ctx context.Context, markdown string, outputFormat OutputFormat) (string, error)
-}
-
-type markdownRenderer struct {
-	logger *slog.Logger
-}
-
-func NewMarkdownRenderer(logger *slog.Logger) MarkdownRenderer {
-	return &markdownRenderer{
-		logger: logger,
-	}
-}
-
-func (r *markdownRenderer) Render(ctx context.Context, markdown string, outputFormat OutputFormat) (string, error) {
-	switch outputFormat {
-	case MarkdownFormatHTML:
-		return r.renderHTML(ctx, markdown)
-	case MarkdownFormatSlackBlockKit:
-		return r.renderSlackBlockKit(ctx, markdown)
-	case MarkdownFormatSlackMrkdwn:
-		return r.renderSlackMrkdwn(ctx, markdown)
-	case MarkdownFormatNoop:
-		return markdown, nil
-	default:
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown output format: %v", outputFormat)
-	}
-}

pkg/templating/markdownrenderer/noop_test.go

@@ -1,17 +0,0 @@
-package markdownrenderer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestRenderNoop(t *testing.T) {
-	renderer := newTestRenderer()
-
-	output, err := renderer.Render(context.Background(), testMarkdown, MarkdownFormatNoop)
-	require.NoError(t, err)
-	assert.Equal(t, testMarkdown, output)
-}

pkg/templating/markdownrenderer/slack.go

@@ -1,24 +0,0 @@
-package markdownrenderer
-
-import (
-	"bytes"
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-func (r *markdownRenderer) renderSlackBlockKit(_ context.Context, markdown string) (string, error) {
-	var buf bytes.Buffer
-	if err := newSlackBlockKitRenderer().Convert([]byte(markdown), &buf); err != nil {
-		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to Slack Block Kit")
-	}
-	return buf.String(), nil
-}
-
-func (r *markdownRenderer) renderSlackMrkdwn(_ context.Context, markdown string) (string, error) {
-	var buf bytes.Buffer
-	if err := newSlackMrkdwnRenderer().Convert([]byte(markdown), &buf); err != nil {
-		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to Slack Mrkdwn")
-	}
-	return buf.String(), nil
-}

pkg/templating/markdownrenderer/slack_test.go

@@ -1,152 +0,0 @@
-package markdownrenderer
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"testing"
-)
-
-func jsonEqual(a, b string) bool {
-	var va, vb any
-	if err := json.Unmarshal([]byte(a), &va); err != nil {
-		return false
-	}
-	if err := json.Unmarshal([]byte(b), &vb); err != nil {
-		return false
-	}
-	ja, _ := json.Marshal(va)
-	jb, _ := json.Marshal(vb)
-	return string(ja) == string(jb)
-}
-
-func prettyJSON(s string) string {
-	var v any
-	if err := json.Unmarshal([]byte(s), &v); err != nil {
-		return s
-	}
-	b, _ := json.MarshalIndent(v, "", "  ")
-	return string(b)
-}
-
-func TestRenderSlackBlockKit(t *testing.T) {
-	renderer := NewMarkdownRenderer(slog.Default())
-
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "simple paragraph",
-			markdown: "Hello world",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Hello world" }
-				}
-			]`,
-		},
-		{
-			name: "alert-themed with heading, list, and code block",
-			markdown: `# Alert Triggered
-
-- Service: **checkout-api**
-- Status: _critical_
-
-` + "```" + `
-error: connection timeout after 30s
-` + "```",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "*Alert Triggered*" }
-				},
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [
-									{ "type": "text", "text": "Service: " },
-									{ "type": "text", "text": "checkout-api", "style": { "bold": true } }
-								]},
-								{ "type": "rich_text_section", "elements": [
-									{ "type": "text", "text": "Status: " },
-									{ "type": "text", "text": "critical", "style": { "italic": true } }
-								]}
-							]
-						}
-					]
-				},
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": "error: connection timeout after 30s" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := renderer.Render(context.Background(), tt.markdown, MarkdownFormatSlackBlockKit)
-			if err != nil {
-				t.Fatalf("Render error: %v", err)
-			}
-
-			// Verify output is valid JSON
-			if !json.Valid([]byte(got)) {
-				t.Fatalf("output is not valid JSON:\n%s", got)
-			}
-
-			if !jsonEqual(got, tt.expected) {
-				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
-					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
-			}
-		})
-	}
-}
-
-func TestRenderSlackMrkdwn(t *testing.T) {
-	renderer := NewMarkdownRenderer(slog.Default())
-
-	markdown := `# Alert Triggered
-
-- Service: **checkout-api**
-- Status: _critical_
-- Dashboard: [View Dashboard](https://example.com/dashboard)
-
-| Metric | Value | Threshold |
-| --- | --- | --- |
-| Latency | 250ms | 100ms |
-| Error Rate | 5.2% | 1% |
-
-` + "```" + `
-error: connection timeout after 30s
-` + "```"
-
-	expected := "*Alert Triggered*\n\n" +
-		"• Service: *checkout-api*\n" +
-		"• Status: _critical_\n" +
-		"• Dashboard: <https://example.com/dashboard|View Dashboard>\n\n" +
-		"```\nMetric     | Value | Threshold\n-----------|-------|----------\nLatency    | 250ms | 100ms    \nError Rate | 5.2%  | 1%       \n```\n\n" +
-		"```\nerror: connection timeout after 30s\n```\n\n"
-
-	got, err := renderer.Render(context.Background(), markdown, MarkdownFormatSlackMrkdwn)
-	if err != nil {
-		t.Fatalf("Render error: %v", err)
-	}
-
-	if got != expected {
-		t.Errorf("mrkdwn mismatch\n\nExpected:\n%q\n\nGot:\n%q", expected, got)
-	}
-}

pkg/templating/slackblockkitrenderer/extender.go

@@ -1,23 +0,0 @@
-package slackblockkitrenderer
-
-import (
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-type blockKitV2 struct{}
-
-// BlockKitV2 is a goldmark.Extender that configures the Slack Block Kit v2 renderer.
-var BlockKitV2 = &blockKitV2{}
-
-// Extend implements goldmark.Extender.
-func (e *blockKitV2) Extend(m goldmark.Markdown) {
-	extension.Table.Extend(m)
-	extension.Strikethrough.Extend(m)
-	extension.TaskList.Extend(m)
-	m.Renderer().AddOptions(
-		renderer.WithNodeRenderers(util.Prioritized(NewRenderer(), 1)),
-	)
-}

pkg/templating/slackblockkitrenderer/renderer_test.go

@@ -1,542 +0,0 @@
-package slackblockkitrenderer
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/yuin/goldmark"
-)
-
-func jsonEqual(a, b string) bool {
-	var va, vb interface{}
-	if err := json.Unmarshal([]byte(a), &va); err != nil {
-		return false
-	}
-	if err := json.Unmarshal([]byte(b), &vb); err != nil {
-		return false
-	}
-	ja, _ := json.Marshal(va)
-	jb, _ := json.Marshal(vb)
-	return string(ja) == string(jb)
-}
-
-func prettyJSON(s string) string {
-	var v interface{}
-	if err := json.Unmarshal([]byte(s), &v); err != nil {
-		return s
-	}
-	b, _ := json.MarshalIndent(v, "", "  ")
-	return string(b)
-}
-
-func TestRenderer(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "empty input",
-			markdown: "",
-			expected: `[]`,
-		},
-		{
-			name:     "simple paragraph",
-			markdown: "Hello world",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Hello world" }
-				}
-			]`,
-		},
-		{
-			name:     "heading",
-			markdown: "# My Heading",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "*My Heading*" }
-				}
-			]`,
-		},
-		{
-			name:     "multiple paragraphs",
-			markdown: "First paragraph\n\nSecond paragraph",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "First paragraph\nSecond paragraph" }
-				}
-			]`,
-		},
-		{
-			name:     "todo list ",
-			markdown: "- [ ] item 1\n- [x] item 2",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-					{ 
-						"border": 0, 
-						"elements": [ 
-							{ "elements": [ { "text": "[ ] ", "type": "text" }, { "text": "item 1", "type": "text" } ], "type": "rich_text_section" }, 
-							{ "elements": [ { "text": "[x] ", "type": "text" }, { "text": "item 2", "type": "text" } ], "type": "rich_text_section" } 
-						],
-						"indent": 0, 
-						"style": "bullet", 
-						"type": "rich_text_list" 
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "thematic break between paragraphs",
-			markdown: "Before\n\n---\n\nAfter",
-			expected: `[
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
-				{ "type": "divider" },
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
-			]`,
-		},
-		{
-			name:     "fenced code block with language",
-			markdown: "```go\nfmt.Println(\"hello\")\n```",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"language": "go",
-							"elements": [
-								{ "type": "text", "text": "fmt.Println(\"hello\")" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "indented code block",
-			markdown: "    code line 1\n    code line 2",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": "code line 1\ncode line 2" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "empty fenced code block",
-			markdown: "```\n```",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": " " }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "simple bullet list",
-			markdown: "- item 1\n- item 2\n- item 3",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "simple ordered list",
-			markdown: "1. first\n2. second\n3. third",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "nested bullet list (2 levels)",
-			markdown: "- item 1\n- item 2\n  - sub a\n  - sub b\n- item 3",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub a" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub b" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "nested ordered list with offset",
-			markdown: "1. first\n   1. nested-a\n   2. nested-b\n2. second\n3. third",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-a" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-b" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "mixed ordered/bullet nesting",
-			markdown: "1. ordered\n   - bullet child\n2. ordered again",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bullet child" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered again" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "list items with bold/italic/link/code",
-			markdown: "- **bold item**\n- _italic item_\n- [link](http://example.com)\n- `code item`",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bold item", "style": { "bold": true } }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "italic item", "style": { "italic": true } }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "link" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "code item", "style": { "code": true } }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with header and body",
-			markdown: "| Name | Age |\n|------|-----|\n| Alice | 30 |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Name", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Age", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Alice" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "30" }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-		{
-			name:     "blockquote",
-			markdown: "> quoted text",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "> quoted text" }
-				}
-			]`,
-		},
-		{
-			name:     "blockquote with nested list",
-			markdown: "> item 1\n> > item 2\n> > item 3",
-			expected: `[
-				{
-					"text": {
-					"text": "> item 1\n> > item 2\n> > item 3",
-					"type": "mrkdwn"
-					},
-					"type": "section"
-				}
-			]`,
-		},
-		{
-			name:     "inline formatting in paragraph",
-			markdown: "This is **bold** and _italic_ and ~strike~ and `code`",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "This is *bold* and _italic_ and ~strike~ and ` + "`code`" + `" }
-				}
-			]`,
-		},
-		{
-			name:     "link in paragraph",
-			markdown: "Visit [Google](http://google.com)",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Visit <http://google.com|Google>" }
-				}
-			]`,
-		},
-		{
-			name:     "image is skipped",
-			markdown: "![alt](http://example.com/image.png)",
-			// For image skip the block and return empty array
-			expected: `[]`,
-		},
-		{
-			name:     "paragraph then list then paragraph",
-			markdown: "Before\n\n- item\n\nAfter",
-			expected: `[
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item" }] }
-							]
-						}
-					]
-				},
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
-			]`,
-		},
-		{
-			name:     "ordered list with start > 1",
-			markdown: "5. fifth\n6. sixth",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 4,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "fifth" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sixth" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "deeply nested ordered list (3 levels) with offsets",
-			markdown: "1. Some things\n\t1. are best left\n2. to the fate\n\t1. of the world\n\t\t1. and then\n\t\t2. this is how\n3. it turns out to be",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Some things" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "are best left" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "to the fate" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "of the world" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 2, "border": 0,
-						  "elements": [
-						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "and then" }] },
-						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "this is how" }] }
-						  ]
-						},
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 2,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "it turns out to be" }] }] }
-					]
-				}
-			]`,
-		},
-		{
-			name:     "link with bold label in list item",
-			markdown: "- [**docs**](http://example.com)",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "docs" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with empty cell",
-			markdown: "| A | B |\n|---|---|\n| 1 | |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with missing column in row",
-			markdown: "| A | B |\n|---|---|\n| 1 |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			md := goldmark.New(
-				goldmark.WithExtensions(BlockKitV2),
-			)
-			var buf bytes.Buffer
-			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatalf("convert error: %v", err)
-			}
-			got := buf.String()
-			if !jsonEqual(got, tt.expected) {
-				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
-					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
-			}
-		})
-	}
-}

pkg/templating/slackblockkitrenderer/slackblockkitrenderer.go

@@ -1,737 +0,0 @@
-package slackblockkitrenderer
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-
-	"github.com/yuin/goldmark/ast"
-	extensionast "github.com/yuin/goldmark/extension/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-// listFrame tracks state for a single level of list nesting.
-type listFrame struct {
-	style     string // "bullet" or "ordered"
-	indent    int
-	itemCount int
-}
-
-// listContext holds all state while processing a list tree.
-type listContext struct {
-	result             []RichTextList
-	stack              []listFrame
-	current            *RichTextList
-	currentItemInlines []interface{}
-}
-
-// tableContext holds state while processing a table.
-type tableContext struct {
-	rows               [][]TableCell
-	currentRow         []TableCell
-	currentCellInlines []interface{}
-	isHeader           bool
-}
-
-// Renderer converts Markdown AST to Slack Block Kit JSON.
-type Renderer struct {
-	blocks []interface{}
-	mrkdwn strings.Builder
-	// holds active styles for the current rich text element
-	styleStack []RichTextStyle
-	// holds the current list context while processing a list tree.
-	listCtx *listContext
-	// holds the current table context while processing a table.
-	tableCtx *tableContext
-	// stores the current blockquote depth while processing a blockquote.
-	// so blockquote with nested list can be rendered correctly.
-	blockquoteDepth int
-}
-
-// NewRenderer returns a new block kit renderer.
-func NewRenderer() renderer.NodeRenderer {
-	return &Renderer{}
-}
-
-// RegisterFuncs registers node rendering functions.
-func (r *Renderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	// Blocks
-	reg.Register(ast.KindDocument, r.renderDocument)
-	reg.Register(ast.KindHeading, r.renderHeading)
-	reg.Register(ast.KindParagraph, r.renderParagraph)
-	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
-	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindFencedCodeBlock, r.renderFencedCodeBlock)
-	reg.Register(ast.KindBlockquote, r.renderBlockquote)
-	reg.Register(ast.KindList, r.renderList)
-	reg.Register(ast.KindListItem, r.renderListItem)
-	reg.Register(ast.KindImage, r.renderImage)
-
-	// Inlines
-	reg.Register(ast.KindText, r.renderText)
-	reg.Register(ast.KindEmphasis, r.renderEmphasis)
-	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
-	reg.Register(ast.KindLink, r.renderLink)
-
-	// Extensions
-	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
-	reg.Register(extensionast.KindTable, r.renderTable)
-	reg.Register(extensionast.KindTableHeader, r.renderTableHeader)
-	reg.Register(extensionast.KindTableRow, r.renderTableRow)
-	reg.Register(extensionast.KindTableCell, r.renderTableCell)
-	reg.Register(extensionast.KindTaskCheckBox, r.renderTaskCheckBox)
-}
-
-// inRichTextMode returns true when we're inside a list or table context
-// in slack blockkit list and table items are rendered as rich_text elements
-// if more cases are found in future those needs to be added here.
-func (r *Renderer) inRichTextMode() bool {
-	return r.listCtx != nil || r.tableCtx != nil
-}
-
-// currentStyle merges the stored style stack into RichTextStyle
-// which can be applied on rich text elements.
-func (r *Renderer) currentStyle() *RichTextStyle {
-	s := RichTextStyle{}
-	for _, f := range r.styleStack {
-		s.Bold = s.Bold || f.Bold
-		s.Italic = s.Italic || f.Italic
-		s.Strike = s.Strike || f.Strike
-		s.Code = s.Code || f.Code
-	}
-	if s == (RichTextStyle{}) {
-		return nil
-	}
-	return &s
-}
-
-// flushMrkdwn collects markdown text and adds it as a SectionBlock with mrkdwn text
-// whenever starting a new block we flush markdown to render it as a separate block.
-func (r *Renderer) flushMrkdwn() {
-	text := strings.TrimSpace(r.mrkdwn.String())
-	if text != "" {
-		r.blocks = append(r.blocks, SectionBlock{
-			Type: "section",
-			Text: &TextObject{
-				Type: "mrkdwn",
-				Text: text,
-			},
-		})
-	}
-	r.mrkdwn.Reset()
-}
-
-// addInline adds an inline element to the appropriate context.
-func (r *Renderer) addInline(el interface{}) {
-	if r.listCtx != nil {
-		r.listCtx.currentItemInlines = append(r.listCtx.currentItemInlines, el)
-	} else if r.tableCtx != nil {
-		r.tableCtx.currentCellInlines = append(r.tableCtx.currentCellInlines, el)
-	}
-}
-
-// --- Document ---
-
-func (r *Renderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.blocks = nil
-		r.mrkdwn.Reset()
-		r.styleStack = nil
-		r.listCtx = nil
-		r.tableCtx = nil
-		r.blockquoteDepth = 0
-	} else {
-		// on exiting the document node write the json for the collected blocks.
-		r.flushMrkdwn()
-		var data []byte
-		var err error
-		if len(r.blocks) > 0 {
-			data, err = json.Marshal(r.blocks)
-			if err != nil {
-				return ast.WalkStop, err
-			}
-		} else {
-			// if no blocks are collected, write an empty array.
-			data = []byte("[]")
-		}
-		_, err = w.Write(data)
-		if err != nil {
-			return ast.WalkStop, err
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Heading ---
-
-func (r *Renderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.mrkdwn.WriteString("*")
-	} else {
-		r.mrkdwn.WriteString("*\n")
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Paragraph ---
-
-func (r *Renderer) renderParagraph(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if r.mrkdwn.Len() > 0 {
-			text := r.mrkdwn.String()
-			if !strings.HasSuffix(text, "\n") {
-				r.mrkdwn.WriteString("\n")
-			}
-		}
-		// handling of nested blockquotes
-		if r.blockquoteDepth > 0 {
-			r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- ThematicBreak ---
-
-func (r *Renderer) renderThematicBreak(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.flushMrkdwn()
-		r.blocks = append(r.blocks, DividerBlock{Type: "divider"})
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- CodeBlock (indented) ---
-
-func (r *Renderer) renderCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	r.flushMrkdwn()
-
-	var buf bytes.Buffer
-	lines := node.Lines()
-	for i := 0; i < lines.Len(); i++ {
-		line := lines.At(i)
-		buf.Write(line.Value(source))
-	}
-
-	text := buf.String()
-	// Remove trailing newline
-	text = strings.TrimRight(text, "\n")
-	// Slack API rejects empty text in rich_text_preformatted elements
-	if text == "" {
-		text = " "
-	}
-
-	elements := []interface{}{
-		RichTextInline{Type: "text", Text: text},
-	}
-
-	r.blocks = append(r.blocks, RichTextBlock{
-		Type: "rich_text",
-		Elements: []interface{}{
-			RichTextPreformatted{
-				Type:     "rich_text_preformatted",
-				Elements: elements,
-				Border:   0,
-			},
-		},
-	})
-	return ast.WalkContinue, nil
-}
-
-// --- FencedCodeBlock ---
-
-func (r *Renderer) renderFencedCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	r.flushMrkdwn()
-
-	n := node.(*ast.FencedCodeBlock)
-	var buf bytes.Buffer
-	lines := node.Lines()
-	for i := 0; i < lines.Len(); i++ {
-		line := lines.At(i)
-		buf.Write(line.Value(source))
-	}
-
-	text := buf.String()
-	text = strings.TrimRight(text, "\n")
-	// Slack API rejects empty text in rich_text_preformatted elements
-	if text == "" {
-		text = " "
-	}
-
-	elements := []interface{}{
-		RichTextInline{Type: "text", Text: text},
-	}
-
-	// If language is specified, collect it.
-	var language string
-	lang := n.Language(source)
-	if len(lang) > 0 {
-		language = string(lang)
-	}
-	// Add the preformatted block to the blocks slice with the collected language.
-	r.blocks = append(r.blocks, RichTextBlock{
-		Type: "rich_text",
-		Elements: []interface{}{
-			RichTextPreformatted{
-				Type:     "rich_text_preformatted",
-				Elements: elements,
-				Border:   0,
-				Language: language,
-			},
-		},
-	})
-
-	return ast.WalkSkipChildren, nil
-}
-
-// --- Blockquote ---
-
-func (r *Renderer) renderBlockquote(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.blockquoteDepth++
-	} else {
-		r.blockquoteDepth--
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- List ---
-
-func (r *Renderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	list := node.(*ast.List)
-
-	if entering {
-		style := "bullet"
-		if list.IsOrdered() {
-			style = "ordered"
-		}
-
-		if r.listCtx == nil {
-			// Top-level list: flush mrkdwn and create context
-			r.flushMrkdwn()
-			r.listCtx = &listContext{}
-		} else {
-			// Nested list: check if we already have some collected list items that needs to be flushed.
-			// in slack blockkit, list items with different levels of indentation are added as different rich_text_list blocks.
-			if len(r.listCtx.currentItemInlines) > 0 {
-				sec := RichTextBlock{
-					Type:     "rich_text_section",
-					Elements: r.listCtx.currentItemInlines,
-				}
-				if r.listCtx.current != nil {
-					r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
-				}
-				r.listCtx.currentItemInlines = nil
-				// Increment parent's itemCount
-				if len(r.listCtx.stack) > 0 {
-					r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
-				}
-			}
-			// Finalize current list to result only if items were collected
-			if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
-				r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
-			}
-		}
-
-		// the stack accumulated till this level derives hte indentation
-		// the stack get's collected as we go in more nested levels of list
-		// and as we get our of the nesting we remove the items from the slack
-		indent := len(r.listCtx.stack)
-		r.listCtx.stack = append(r.listCtx.stack, listFrame{
-			style:     style,
-			indent:    indent,
-			itemCount: 0,
-		})
-
-		newList := &RichTextList{
-			Type:     "rich_text_list",
-			Style:    style,
-			Indent:   indent,
-			Border:   0,
-			Elements: []interface{}{},
-		}
-
-		// Handle ordered list with start > 1
-		if list.IsOrdered() && list.Start > 1 {
-			newList.Offset = list.Start - 1
-		}
-
-		r.listCtx.current = newList
-
-	} else {
-		// Leaving list: finalize current list
-		if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
-			r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
-		}
-
-		// Pop stack to so upcoming indentations can be handled correctly.
-		r.listCtx.stack = r.listCtx.stack[:len(r.listCtx.stack)-1]
-
-		if len(r.listCtx.stack) > 0 {
-			// Resume parent: start a new list segment at parent indent/style
-			parent := &r.listCtx.stack[len(r.listCtx.stack)-1]
-			newList := &RichTextList{
-				Type:     "rich_text_list",
-				Style:    parent.style,
-				Indent:   parent.indent,
-				Border:   0,
-				Elements: []interface{}{},
-			}
-			// Set offset for ordered parent continuation
-			if parent.style == "ordered" && parent.itemCount > 0 {
-				newList.Offset = parent.itemCount
-			}
-			r.listCtx.current = newList
-		} else {
-			// Top-level list is done since all stack are popped: build RichTextBlock if non-empty
-			if len(r.listCtx.result) > 0 {
-				elements := make([]interface{}, len(r.listCtx.result))
-				for i, l := range r.listCtx.result {
-					elements[i] = l
-				}
-				r.blocks = append(r.blocks, RichTextBlock{
-					Type:     "rich_text",
-					Elements: elements,
-				})
-			}
-			r.listCtx = nil
-		}
-	}
-
-	return ast.WalkContinue, nil
-}
-
-// --- ListItem ---
-
-func (r *Renderer) renderListItem(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.listCtx.currentItemInlines = nil
-	} else {
-		// Only add if there are inlines (might be empty after nested list consumed them)
-		if len(r.listCtx.currentItemInlines) > 0 {
-			sec := RichTextBlock{
-				Type:     "rich_text_section",
-				Elements: r.listCtx.currentItemInlines,
-			}
-			if r.listCtx.current != nil {
-				r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
-			}
-			r.listCtx.currentItemInlines = nil
-			// Increment parent frame's itemCount
-			if len(r.listCtx.stack) > 0 {
-				r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
-			}
-		}
-	}
-
-	return ast.WalkContinue, nil
-}
-
-// --- Table ---
-// when table is encountered, we flush the markdown and create a table context.
-// when header row is encountered, we set the isHeader flag to true
-// when each row ends in renderTableRow we add that row to rows array of table context.
-// when table cell is encountered, we apply header related styles to the collected inline items,
-// all inline items are parsed as separate AST items like list item, links, text, etc. are collected
-// using the addInline function and wrapped in a rich_text_section block.
-
-func (r *Renderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.flushMrkdwn()
-		r.tableCtx = &tableContext{}
-	} else {
-		// Pad short rows to match header column count for valid Block Kit payload
-		// without this slack blockkit attachment is invalid and the API fails
-		rows := r.tableCtx.rows
-		if len(rows) > 0 {
-			maxCols := len(rows[0])
-			for i, row := range rows {
-				for len(row) < maxCols {
-					emptySec := RichTextBlock{
-						Type:     "rich_text_section",
-						Elements: []interface{}{RichTextInline{Type: "text", Text: " "}},
-					}
-					row = append(row, TableCell{
-						Type:     "rich_text",
-						Elements: []interface{}{emptySec},
-					})
-				}
-				rows[i] = row
-			}
-		}
-		r.blocks = append(r.blocks, TableBlock{
-			Type: "table",
-			Rows: rows,
-		})
-		r.tableCtx = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderTableHeader(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.isHeader = true
-		r.tableCtx.currentRow = nil
-	} else {
-		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
-		r.tableCtx.currentRow = nil
-		r.tableCtx.isHeader = false
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderTableRow(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.currentRow = nil
-	} else {
-		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
-		r.tableCtx.currentRow = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderTableCell(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.currentCellInlines = nil
-	} else {
-		// If header, make text bold for the collected inline items.
-		if r.tableCtx.isHeader {
-			for i, el := range r.tableCtx.currentCellInlines {
-				if inline, ok := el.(RichTextInline); ok {
-					if inline.Style == nil {
-						inline.Style = &RichTextStyle{Bold: true}
-					} else {
-						inline.Style.Bold = true
-					}
-					r.tableCtx.currentCellInlines[i] = inline
-				}
-			}
-		}
-		// Ensure cell has at least one element for valid Block Kit payload
-		if len(r.tableCtx.currentCellInlines) == 0 {
-			r.tableCtx.currentCellInlines = []interface{}{
-				RichTextInline{Type: "text", Text: " "},
-			}
-		}
-		// All inline items that are collected for a table cell are wrapped in a rich_text_section block.
-		sec := RichTextBlock{
-			Type:     "rich_text_section",
-			Elements: r.tableCtx.currentCellInlines,
-		}
-		// The rich_text_section block is wrapped in a rich_text block.
-		cell := TableCell{
-			Type:     "rich_text",
-			Elements: []interface{}{sec},
-		}
-		r.tableCtx.currentRow = append(r.tableCtx.currentRow, cell)
-		r.tableCtx.currentCellInlines = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- TaskCheckBox ---
-
-func (r *Renderer) renderTaskCheckBox(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*extensionast.TaskCheckBox)
-	text := "[ ] "
-	if n.IsChecked {
-		text = "[x] "
-	}
-	if r.inRichTextMode() {
-		r.addInline(RichTextInline{Type: "text", Text: text})
-	} else {
-		r.mrkdwn.WriteString(text)
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Text ---
-
-func (r *Renderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Text)
-	value := string(n.Segment.Value(source))
-
-	if r.inRichTextMode() {
-		r.addInline(RichTextInline{
-			Type:  "text",
-			Text:  value,
-			Style: r.currentStyle(),
-		})
-		if n.HardLineBreak() || n.SoftLineBreak() {
-			r.addInline(RichTextInline{Type: "text", Text: "\n"})
-		}
-	} else {
-		r.mrkdwn.WriteString(value)
-		if n.HardLineBreak() || n.SoftLineBreak() {
-			r.mrkdwn.WriteString("\n")
-			if r.blockquoteDepth > 0 {
-				r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
-			}
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Emphasis ---
-
-func (r *Renderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Emphasis)
-	if r.inRichTextMode() {
-		if entering {
-			s := RichTextStyle{}
-			if n.Level == 1 {
-				s.Italic = true
-			} else {
-				s.Bold = true
-			}
-			r.styleStack = append(r.styleStack, s)
-		} else {
-			// the collected style gets used by the rich text element using currentStyle()
-			// so we remove this style from the stack.
-			if len(r.styleStack) > 0 {
-				r.styleStack = r.styleStack[:len(r.styleStack)-1]
-			}
-		}
-	} else {
-		if n.Level == 1 {
-			r.mrkdwn.WriteString("_")
-		} else {
-			r.mrkdwn.WriteString("*")
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Strikethrough ---
-
-func (r *Renderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if r.inRichTextMode() {
-		if entering {
-			r.styleStack = append(r.styleStack, RichTextStyle{Strike: true})
-		} else {
-			// the collected style gets used by the rich text element using currentStyle()
-			// so we remove this style from the stack.
-			if len(r.styleStack) > 0 {
-				r.styleStack = r.styleStack[:len(r.styleStack)-1]
-			}
-		}
-	} else {
-		r.mrkdwn.WriteString("~")
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: CodeSpan ---
-
-func (r *Renderer) renderCodeSpan(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	if r.inRichTextMode() {
-		// Collect all child text
-		var buf bytes.Buffer
-		for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-			if t, ok := c.(*ast.Text); ok {
-				v := t.Segment.Value(source)
-				if bytes.HasSuffix(v, []byte("\n")) {
-					buf.Write(v[:len(v)-1])
-					buf.WriteByte(' ')
-				} else {
-					buf.Write(v)
-				}
-			} else if s, ok := c.(*ast.String); ok {
-				buf.Write(s.Value)
-			}
-		}
-		style := r.currentStyle()
-		if style == nil {
-			style = &RichTextStyle{Code: true}
-		} else {
-			style.Code = true
-		}
-		r.addInline(RichTextInline{
-			Type:  "text",
-			Text:  buf.String(),
-			Style: style,
-		})
-		return ast.WalkSkipChildren, nil
-	}
-	// mrkdwn mode
-	r.mrkdwn.WriteByte('`')
-	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-		if t, ok := c.(*ast.Text); ok {
-			v := t.Segment.Value(source)
-			if bytes.HasSuffix(v, []byte("\n")) {
-				r.mrkdwn.Write(v[:len(v)-1])
-				r.mrkdwn.WriteByte(' ')
-			} else {
-				r.mrkdwn.Write(v)
-			}
-		} else if s, ok := c.(*ast.String); ok {
-			r.mrkdwn.Write(s.Value)
-		}
-	}
-	r.mrkdwn.WriteByte('`')
-	return ast.WalkSkipChildren, nil
-}
-
-// --- Inline: Link ---
-
-func (r *Renderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Link)
-	if r.inRichTextMode() {
-		if entering {
-			// Walk the entire subtree to collect text from all descendants,
-			// including nested inline nodes like emphasis, strong, code spans, etc.
-			var buf bytes.Buffer
-			_ = ast.Walk(node, func(child ast.Node, entering bool) (ast.WalkStatus, error) {
-				if !entering || child == node {
-					return ast.WalkContinue, nil
-				}
-				if t, ok := child.(*ast.Text); ok {
-					buf.Write(t.Segment.Value(source))
-				} else if s, ok := child.(*ast.String); ok {
-					buf.Write(s.Value)
-				}
-				return ast.WalkContinue, nil
-			})
-			// Once we've collected the text for the link (given it was present)
-			// let's add the link to the rich text block.
-			r.addInline(RichTextLink{
-				Type:  "link",
-				URL:   string(n.Destination),
-				Text:  buf.String(),
-				Style: r.currentStyle(),
-			})
-			return ast.WalkSkipChildren, nil
-		}
-	} else {
-		if entering {
-			r.mrkdwn.WriteString("<")
-			r.mrkdwn.Write(n.Destination)
-			r.mrkdwn.WriteString("|")
-		} else {
-			r.mrkdwn.WriteString(">")
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Image (skip) ---
-
-func (r *Renderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	return ast.WalkSkipChildren, nil
-}

pkg/templating/slackblockkitrenderer/types.go

@@ -1,80 +0,0 @@
-package slackblockkitrenderer
-
-// SectionBlock represents a Slack section block with mrkdwn text.
-type SectionBlock struct {
-	Type string      `json:"type"`
-	Text *TextObject `json:"text"`
-}
-
-// DividerBlock represents a Slack divider block.
-type DividerBlock struct {
-	Type string `json:"type"`
-}
-
-// RichTextBlock is a container for rich text elements (lists, code blocks, table and cell blocks).
-type RichTextBlock struct {
-	Type     string        `json:"type"`
-	Elements []interface{} `json:"elements"`
-}
-
-// TableBlock represents a Slack table rendered as a rich_text block with preformatted text.
-type TableBlock struct {
-	Type string        `json:"type"`
-	Rows [][]TableCell `json:"rows"`
-}
-
-// TableCell is a cell in a table block.
-type TableCell struct {
-	Type     string        `json:"type"`
-	Elements []interface{} `json:"elements"`
-}
-
-// TextObject is the text field inside a SectionBlock.
-type TextObject struct {
-	Type string `json:"type"`
-	Text string `json:"text"`
-}
-
-// RichTextList represents an ordered or unordered list.
-type RichTextList struct {
-	Type     string        `json:"type"`
-	Style    string        `json:"style"`
-	Indent   int           `json:"indent"`
-	Border   int           `json:"border"`
-	Offset   int           `json:"offset,omitempty"`
-	Elements []interface{} `json:"elements"`
-}
-
-// RichTextPreformatted represents a code block.
-type RichTextPreformatted struct {
-	Type     string        `json:"type"`
-	Elements []interface{} `json:"elements"`
-	Border   int           `json:"border"`
-	Language string        `json:"language,omitempty"`
-}
-
-// RichTextInline represents inline text with optional styling
-// ex: text inside list, table cell
-type RichTextInline struct {
-	Type  string         `json:"type"`
-	Text  string         `json:"text"`
-	Style *RichTextStyle `json:"style,omitempty"`
-}
-
-// RichTextLink represents a link inside rich text
-// ex: link inside list, table cell
-type RichTextLink struct {
-	Type  string         `json:"type"`
-	URL   string         `json:"url"`
-	Text  string         `json:"text,omitempty"`
-	Style *RichTextStyle `json:"style,omitempty"`
-}
-
-// RichTextStyle holds boolean style flags for inline elements
-// these bools can toggle different styles for a rich text element at once.
-type RichTextStyle struct {
-	Bold   bool `json:"bold,omitempty"`
-	Italic bool `json:"italic,omitempty"`
-	Strike bool `json:"strike,omitempty"`
-	Code   bool `json:"code,omitempty"`
-}

pkg/templating/slackmrkdwnrenderer/extender.go

@@ -1,22 +0,0 @@
-package slackmrkdwnrenderer
-
-import (
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-type slackMrkdwn struct{}
-
-// SlackMrkdwn is a goldmark.Extender that configures the Slack mrkdwn renderer.
-var SlackMrkdwn = &slackMrkdwn{}
-
-// Extend implements goldmark.Extender.
-func (e *slackMrkdwn) Extend(m goldmark.Markdown) {
-	extension.Table.Extend(m)
-	extension.Strikethrough.Extend(m)
-	m.Renderer().AddOptions(
-		renderer.WithNodeRenderers(util.Prioritized(NewRenderer(), 1)),
-	)
-}

pkg/templating/slackmrkdwnrenderer/slack.go

@@ -1,383 +0,0 @@
-package slackmrkdwnrenderer
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/yuin/goldmark/ast"
-	extensionast "github.com/yuin/goldmark/extension/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-// Renderer renders nodes as Slack mrkdwn.
-type Renderer struct {
-	prefixes []string
-}
-
-// NewRenderer returns a new Renderer with given options.
-func NewRenderer() renderer.NodeRenderer {
-	return &Renderer{}
-}
-
-// RegisterFuncs implements NodeRenderer.RegisterFuncs.
-func (r *Renderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	// Blocks
-	reg.Register(ast.KindDocument, r.renderDocument)
-	reg.Register(ast.KindHeading, r.renderHeading)
-	reg.Register(ast.KindBlockquote, r.renderBlockquote)
-	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindFencedCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindList, r.renderList)
-	reg.Register(ast.KindListItem, r.renderListItem)
-	reg.Register(ast.KindParagraph, r.renderParagraph)
-	reg.Register(ast.KindTextBlock, r.renderTextBlock)
-	reg.Register(ast.KindRawHTML, r.renderRawHTML)
-	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
-
-	// Inlines
-	reg.Register(ast.KindAutoLink, r.renderAutoLink)
-	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
-	reg.Register(ast.KindEmphasis, r.renderEmphasis)
-	reg.Register(ast.KindImage, r.renderImage)
-	reg.Register(ast.KindLink, r.renderLink)
-	reg.Register(ast.KindText, r.renderText)
-
-	// Extensions
-	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
-	reg.Register(extensionast.KindTable, r.renderTable)
-}
-
-func (r *Renderer) writePrefix(w util.BufWriter) {
-	for _, p := range r.prefixes {
-		_, _ = w.WriteString(p)
-	}
-}
-
-// writeLineSeparator writes a newline followed by the current prefix.
-// Used for tight separations (e.g., between list items or text blocks).
-func (r *Renderer) writeLineSeparator(w util.BufWriter) {
-	_ = w.WriteByte('\n')
-	r.writePrefix(w)
-}
-
-// writeBlockSeparator writes a blank line separator between block-level elements,
-// respecting any active prefixes for proper nesting (e.g., inside blockquotes).
-func (r *Renderer) writeBlockSeparator(w util.BufWriter) {
-	r.writeLineSeparator(w)
-	r.writeLineSeparator(w)
-}
-
-// separateFromPrevious writes a block separator if the node has a previous sibling.
-func (r *Renderer) separateFromPrevious(w util.BufWriter, n ast.Node) {
-	if n.PreviousSibling() != nil {
-		r.writeBlockSeparator(w)
-	}
-}
-
-func (r *Renderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		_, _ = w.WriteString("\n\n")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, node)
-	}
-	_, _ = w.WriteString("*")
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderBlockquote(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		r.prefixes = append(r.prefixes, "> ")
-		_, _ = w.WriteString("> ")
-	} else {
-		r.prefixes = r.prefixes[:len(r.prefixes)-1]
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderCodeBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		// start code block and write code line by line
-		_, _ = w.WriteString("```\n")
-		l := n.Lines().Len()
-		for i := 0; i < l; i++ {
-			line := n.Lines().At(i)
-			v := line.Value(source)
-			_, _ = w.Write(v)
-		}
-	} else {
-		_, _ = w.WriteString("```")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if node.PreviousSibling() != nil {
-			r.writeLineSeparator(w)
-			// another line break if not a nested list item and starting another block
-			if node.Parent() == nil || node.Parent().Kind() != ast.KindListItem {
-				r.writeLineSeparator(w)
-			}
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderListItem(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if n.PreviousSibling() != nil {
-			r.writeLineSeparator(w)
-		}
-		parent := n.Parent().(*ast.List)
-		// compute and write the prefix based on list type and index
-		var prefixStr string
-		if parent.IsOrdered() {
-			index := parent.Start
-			for c := parent.FirstChild(); c != nil && c != n; c = c.NextSibling() {
-				index++
-			}
-			prefixStr = fmt.Sprintf("%d. ", index)
-		} else {
-			prefixStr = "• "
-		}
-		_, _ = w.WriteString(prefixStr)
-		r.prefixes = append(r.prefixes, "\t") // add tab for nested list items
-	} else {
-		r.prefixes = r.prefixes[:len(r.prefixes)-1]
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderParagraph(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderTextBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering && n.PreviousSibling() != nil {
-		r.writeLineSeparator(w)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderRawHTML(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		n := n.(*ast.RawHTML)
-		l := n.Segments.Len()
-		for i := 0; i < l; i++ {
-			segment := n.Segments.At(i)
-			_, _ = w.Write(segment.Value(source))
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderThematicBreak(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		_, _ = w.WriteString("---")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.AutoLink)
-	url := string(n.URL(source))
-	label := string(n.Label(source))
-
-	if n.AutoLinkType == ast.AutoLinkEmail && !strings.HasPrefix(strings.ToLower(url), "mailto:") {
-		url = "mailto:" + url
-	}
-
-	if url == label {
-		_, _ = fmt.Fprintf(w, "<%s>", url)
-	} else {
-		_, _ = fmt.Fprintf(w, "<%s|%s>", url, label)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		_ = w.WriteByte('`')
-		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
-			segment := c.(*ast.Text).Segment
-			value := segment.Value(source)
-			if bytes.HasSuffix(value, []byte("\n")) { // replace newline with space
-				_, _ = w.Write(value[:len(value)-1])
-				_ = w.WriteByte(' ')
-			} else {
-				_, _ = w.Write(value)
-			}
-		}
-		return ast.WalkSkipChildren, nil
-	}
-	_ = w.WriteByte('`')
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Emphasis)
-	mark := "_"
-	if n.Level == 2 {
-		mark = "*"
-	}
-	_, _ = w.WriteString(mark)
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Link)
-	if entering {
-		_, _ = w.WriteString("<")
-		_, _ = w.Write(util.URLEscape(n.Destination, true))
-		_, _ = w.WriteString("|")
-	} else {
-		_, _ = w.WriteString(">")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Image)
-	_, _ = w.WriteString("<")
-	_, _ = w.Write(util.URLEscape(n.Destination, true))
-	_, _ = w.WriteString("|")
-
-	// Write the alt text directly
-	var altBuf bytes.Buffer
-	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
-		if textNode, ok := c.(*ast.Text); ok {
-			altBuf.Write(textNode.Segment.Value(source))
-		}
-	}
-	_, _ = w.Write(altBuf.Bytes())
-
-	_, _ = w.WriteString(">")
-	return ast.WalkSkipChildren, nil
-}
-
-func (r *Renderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Text)
-	segment := n.Segment
-	value := segment.Value(source)
-	_, _ = w.Write(value)
-	if n.HardLineBreak() || n.SoftLineBreak() {
-		r.writeLineSeparator(w)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	_, _ = w.WriteString("~")
-	return ast.WalkContinue, nil
-}
-
-func (r *Renderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-
-	r.separateFromPrevious(w, node)
-
-	// Collect cells and max widths
-	var rows [][]string
-	var colWidths []int
-
-	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-		if c.Kind() == extensionast.KindTableHeader || c.Kind() == extensionast.KindTableRow {
-			var row []string
-			colIdx := 0
-			for cc := c.FirstChild(); cc != nil; cc = cc.NextSibling() {
-				if cc.Kind() == extensionast.KindTableCell {
-					cellText := extractPlainText(cc, source)
-					row = append(row, cellText)
-					runeLen := utf8.RuneCountInString(cellText)
-					if colIdx >= len(colWidths) {
-						colWidths = append(colWidths, runeLen)
-					} else if runeLen > colWidths[colIdx] {
-						colWidths[colIdx] = runeLen
-					}
-					colIdx++
-				}
-			}
-			rows = append(rows, row)
-		}
-	}
-
-	// writing table in code block
-	_, _ = w.WriteString("```\n")
-	for i, row := range rows {
-		for colIdx, cellText := range row {
-			width := 0
-			if colIdx < len(colWidths) {
-				width = colWidths[colIdx]
-			}
-			runeLen := utf8.RuneCountInString(cellText)
-			padding := max(0, width-runeLen)
-
-			_, _ = w.WriteString(cellText)
-			_, _ = w.WriteString(strings.Repeat(" ", padding))
-			if colIdx < len(row)-1 {
-				_, _ = w.WriteString(" | ")
-			}
-		}
-		_ = w.WriteByte('\n')
-
-		// Print separator after header
-		if i == 0 {
-			for colIdx := range row {
-				width := 0
-				if colIdx < len(colWidths) {
-					width = colWidths[colIdx]
-				}
-				_, _ = w.WriteString(strings.Repeat("-", width))
-				if colIdx < len(row)-1 {
-					_, _ = w.WriteString("-|-")
-				}
-			}
-			_ = w.WriteByte('\n')
-		}
-	}
-	_, _ = w.WriteString("```")
-
-	return ast.WalkSkipChildren, nil
-}
-
-// extractPlainText extracts all the text content from the given node.
-func extractPlainText(n ast.Node, source []byte) string {
-	var buf bytes.Buffer
-	_ = ast.Walk(n, func(node ast.Node, entering bool) (ast.WalkStatus, error) {
-		if !entering {
-			return ast.WalkContinue, nil
-		}
-		if textNode, ok := node.(*ast.Text); ok {
-			buf.Write(textNode.Segment.Value(source))
-		} else if strNode, ok := node.(*ast.String); ok {
-			buf.Write(strNode.Value)
-		}
-		return ast.WalkContinue, nil
-	})
-	return strings.TrimSpace(buf.String())
-}

pkg/templating/slackmrkdwnrenderer/slack_test.go

@@ -1,115 +0,0 @@
-package slackmrkdwnrenderer
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/yuin/goldmark"
-)
-
-func TestRenderer(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "Heading with Thematic Break",
-			markdown: "# Title 1\n# Hello World\n---\nthis is sometext",
-			expected: "*Title 1*\n\n*Hello World*\n\n---\n\nthis is sometext\n\n",
-		},
-		{
-			name:     "Blockquote",
-			markdown: "> This is a quote\n> It continues",
-			expected: "> This is a quote\n> It continues\n\n",
-		},
-		{
-			name:     "Fenced Code Block",
-			markdown: "```go\npackage main\nfunc main() {}\n```",
-			expected: "```\npackage main\nfunc main() {}\n```\n\n",
-		},
-		{
-			name:     "Unordered List",
-			markdown: "- item 1\n- item 2\n- item 3",
-			expected: "• item 1\n• item 2\n• item 3\n\n",
-		},
-		{
-			name:     "nested unordered list",
-			markdown: "- item 1\n- item 2\n\t- item 2.1\n\t\t- item 2.1.1\n\t\t- item 2.1.2\n\t- item 2.2\n- item 3",
-			expected: "• item 1\n• item 2\n\t• item 2.1\n\t\t• item 2.1.1\n\t\t• item 2.1.2\n\t• item 2.2\n• item 3\n\n",
-		},
-		{
-			name:     "Ordered List",
-			markdown: "1. item 1\n2. item 2\n3. item 3",
-			expected: "1. item 1\n2. item 2\n3. item 3\n\n",
-		},
-		{
-			name:     "nested ordered list",
-			markdown: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4",
-			expected: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4\n\n",
-		},
-		{
-			name:     "Links and AutoLinks",
-			markdown: "This is a [link](https://example.com) and an autolink <https://test.com>",
-			expected: "This is a <https://example.com|link> and an autolink <https://test.com>\n\n",
-		},
-		{
-			name:     "Images",
-			markdown: "An image ![alt text](https://example.com/image.png)",
-			expected: "An image <https://example.com/image.png|alt text>\n\n",
-		},
-		{
-			name:     "Emphasis",
-			markdown: "This is **bold** and *italic* and __bold__ and _italic_",
-			expected: "This is *bold* and _italic_ and *bold* and _italic_\n\n",
-		},
-		{
-			name:     "Strikethrough",
-			markdown: "This is ~~strike~~",
-			expected: "This is ~strike~\n\n",
-		},
-		{
-			name:     "Code Span",
-			markdown: "This is `inline code` embedded.",
-			expected: "This is `inline code` embedded.\n\n",
-		},
-		{
-			name:     "Table",
-			markdown: "Col 1 | Col 2 | Col 3\n--- | --- | ---\nVal 1 | Long Value 2 | 3\nShort | V | 1000",
-			expected: "```\nCol 1 | Col 2        | Col 3\n------|--------------|------\nVal 1 | Long Value 2 | 3    \nShort | V            | 1000 \n```\n\n",
-		},
-		{
-			name:     "Mixed Nested Lists",
-			markdown: "1. first\n\t- nested bullet\n\t- another bullet\n2. second",
-			expected: "1. first\n\t• nested bullet\n\t• another bullet\n2. second\n\n",
-		},
-		{
-			name:     "Email AutoLink",
-			markdown: "<user@example.com>",
-			expected: "<mailto:user@example.com|user@example.com>\n\n",
-		},
-		{
-			name:     "No value string parsed as is",
-			markdown: "Service: <no value>",
-			expected: "Service: <no value>\n\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			md := goldmark.New(goldmark.WithExtensions(SlackMrkdwn))
-
-			var buf bytes.Buffer
-			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatalf("failed to convert: %v", err)
-			}
-
-			// Do exact string matching
-			actual := buf.String()
-			if actual != tt.expected {
-				t.Errorf("\nExpected:\n%q\nGot:\n%q\nRaw Expected:\n%s\nRaw Got:\n%s",
-					tt.expected, actual, tt.expected, actual)
-			}
-		})
-	}
-}

pkg/templating/templatingextensions/html.go

@@ -1,66 +0,0 @@
-package templatingextensions
-
-import (
-	"github.com/yuin/goldmark"
-	gast "github.com/yuin/goldmark/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/renderer/html"
-	"github.com/yuin/goldmark/util"
-)
-
-// NoValueHTMLRenderer is a renderer.NodeRenderer implementation that
-// renders <no value> as escaped visible text instead of omitting it.
-type NoValueHTMLRenderer struct {
-	html.Config
-}
-
-// NewNoValueHTMLRenderer returns a new NoValueHTMLRenderer.
-func NewNoValueHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
-	r := &NoValueHTMLRenderer{
-		Config: html.NewConfig(),
-	}
-	for _, opt := range opts {
-		opt.SetHTMLOption(&r.Config)
-	}
-	return r
-}
-
-// RegisterFuncs implements renderer.NodeRenderer.RegisterFuncs.
-func (r *NoValueHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	reg.Register(gast.KindRawHTML, r.renderRawHTML)
-}
-
-func (r *NoValueHTMLRenderer) renderRawHTML(
-	w util.BufWriter, source []byte, node gast.Node, entering bool) (gast.WalkStatus, error) {
-	if !entering {
-		return gast.WalkSkipChildren, nil
-	}
-	if r.Unsafe {
-		n := node.(*gast.RawHTML)
-		for i := 0; i < n.Segments.Len(); i++ {
-			segment := n.Segments.At(i)
-			_, _ = w.Write(segment.Value(source))
-		}
-		return gast.WalkSkipChildren, nil
-	}
-	n := node.(*gast.RawHTML)
-	raw := string(n.Segments.Value(source))
-	if raw == "<no value>" {
-		_, _ = w.WriteString("&lt;no value&gt;")
-		return gast.WalkSkipChildren, nil
-	}
-	_, _ = w.WriteString("<!-- raw HTML omitted -->")
-	return gast.WalkSkipChildren, nil
-}
-
-type escapeNoValue struct{}
-
-// EscapeNoValue is an extension that renders <no value> as visible
-// escaped text instead of omitting it as raw HTML.
-var EscapeNoValue = &escapeNoValue{}
-
-func (e *escapeNoValue) Extend(m goldmark.Markdown) {
-	m.Renderer().AddOptions(renderer.WithNodeRenderers(
-		util.Prioritized(NewNoValueHTMLRenderer(), 500),
-	))
-}

pkg/templating/templatingextensions/html_test.go

@@ -1,66 +0,0 @@
-package templatingextensions
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-)
-
-func TestEscapeNoValue(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "plain text",
-			markdown: "Service: <no value>",
-			expected: "<p>Service: &lt;no value&gt;</p>\n",
-		},
-		{
-			name:     "inside strong",
-			markdown: "Service: **<no value>**",
-			expected: "<p>Service: <strong>&lt;no value&gt;</strong></p>\n",
-		},
-		{
-			name:     "inside emphasis",
-			markdown: "Service: *<no value>*",
-			expected: "<p>Service: <em>&lt;no value&gt;</em></p>\n",
-		},
-		{
-			name:     "inside strikethrough",
-			markdown: "Service: ~~<no value>~~",
-			expected: "<p>Service: <del>&lt;no value&gt;</del></p>\n",
-		},
-		{
-			name:     "real html still omitted",
-			markdown: "hello <div>world</div>",
-			expected: "<p>hello <!-- raw HTML omitted -->world<!-- raw HTML omitted --></p>\n",
-		},
-		{
-			name:     "inside heading",
-			markdown: "# Title <no value>",
-			expected: "<h1>Title &lt;no value&gt;</h1>\n",
-		},
-		{
-			name:     "inside list item",
-			markdown: "- item <no value>",
-			expected: "<ul>\n<li>item &lt;no value&gt;</li>\n</ul>\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := goldmark.New(goldmark.WithExtensions(EscapeNoValue, extension.Strikethrough))
-			var buf bytes.Buffer
-			if err := gm.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatal(err)
-			}
-			if buf.String() != tt.expected {
-				t.Errorf("expected:\n%s\ngot:\n%s", tt.expected, buf.String())
-			}
-		})
-	}
-}

pkg/types/alertmanagertypes/template.go

@@ -11,22 +11,19 @@ import (
 	alertmanagertemplate "github.com/prometheus/alertmanager/template"
 )
 
-func AdditionalFuncMap() tmpltext.FuncMap {
-	return tmpltext.FuncMap{
-		// urlescape escapes the string for use in a URL query parameter.
-		// It returns tmplhtml.HTML to prevent the template engine from escaping the already escaped string.
-		// url.QueryEscape escapes spaces as "+", and html/template escapes "+" as "+" if tmplhtml.HTML is not used.
-		"urlescape": func(value string) tmplhtml.HTML {
-			return tmplhtml.HTML(url.QueryEscape(value))
-		},
-	}
-}
-
 // customTemplateOption returns an Option that adds custom functions to the template.
 func customTemplateOption() alertmanagertemplate.Option {
 	return func(text *tmpltext.Template, html *tmplhtml.Template) {
-		text.Funcs(AdditionalFuncMap())
-		html.Funcs(AdditionalFuncMap())
+		funcs := tmpltext.FuncMap{
+			// urlescape escapes the string for use in a URL query parameter.
+			// It returns tmplhtml.HTML to prevent the template engine from escaping the already escaped string.
+			// url.QueryEscape escapes spaces as "+", and html/template escapes "+" as "+" if tmplhtml.HTML is not used.
+			"urlescape": func(value string) tmplhtml.HTML {
+				return tmplhtml.HTML(url.QueryEscape(value))
+			},
+		}
+		text.Funcs(funcs)
+		html.Funcs(funcs)
 	}
 }
 

pkg/types/ruletypes/constants.go

@@ -9,20 +9,4 @@ const (
 	LabelSeverityName     = "severity"
 	LabelLastSeen         = "lastSeen"
 	LabelRuleID           = "ruleId"
-	LabelRuleSource       = "ruleSource"
-	LabelNoData           = "nodata"
-	LabelTestAlert        = "testalert"
-	LabelAlertName        = "alertname"
-	LabelIsRecovering     = "is_recovering"
-)
-
-const (
-	AnnotationRelatedLogs    = "related_logs"
-	AnnotationRelatedTraces  = "related_traces"
-	AnnotationTitleTemplate  = "title_template"
-	AnnotationBodyTemplate   = "body_template"
-	AnnotationValue          = "value"
-	AnnotationThresholdValue = "threshold.value"
-	AnnotationCompareOp      = "compare_op"
-	AnnotationMatchType      = "match_type"
 )