Add support for iterating over external data

src/metrics-alerting/alert/alert.go

 	"fmt"
 
 	"metrics-alerting/config"
+	"metrics-alerting/script_data"
 
 	"gopkg.in/gomail.v2"
 )
 	script config.Script,
 	result interface{},
 	labels map[string]string,
+	data script_data.Data,
 ) error {
 	switch script.Action {
 	case "http":
-		return a.alertHttp(script, result, labels)
+		return a.alertHttp(script, result, labels, data)
 	case "email":
-		return a.alertEmail(script, result, labels)
+		return a.alertEmail(script, result, labels, data)
 	default:
 		return fmt.Errorf("invalid action type: %s", script.Action)
 	}

src/metrics-alerting/alert/email.go

 	"strings"
 
 	"metrics-alerting/config"
+	"metrics-alerting/script_data"
 
 	"gopkg.in/gomail.v2"
 )
 	script config.Script,
 	result interface{},
 	labels map[string]string,
+	data script_data.Data,
 ) error {
-	formatNumber := "Script %s just exceeded its threshold of %.2f and now returns %f"
-	formatBool := "Test for script %s and returned false instead of true"
+	formatNumber := "Script \"%s\" just exceeded its threshold of %.2f and now returns %f"
+	formatBool := "Test for script \"%s\" failed and returned false instead of true"
 
 	var body, subject string
 	switch script.Type {
 	case "number", "series":
 		subject = fmt.Sprintf(
-			"Threshold exceeded for script %s %s", script.Key,
-			getIdentifyingLabels(script, labels),
+			"Threshold exceeded for script \"%s\" %s%s", script.Key,
+			getIdentifyingLabels(script, labels), getScriptData(data),
 		)
 		body = fmt.Sprintf(
 			formatNumber, script.Key, script.Threshold, result.(float64),
 		)
 	case "bool":
 		subject = fmt.Sprintf(
-			"Test for script %s failed %s", script.Key,
-			getIdentifyingLabels(script, labels),
+			"Test for script \"%s\" failed %s%s", script.Key,
+			getIdentifyingLabels(script, labels), getScriptData(data),
 		)
 		body = fmt.Sprintf(formatBool, script.Key)
 	}
 
 	identifyingLabels := make(map[string]string)
 	for _, label := range script.IdentifyingLabels {
-		identifyingLabels[label] = labels[label]
+		if len(labels[label]) > 0 {
+			identifyingLabels[label] = labels[label]
+		}
 	}
 
 	labelsAsStrs := []string{}
 
 	return "(" + strings.Join(labelsAsStrs, ", ") + ")"
 }
+
+func getScriptData(data script_data.Data) string {
+	if len(data.Key) == 0 {
+		return ""
+	}
+
+	return "(" + data.Key + "=" + data.Value + ")"
+}

src/metrics-alerting/alert/http.go

 	"strconv"
 
 	"metrics-alerting/config"
+	"metrics-alerting/script_data"
 )
 
 type alertBody struct {
 	Key    string            `json:"scriptKey"`
 	Value  string            `json:"value"`
 	Labels map[string]string `json:"labels"`
+	Data   map[string]string `json:"data"`
 }
 
 func (a *Alerter) alertHttp(
 	script config.Script,
 	result interface{},
 	labels map[string]string,
+	data script_data.Data,
 ) error {
 	var value string
 	switch script.Type {
 		value = strconv.FormatBool(result.(bool))
 	}
 
+	returnData := make(map[string]string)
+	returnData[data.Key] = data.Value
+
 	alert := alertBody{
 		Key:    script.Key,
 		Value:  value,
 		Labels: labels,
+		Data:   returnData,
 	}
 
 	body, err := json.Marshal(alert)

src/metrics-alerting/config/config.go

 package config
 
 import (
+	"bufio"
+	"io"
 	"io/ioutil"
+	"os"
 
 	"gopkg.in/yaml.v2"
 )
 	Password string `yaml:"password"`
 }
 
+type ScriptDataSource struct {
+	// Data to load from a file containing the content for the slide, one
+	// element per line
+	FromFile map[string]string `yaml:"from_file,omitempty"`
+	// Plain data
+	Plain map[string][]string `yaml:"plain,omitempty"`
+}
+
 type Script struct {
 	// An identifying key for the script
 	Key string `yaml:"key"`
 	// The labels that will be mentioned in the email subject, only required if
 	// the action is "email"
 	IdentifyingLabels []string `yaml:"identifying_labels,omitempty"`
+	// Data to use in the script
+	DataSource ScriptDataSource `yaml:"script_data,omitempty"`
+	// Loaded data
+	ScriptData map[string][]string
 }
 
 type Config struct {
 	Scripts []Script `yaml:"scripts"`
 }
 
-func Load(filePath string) (cfg Config, err error) {
+func (cfg *Config) Load(filePath string) (err error) {
 	content, err := ioutil.ReadFile(filePath)
 	if err != nil {
 		return
 	}
 
 	err = yaml.Unmarshal(content, &cfg)
-	return
+	if err != nil {
+		return
+	}
+
+	return cfg.loadData()
+}
+
+func (cfg *Config) loadData() error {
+	var line string
+	var l []byte
+	var isPrefix bool
+	for i, script := range cfg.Scripts {
+		script.ScriptData = make(map[string][]string)
+		for key, fileName := range script.DataSource.FromFile {
+			fp, err := os.Open(fileName)
+			if err != nil {
+				return err
+			}
+			reader := bufio.NewReader(fp)
+
+			for true {
+				isPrefix = true
+				line = ""
+				for isPrefix {
+					l, isPrefix, err = reader.ReadLine()
+					if err != nil && err != io.EOF {
+						return err
+					}
+					line = line + string(l)
+				}
+
+				if err == io.EOF {
+					break
+				}
+
+				script.ScriptData[key] = append(script.ScriptData[key], line)
+			}
+		}
+		for key, slice := range script.DataSource.Plain {
+			script.ScriptData[key] = slice
+		}
+
+		cfg.Scripts[i] = script
+	}
+
+	return nil
 }

src/metrics-alerting/main.go

 
 import (
 	"flag"
-	"fmt"
 
 	"metrics-alerting/alert"
 	"metrics-alerting/config"
 func main() {
 	flag.Parse()
 
-	cfg, _ := config.Load(*configPath)
+	cfg := config.Config{}
+	if err := cfg.Load(*configPath); err != nil {
+		logrus.Panic(err)
+	}
 	client := warp10.Warp10Client{
 		ExecEndpoint: cfg.Warp10Exec,
 		ReadToken:    cfg.ReadToken,
 	}
 
 	for _, script := range cfg.Scripts {
-		var err error
-		switch script.Type {
-		case "number":
-			err = process.ProcessNumber(client, script, alerter)
-			break
-		case "bool":
-			err = process.ProcessBool(client, script, alerter)
-			break
-		case "series":
-			err = process.ProcessSeries(client, script, alerter)
-			break
-		default:
-			err = fmt.Errorf("invalid return type: %s", script.Type)
-		}
-
-		if err != nil {
+		if err := process.Process(client, script, alerter); err != nil {
 			logrus.Error(err)
 		}
 	}

src/metrics-alerting/process/process.go

 package process
 
 import (
+	"fmt"
+	"regexp"
 	"time"
 
 	"metrics-alerting/alert"
 	"metrics-alerting/config"
+	"metrics-alerting/script_data"
 	"metrics-alerting/warp10"
 )
 
-func ProcessNumber(
+func Process(
 	client warp10.Warp10Client,
 	script config.Script,
 	alerter alert.Alerter,
 ) error {
+	var scriptData script_data.Data
+	// TODO: Process more than one dataset
+	for key, data := range script.ScriptData {
+		scriptData.Key = key
+		r, err := regexp.Compile("`" + key + "`")
+		if err != nil {
+			return err
+		}
+		match := r.Find([]byte(script.Script))
+		if len(match) == 0 {
+			return fmt.Errorf("no variable named %s in script %s", key, script.Key)
+		}
+
+		origScript := script.Script
+
+		for _, el := range data {
+			scriptData.Value = el
+			filledScript := r.ReplaceAll([]byte(origScript), []byte(el))
+			script.Script = string(filledScript)
+			if err = dispatchType(client, script, alerter, scriptData); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func dispatchType(
+	client warp10.Warp10Client,
+	script config.Script,
+	alerter alert.Alerter,
+	data script_data.Data,
+) error {
+	switch script.Type {
+	case "number":
+		return processNumber(client, script, alerter, data)
+	case "bool":
+		return processBool(client, script, alerter, data)
+	case "series":
+		return processSeries(client, script, alerter, data)
+	}
+	return fmt.Errorf("invalid return type: %s", script.Type)
+}
+
+func processNumber(
+	client warp10.Warp10Client,
+	script config.Script,
+	alerter alert.Alerter,
+	data script_data.Data,
+) error {
 	value, err := client.ReadNumber(script.Script)
 	if err != nil {
 		return err
 	}
 
-	return processFloat(value, script, alerter, nil)
+	return processFloat(value, script, alerter, nil, data)
 }
 
-func ProcessBool(
+func processBool(
 	client warp10.Warp10Client,
 	script config.Script,
 	alerter alert.Alerter,
+	data script_data.Data,
 ) error {
 	value, err := client.ReadBool(script.Script)
 	if err != nil {
 		return nil
 	}
 
-	return alerter.Alert(script, value, nil)
+	return alerter.Alert(script, value, nil, data)
 }
 
-func ProcessSeries(
+func processSeries(
 	client warp10.Warp10Client,
 	script config.Script,
 	alerter alert.Alerter,
+	data script_data.Data,
 ) error {
 	series, err := client.ReadSeriesOfNumbers(script.Script)
 
 		// to find when the situation began so we can add info about time in the
 		// alert.
 		if err = processFloat(
-			serie.Datapoints[0][1], script, alerter, serie.Labels,
+			serie.Datapoints[0][1], script, alerter, serie.Labels, data,
 		); err != nil {
 			return err
 		}
 	script config.Script,
 	alerter alert.Alerter,
 	labels map[string]string,
+	data script_data.Data,
 ) error {
 	if value < script.Threshold {
 		// Nothing to alert about
 		return nil
 	}
 
-	return alerter.Alert(script, value, labels)
+	return alerter.Alert(script, value, labels, data)
 }
 
 func isRecentEnough(datapoint []float64) bool {

src/metrics-alerting/script_data/script_data.go

+package script_data
+
+type Data struct {
+	Key   string
+	Value string
+}