Merge pull request #480 from SumoLogic/pgupta-monitor-based-slo-support

SUMO-209281 Terraform support for monitor based SLOs

Author: pgupta-sumo

sumologic/resource_sumologic_slo.go

@@ -10,6 +10,7 @@ import (
 
 const fieldNameWindowBasedEvaluation = `window_based_evaluation`
 const fieldNameRequestBasedEvaluation = `request_based_evaluation`
+const fieldNameMonitorBasedEvaluation = `monitor_based_evaluation`
 const sloContentTypeString = "Slo"
 
 func resourceSumologicSLO() *schema.Resource {
@@ -116,6 +117,41 @@ func resourceSumologicSLO() *schema.Resource {
 		},
 	}
 
+	triggerTypeSchema := &schema.Schema{
+		Type: schema.TypeString,
+		ValidateFunc: validation.StringInSlice([]string{
+			"Critical", "Warning", "MissingData",
+		}, false),
+	}
+
+	monitorTriggerSchema := &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"monitor_id": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"trigger_types": {
+				Type:     schema.TypeList,
+				MinItems: 1,
+				MaxItems: 1,
+				Elem:     triggerTypeSchema,
+				Required: true,
+			},
+		},
+	}
+
+	monitorBasedIndicatorSchema := &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"monitor_triggers": {
+				Type:     schema.TypeList,
+				MinItems: 1,
+				MaxItems: 1,
+				Required: true,
+				Elem:     monitorTriggerSchema,
+			},
+		},
+	}
+
 	return &schema.Resource{
 		Create: resourceSumologicSLOCreate,
 		Read:   resourceSLORead,
@@ -231,6 +267,12 @@ func resourceSumologicSLO() *schema.Resource {
 							Optional: true,
 							Elem:     requestBasedIndicatorSchema,
 						},
+						fieldNameMonitorBasedEvaluation: {
+							Type:     schema.TypeList,
+							MaxItems: 1,
+							Optional: true,
+							Elem:     monitorBasedIndicatorSchema,
+						},
 					},
 				},
 			},
@@ -386,6 +428,8 @@ func flattenSLOIndicator(ind SLOIndicator) (map[string]interface{}, error) {
 		return flattenRequestIndicator(ind)
 	case "Window":
 		return flattenWindowIndicator(ind)
+	case "Monitor":
+		return flattenMonitorIndicator(ind)
 	default:
 		return nil, fmt.Errorf("unhandled indicator type found : %s", ind.EvaluationType)
 	}
@@ -410,6 +454,29 @@ func flattenRequestIndicator(ind SLOIndicator) (map[string]interface{}, error) {
 	}, nil
 }
 
+func flattenMonitorIndicator(ind SLOIndicator) (map[string]interface{}, error) {
+	monitorIndicator := map[string]interface{}{}
+	monitorTriggers, err := flattenMonitorTriggers(ind.MonitorTriggers)
+	if err != nil {
+		return nil, err
+	}
+	monitorIndicator["monitor_triggers"] = monitorTriggers
+	return map[string]interface{}{
+		fieldNameMonitorBasedEvaluation: []interface{}{monitorIndicator},
+	}, nil
+}
+
+func flattenMonitorTriggers(triggers []MonitorTrigger) ([]interface{}, error) {
+	var triggerList []interface{}
+	for _, trigger := range triggers {
+		queryMap := map[string]interface{}{}
+		queryMap["monitor_id"] = trigger.MonitorId
+		queryMap["trigger_types"] = trigger.TriggerTypes
+		triggerList = append(triggerList, queryMap)
+	}
+	return triggerList, nil
+}
+
 func flattenWindowIndicator(ind SLOIndicator) (map[string]interface{}, error) {
 	windowIndicator := map[string]interface{}{}
 	windowIndicator["query_type"] = ind.QueryType
@@ -582,7 +649,34 @@ func getSLOIndicator(d *schema.ResourceData) (*SLOIndicator, error) {
 		}, nil
 	}
 
-	return nil, fmt.Errorf("can't find indicator in resource, valid types are '%s' and '%s'", fieldNameRequestBasedEvaluation, fieldNameWindowBasedEvaluation)
+	if indicatorWrapperDict[fieldNameMonitorBasedEvaluation] != nil &&
+		len(indicatorWrapperDict[fieldNameMonitorBasedEvaluation].([]interface{})) > 0 {
+		indicatorDictList := indicatorWrapperDict[fieldNameMonitorBasedEvaluation].([]interface{})
+		var monitorTriggers []MonitorTrigger
+		for _, indicatorDictElem := range indicatorDictList {
+			indicatorDictElemMapped := indicatorDictElem.(map[string]interface{})
+			monitorTriggersMappedArray := indicatorDictElemMapped["monitor_triggers"].([]interface{})
+			for _, monitorTriggersElem := range monitorTriggersMappedArray {
+				monitorIdResult := monitorTriggersElem.(map[string]interface{})["monitor_id"].(string)
+				triggerTypes := monitorTriggersElem.(map[string]interface{})["trigger_types"].([]interface{})
+				var triggerTypesResult []string
+				for _, triggerType := range triggerTypes {
+					triggerTypesResult = append(triggerTypesResult, triggerType.(string))
+				}
+				monitorTriggers = append(monitorTriggers, MonitorTrigger{
+					MonitorId:    monitorIdResult,
+					TriggerTypes: triggerTypesResult,
+				})
+			}
+		}
+
+		return &SLOIndicator{
+			EvaluationType:  "Monitor",
+			MonitorTriggers: monitorTriggers,
+		}, nil
+	}
+
+	return nil, fmt.Errorf("can't find indicator in resource, valid types are '%s', '%s' and '%s'", fieldNameRequestBasedEvaluation, fieldNameWindowBasedEvaluation, fieldNameMonitorBasedEvaluation)
 }
 
 func GetSLOIndicatorQueries(queriesRaw []interface{}) []SLIQueryGroup {

sumologic/sumologic_slo_library_slo.go

@@ -143,14 +143,20 @@ type SLOCompliance struct {
 	StartFrom      string  `json:"startFrom,omitempty"`
 }
 
+type MonitorTrigger struct {
+	MonitorId    string   `json:"monitorId"`
+	TriggerTypes []string `json:"triggerTypes"`
+}
+
 type SLOIndicator struct {
-	EvaluationType string          `json:"evaluationType"` // string^(Window|Request)$
-	QueryType      string          `json:"queryType"`      // string^(Logs|Metrics)$
-	Queries        []SLIQueryGroup `json:"queries"`
-	Threshold      float64         `json:"threshold"`
-	Op             string          `json:"op,omitempty"`
-	Aggregation    string          `json:"aggregation,omitempty"`
-	Size           string          `json:"size,omitempty"`
+	EvaluationType  string           `json:"evaluationType"` // string^(Window|Request|Monitor)$
+	QueryType       string           `json:"queryType"`      // string^(Logs|Metrics)$
+	Queries         []SLIQueryGroup  `json:"queries"`
+	Threshold       float64          `json:"threshold"`
+	Op              string           `json:"op,omitempty"`
+	Aggregation     string           `json:"aggregation,omitempty"`
+	Size            string           `json:"size,omitempty"`
+	MonitorTriggers []MonitorTrigger `json:"monitorTriggers"`
 }
 
 type SLI struct {

website/docs/r/slo.html.markdown

@@ -117,6 +117,29 @@ QUERY
     }
   }
 }
+
+resource "sumologic_slo" "slo_tf_monitor_based" {
+  name        = "slo-tf-monitor-based"
+  description = "example of monitor based SLO created with terraform"
+  parent_id   = "0000000000000001"
+  signal_type = "Error"
+  service     = "auth"
+  application = "login"
+  compliance {
+    compliance_type = "Rolling"
+    size            = "7d"
+    target          = 99
+    timezone        = "Asia/Kolkata"
+  }
+  indicator {
+    monitor_based_evaluation {
+      monitor_triggers {
+        monitor_id = "0000000000BCB3A4"
+        trigger_types = ["Critical"]
+      }
+    }
+  }
+}
 ```
 
 ## Argument reference
@@ -186,6 +209,13 @@ The following arguments are supported:
         - `field` - (Optional) Field of log query output to compare against. To be used only for logs based data
           type when `use_row_count` is false.
 
+#### monitor_based_evaluation
+
+- `monitor_triggers` - (Required) Monitor details on which SLO will be based. Only single monitor is supported here.
+    - `monitor_id` - (Required) ID of the monitor. Ex: `0000000000BCB3A4`
+    - `trigger_types` - (Required) Type of monitor trigger which will attribute towards a successful or unsuccessful SLO 
+       window. Valid values are `Critical`, `Warning`, `MissingData`. Only one trigger type is supported.
+    
 [1]: https://help.sumologic.com/Beta/SLO_Reliability_Management
 
 [2]: slo_folder.html.markdown