fix(tools):missing parameters in create/update alert rule tools (#663)

Author: Shaik-Sirajuddin

testdata/provisioning/alerting/alert_rules.yaml

@@ -176,3 +176,31 @@ groups:
           type: test
           rule: third
         isPaused: true
+      - uid: recording_rule_1
+        title: test_recording_rule
+        condition: A
+        data:
+          - refId: A
+            relativeTimeRange:
+              from: 600
+              to: 0
+            datasourceUid: prometheus  
+            model:
+              datasource:
+                type: prometheus
+                uid: prometheus
+              editorMode: code
+              expr: avg(rate(http_requests_total[5m])) 
+              instant: true
+              range: false
+              refId: A
+        record:
+          from: A
+          metric: http_requests_avg
+          target_datasource_uid: prometheus
+
+        annotations:
+          description: "Recording avg HTTP request rate"
+        labels:
+          team: sre
+          type: test

tools/alerting_manage_rules_handlers.go

@@ -122,9 +122,11 @@ func getAlertRuleVersions(ctx context.Context, uid string) (any, error) {
 // are left at their zero values.
 func mergeRuleDetail(provisioned *models.ProvisionedAlertRule, runtime *alertingRule) alertRuleDetail {
 	detail := alertRuleDetail{
-		UID:         provisioned.UID,
-		Labels:      provisioned.Labels,
-		Annotations: provisioned.Annotations,
+		UID:                         provisioned.UID,
+		Labels:                      provisioned.Labels,
+		Annotations:                 provisioned.Annotations,
+		KeepFiringFor:               provisioned.KeepFiringFor.String(),
+		MissingSeriesEvalsToResolve: provisioned.MissingSeriesEvalsToResolve,
 	}
 
 	if provisioned.Title != nil {
@@ -139,6 +141,8 @@ func mergeRuleDetail(provisioned *models.ProvisionedAlertRule, runtime *alerting
 	if provisioned.Condition != nil {
 		detail.Condition = *provisioned.Condition
 	}
+	// NoDataState, ExecErrState are set empty by grafana HTTP API for a recording rule
+	// non-nil checks are applied as api expects to have a defined value for these fields
 	if provisioned.NoDataState != nil {
 		detail.NoDataState = *provisioned.NoDataState
 	}
@@ -148,6 +152,9 @@ func mergeRuleDetail(provisioned *models.ProvisionedAlertRule, runtime *alerting
 	if provisioned.For != nil {
 		detail.For = provisioned.For.String()
 	}
+	if provisioned.Record != nil {
+		detail.Record = (*Record)(provisioned.Record)
+	}
 
 	detail.IsPaused = provisioned.IsPaused
 	detail.NotificationSettings = provisioned.NotificationSettings
@@ -313,26 +320,41 @@ func createAlertRule(ctx context.Context, args CreateAlertRuleParams) (*models.P
 
 	duration, err := time.ParseDuration(args.For)
 	if err != nil {
-		return nil, fmt.Errorf("create alert rule: invalid duration format %q: %w", args.For, err)
+		return nil, fmt.Errorf("create alert rule: invalid duration format for parameter for: %q: %w", args.For, err)
 	}
 
 	convertedData, err := convertAlertQueries(args.Data)
 	if err != nil {
 		return nil, fmt.Errorf("create alert rule: %w", err)
 	}
+	keepFiringFor := time.Duration(0)
+	if args.KeepFiringFor != "" {
+		keepFiringFor, err = time.ParseDuration(args.KeepFiringFor)
+		if err != nil {
+			return nil, fmt.Errorf("create alert rule: invalid duration format for parameter keepFiringFor: %q: %w", args.KeepFiringFor, err)
+		}
+	}
+
+	notificationSettings := convertNotificationSettings(args.NotificationSettings)
+	record := convertRecord(args.Record)
 
 	rule := &models.ProvisionedAlertRule{
-		Title:        &args.Title,
-		RuleGroup:    &args.RuleGroup,
-		FolderUID:    &args.FolderUID,
-		Condition:    &args.Condition,
-		Data:         convertedData,
-		NoDataState:  &args.NoDataState,
-		ExecErrState: &args.ExecErrState,
-		For:          func() *strfmt.Duration { d := strfmt.Duration(duration); return &d }(),
-		Annotations:  args.Annotations,
-		Labels:       args.Labels,
-		OrgID:        &args.OrgID,
+		Title:                       &args.Title,
+		RuleGroup:                   &args.RuleGroup,
+		FolderUID:                   &args.FolderUID,
+		Condition:                   &args.Condition,
+		Data:                        convertedData,
+		NoDataState:                 &args.NoDataState,
+		ExecErrState:                &args.ExecErrState,
+		For:                         func() *strfmt.Duration { d := strfmt.Duration(duration); return &d }(),
+		Annotations:                 args.Annotations,
+		Labels:                      args.Labels,
+		OrgID:                       &args.OrgID,
+		IsPaused:                    args.IsPaused,
+		KeepFiringFor:               func() strfmt.Duration { d := strfmt.Duration(keepFiringFor); return d }(),
+		MissingSeriesEvalsToResolve: args.MissingSeriesEvalsToResolve,
+		NotificationSettings:        notificationSettings,
+		Record:                      record,
 	}
 
 	if args.UID != nil {
@@ -353,7 +375,6 @@ func createAlertRule(ctx context.Context, args CreateAlertRuleParams) (*models.P
 		header := "true"
 		params = params.WithXDisableProvenance(&header)
 	}
-
 	response, err := c.Provisioning.PostAlertRule(params)
 	if err != nil {
 		return nil, fmt.Errorf("create alert rule: %w", err)
@@ -371,27 +392,45 @@ func updateAlertRule(ctx context.Context, args UpdateAlertRuleParams) (*models.P
 
 	duration, err := time.ParseDuration(args.For)
 	if err != nil {
-		return nil, fmt.Errorf("update alert rule: invalid duration format %q: %w", args.For, err)
+		return nil, fmt.Errorf("update alert rule: invalid duration format for parameter for: %q: %w", args.For, err)
 	}
 
 	convertedData, err := convertAlertQueries(args.Data)
 	if err != nil {
 		return nil, fmt.Errorf("update alert rule: %w", err)
 	}
 
+	keepFiringFor := time.Duration(0)
+	if args.KeepFiringFor != "" {
+		keepFiringFor, err = time.ParseDuration(args.KeepFiringFor)
+		if err != nil {
+			return nil, fmt.Errorf("update alert rule: invalid duration format for parameter keepFiringFor: %q: %w", args.KeepFiringFor, err)
+		}
+	}
+
+	notificationSettings := convertNotificationSettings(args.NotificationSettings)
+
+	record := convertRecord(args.Record)
+
+	// MissingSeriesEvalsToResolve, Provenance are set to defaults
 	rule := &models.ProvisionedAlertRule{
-		UID:          args.UID,
-		Title:        &args.Title,
-		RuleGroup:    &args.RuleGroup,
-		FolderUID:    &args.FolderUID,
-		Condition:    &args.Condition,
-		Data:         convertedData,
-		NoDataState:  &args.NoDataState,
-		ExecErrState: &args.ExecErrState,
-		For:          func() *strfmt.Duration { d := strfmt.Duration(duration); return &d }(),
-		Annotations:  args.Annotations,
-		Labels:       args.Labels,
-		OrgID:        &args.OrgID,
+		UID:                         args.UID,
+		Title:                       &args.Title,
+		RuleGroup:                   &args.RuleGroup,
+		FolderUID:                   &args.FolderUID,
+		Condition:                   &args.Condition,
+		Data:                        convertedData,
+		NoDataState:                 &args.NoDataState,
+		ExecErrState:                &args.ExecErrState,
+		For:                         func() *strfmt.Duration { d := strfmt.Duration(duration); return &d }(),
+		Annotations:                 args.Annotations,
+		Labels:                      args.Labels,
+		OrgID:                       &args.OrgID,
+		IsPaused:                    args.IsPaused,
+		MissingSeriesEvalsToResolve: args.MissingSeriesEvalsToResolve,
+		KeepFiringFor:               func() strfmt.Duration { d := strfmt.Duration(keepFiringFor); return d }(),
+		NotificationSettings:        notificationSettings,
+		Record:                      record,
 	}
 
 	if err := rule.Validate(strfmt.Default); err != nil {