Merge pull request #499 from SumoLogic/jinkane-multi-burn-rate

SUMO-213711 added new fields for multi window multi burn monitor

Author: jinkane

CHANGELOG.md

@@ -1,10 +1,15 @@
 ## 2.21.1 (Unreleased)
 FEATURES:
+* resource/sumologic_monitor: Added support for creating SLO Monitors with multiple burn rates (GH-499)
 * Add new optional `resolution_payload` field to connection resource and `resolution_payload_override` field to notifications section of monitor resource (GH-482)
 
 BUG FIXES:
 * Remove thresholdType field under searchSchedule in content resource (GH-483)
 
+DEPRECATIONS:
+
+* resource/sumologic_monitor: Deprecated `burn_rate_threshold` and `time_range` in favor of `burn_rate` inside `slo_burn_rate_condition` block (GH-499)
+
 ## 2.21.0 (February 27, 2023)
 FEATURES:
 * **New Resource:** sumologic_cse_first_seen_rule (GH-476)

sumologic/resource_sumologic_monitors_library_monitor.go

@@ -1,6 +1,7 @@
 package sumologic
 
 import (
+	"fmt"
 	"log"
 	"regexp"
 	"strings"
@@ -555,23 +556,38 @@ var sloSLITriggerConditionSchema = map[string]*schema.Schema{
 
 var sloBurnRateTriggerConditionSchema = map[string]*schema.Schema{
 	"critical": nestedWithAtleastOneOfKeys(true, schemaMap{
-		"time_range": &timeRangeSchema,
-		"burn_rate_threshold": {
-			Type:         schema.TypeFloat,
-			Required:     true,
-			ValidateFunc: validation.FloatAtLeast(0),
-		},
+		"time_range":          getSloBurnRateTimeRangeSchema("critical"),
+		"burn_rate_threshold": getSloBurnRateThresholdSchema("critical"),
+		"burn_rate":           getBurnRateSchema("critical"),
 	}, sloBurnRateConditionCriticalOrWarningAtleastOneKeys),
 	"warning": nestedWithAtleastOneOfKeys(true, schemaMap{
-		"time_range": &timeRangeSchema,
-		"burn_rate_threshold": {
-			Type:         schema.TypeFloat,
-			Required:     true,
-			ValidateFunc: validation.FloatAtLeast(0),
-		},
+		"time_range":          getSloBurnRateTimeRangeSchema("warning"),
+		"burn_rate_threshold": getSloBurnRateThresholdSchema("warning"),
+		"burn_rate":           getBurnRateSchema("warning"),
 	}, sloBurnRateConditionCriticalOrWarningAtleastOneKeys),
 }
 
+func getBurnRateSchema(triggerType string) *schema.Schema {
+	burnRateThresholdConflict := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.burn_rate_threshold", triggerType)
+	timeRangeConflict := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.time_range", triggerType)
+
+	return &schema.Schema{
+		Optional:      true,
+		Type:          schema.TypeList,
+		ConflictsWith: []string{burnRateThresholdConflict, timeRangeConflict},
+		Elem: &schema.Resource{
+			Schema: map[string]*schema.Schema{
+				"burn_rate_threshold": {
+					Type:         schema.TypeFloat,
+					Required:     true,
+					ValidateFunc: validation.FloatAtLeast(0),
+				},
+				"time_range": &timeRangeSchema,
+			},
+		},
+	}
+}
+
 var occurrenceTypeSchema = schema.Schema{
 	Type:         schema.TypeString,
 	Required:     true,
@@ -611,10 +627,37 @@ var consecutiveSchema = schema.Schema{
 var timeRangeSchema = schema.Schema{
 	Type:             schema.TypeString,
 	Required:         true,
-	ValidateFunc:     validation.StringMatch(regexp.MustCompile(`^-?(\d)+[smhd]$`), "Time range must be in the format '-?\\d+[smhd]'. Examples: -15m, 1d, etc."),
+	ValidateFunc:     timeRangeValidation,
 	DiffSuppressFunc: SuppressEquivalentTimeDiff(false),
 }
 
+func getSloBurnRateThresholdSchema(triggerType string) *schema.Schema {
+	requiredWith := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.time_range", triggerType)
+	conflictsWith := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.burn_rate", triggerType)
+	return &schema.Schema{
+		Type:          schema.TypeFloat,
+		Optional:      true,
+		ValidateFunc:  validation.FloatAtLeast(0),
+		RequiredWith:  []string{requiredWith},
+		ConflictsWith: []string{conflictsWith},
+	}
+}
+
+func getSloBurnRateTimeRangeSchema(triggerType string) *schema.Schema {
+	requiredWith := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.burn_rate_threshold", triggerType)
+	conflictsWith := fmt.Sprintf("trigger_conditions.0.slo_burn_rate_condition.0.%s.0.burn_rate", triggerType)
+	return &schema.Schema{
+		Type:             schema.TypeString,
+		Optional:         true,
+		ValidateFunc:     timeRangeValidation,
+		DiffSuppressFunc: SuppressEquivalentTimeDiff(false),
+		RequiredWith:     []string{requiredWith},
+		ConflictsWith:    []string{conflictsWith},
+	}
+}
+
+var timeRangeValidation = validation.StringMatch(regexp.MustCompile(`^-?(\d)+[smhd]$`), "Time range must be in the format '-?\\d+[smhd]'. Examples: -15m, 1d, etc.")
+
 var resolutionWindowSchema = schema.Schema{
 	Type:             schema.TypeString,
 	Optional:         true,
@@ -635,6 +678,7 @@ var thresholdTypeSchema = schema.Schema{
 
 func resourceSumologicMonitorsLibraryMonitorCreate(d *schema.ResourceData, meta interface{}) error {
 	c := meta.(*Client)
+
 	if d.Id() == "" {
 		monitor := resourceToMonitorsLibraryMonitor(d)
 		if monitor.ParentID == "" {
@@ -1351,22 +1395,21 @@ func jsonToSloBurnRateConditionBlock(conditions []TriggerCondition) map[string]i
 	var criticalAlrt, warningAlrt = dict{}, dict{}
 	block := map[string]interface{}{}
 
-	block["critical"] = toSingletonArray(criticalAlrt)
-	block["warning"] = toSingletonArray(warningAlrt)
-
 	var hasCritical, hasWarning = false, false
 	for _, condition := range conditions {
 		switch condition.TriggerType {
 		case "Critical":
 			hasCritical = true
-			criticalAlrt["time_range"] = condition.TimeRange
-			criticalAlrt["burn_rate_threshold"] = condition.BurnRateThreshold
+			criticalAlrt = getAlertBlock(condition)
 		case "Warning":
 			hasWarning = true
-			warningAlrt["time_range"] = condition.TimeRange
-			warningAlrt["burn_rate_threshold"] = condition.BurnRateThreshold
+			warningAlrt = getAlertBlock(condition)
 		}
 	}
+
+	block["critical"] = toSingletonArray(criticalAlrt)
+	block["warning"] = toSingletonArray(warningAlrt)
+
 	if !hasCritical {
 		delete(block, "critical")
 	}
@@ -1376,6 +1419,24 @@ func jsonToSloBurnRateConditionBlock(conditions []TriggerCondition) map[string]i
 	return block
 }
 
+func getAlertBlock(condition TriggerCondition) dict {
+	var alert = dict{}
+	burnRates := make([]interface{}, len(condition.BurnRates))
+	alert["time_range"] = condition.TimeRange
+	alert["burn_rate_threshold"] = condition.BurnRateThreshold
+
+	for i := range condition.BurnRates {
+		burnRateBlock := map[string]interface{}{}
+		burnRateBlock["burn_rate_threshold"] = condition.BurnRates[i].BurnRateThreshold
+		burnRateBlock["time_range"] = condition.BurnRates[i].TimeRange
+		burnRates[i] = burnRateBlock
+	}
+	if len(burnRates) > 0 {
+		alert["burn_rate"] = burnRates
+	}
+	return alert
+}
+
 func jsonToLogsMissingDataConditionBlock(conditions []TriggerCondition) map[string]interface{} {
 	block := map[string]interface{}{}
 	firstCondition := conditions[0]
@@ -1625,15 +1686,33 @@ func (base TriggerCondition) sloCloneReadingFromNestedBlocks(block map[string]in
 
 	if critical, ok := fromSingletonArray(block, "critical"); ok {
 		criticalCondition.readFrom(critical)
+		criticalCondition.computeBurnRates(critical)
 		conditions = append(conditions, criticalCondition)
 	}
 	if warning, ok := fromSingletonArray(block, "warning"); ok {
 		warningCondition.readFrom(warning)
+		warningCondition.computeBurnRates(warning)
 		conditions = append(conditions, warningCondition)
 	}
 	return conditions
 }
 
+func (condition *TriggerCondition) computeBurnRates(block map[string]interface{}) {
+	if burnRatesResource, ok := block["burn_rate"].([]interface{}); ok {
+		burnRates := make([]BurnRate, len(burnRatesResource))
+		for i := range burnRatesResource {
+			burnRateResource := burnRatesResource[i].(map[string]interface{})
+			burnRates[i] = BurnRate{
+				BurnRateThreshold: burnRateResource["burn_rate_threshold"].(float64),
+				TimeRange:         burnRateResource["time_range"].(string),
+			}
+		}
+		condition.BurnRates = burnRates
+	} else {
+		condition.BurnRates = []BurnRate{}
+	}
+}
+
 func toSingletonArray(m map[string]interface{}) []map[string]interface{} {
 	return []map[string]interface{}{m}
 }