Agents auto-retry connect to heartbeat server alternative addresses

.gitignore

@@ -4,3 +4,19 @@ out/
 *.swo
 *.tar.gz
 docs/_site
+vendor/
+
+# binary file
+falcon-agent  
+falcon-aggregator  
+falcon-alarm  
+falcon-api  
+falcon-gateway  
+falcon-graph  
+falcon-hbs  
+falcon-judge  
+falcon-nodata  
+falcon-transfer
+open-falcon
+
+git.go

README.md

@@ -59,6 +59,12 @@ mysql -h 127.0.0.1 -u root -p < 4_graph-db-schema.sql
 mysql -h 127.0.0.1 -u root -p < 5_alarms-db-schema.sql
 ```
 
+Optional feature: matched string persistence in MySQL DB
+
+    mysql -h 127.0.0.1 -u root -p < scripts/mysql/db_schema/6_history-db-schema.sql
+
+
+
 **NOTE: if you are upgrading from v0.1 to current version v0.2.0,then**. [More upgrading instruction](http://www.jianshu.com/p/6fb2c2b4d030)
 
     mysql -h 127.0.0.1 -u root -p < 5_alarms-db-schema.sql

common/model/eexp.go

@@ -0,0 +1,125 @@
+package model
+
+import (
+	"encoding/json"
+	"log"
+	"math"
+	"strconv"
+)
+
+type Filter struct {
+	Func       string      `json:"func"`
+	Key        string      `json:"key"`
+	Ago        uint64      `json:"ago"`   // for func count
+	Hits       uint64      `json:"hits"`  // for func count
+	Limit      uint64      `json:"limit"` // for func all
+	Operator   string      `json:"operator"`
+	RightValue interface{} `json:"rightValue"`
+}
+
+type EExpResponse struct {
+	EExps []EExp `json:"eexps"`
+}
+
+type EExp struct {
+	ID       int               `json:"id"`
+	Key      string            `json:"key"` // join(sorted(conditionKeys), ",")
+	Filters  map[string]Filter `json:"filters"`
+	Priority int               `json:"priority"`
+	MaxStep  int               `json:"maxStep"`
+	Note     string            `json:"note"`
+}
+
+func (c *Filter) String() string {
+	out, _ := json.Marshal(c)
+	return string(out)
+}
+
+func (ee *EExp) String() string {
+	out, _ := json.Marshal(ee)
+	return string(out)
+}
+
+func opResultFloat64(leftValue float64, operator string, rightValue float64) (isTriggered bool) {
+	switch operator {
+	case "=", "==":
+		isTriggered = math.Abs(leftValue-rightValue) < 0.0001
+	case "!=":
+		isTriggered = math.Abs(leftValue-rightValue) > 0.0001
+	case "<":
+		isTriggered = leftValue < rightValue
+	case "<=":
+		isTriggered = leftValue <= rightValue
+	case ">":
+		isTriggered = leftValue > rightValue
+	case ">=":
+		isTriggered = leftValue >= rightValue
+	}
+	return
+}
+
+func opResultString(leftValue string, operator string, rightValue string) (isTriggered bool) {
+	switch operator {
+	case "=", "==":
+		isTriggered = leftValue == rightValue
+	case "!=":
+		isTriggered = leftValue != rightValue
+	}
+	return
+}
+
+func (ee *EExp) HitFilters(m *map[string]interface{}) bool {
+	var err error
+	for k, filter := range ee.Filters {
+		valueI, ok := (*m)[k]
+		if !ok {
+			return false
+		}
+
+		switch filter.RightValue.(type) {
+		case float64:
+			{
+
+				var leftValue float64
+				leftValueStr, ok := valueI.(string)
+				if ok {
+					leftValue, err = strconv.ParseFloat(leftValueStr, 64)
+					if err != nil {
+						log.Println("strconv.ParseFloat failed", err)
+						return false
+					}
+				} else {
+					leftValue, ok = valueI.(float64)
+					if !ok {
+						log.Println("parse in float64 failed")
+						return false
+					}
+				}
+
+				rightValue := filter.RightValue.(float64)
+
+				if !opResultFloat64(leftValue, filter.Operator, rightValue) {
+					return false
+				}
+
+			}
+		case string:
+			{
+				leftValue, ok := valueI.(string)
+				if !ok {
+					log.Println("parse in string failed")
+					return false
+				}
+
+				rightValue := filter.RightValue.(string)
+
+				if !opResultString(leftValue, filter.Operator, rightValue) {
+					return false
+				}
+
+			}
+		}
+
+	}
+	return true
+}

common/model/ejudge.go

@@ -0,0 +1,6 @@
+package model
+
+type EHistoryData struct {
+	Timestamp int64                  `json:"timestamp"`
+	Filters   map[string]interface{} `json:"filters"`
+}

common/model/emetric.go

@@ -0,0 +1,18 @@
+package model
+
+type EMetric struct {
+	Endpoint  string                 `json:"endpoint"`
+	Key       string                 `json:"key"`
+	Filters   map[string]interface{} `json:"values"`
+	Timestamp int64                  `json:"timestamp"`
+}
+
+func NewEMetric() *EMetric {
+	e := EMetric{}
+	e.Filters = map[string]interface{}{}
+	return &e
+}
+
+func (e *EMetric) PK() string {
+	return e.Key
+}

common/model/event.go

@@ -15,6 +15,7 @@
 package model
 
 import (
+	"encoding/json"
 	"fmt"
 
 	"github.com/open-falcon/falcon-plus/common/utils"
@@ -25,9 +26,10 @@ type Event struct {
 	Id          string            `json:"id"`
 	Strategy    *Strategy         `json:"strategy"`
 	Expression  *Expression       `json:"expression"`
+	EExp        *EExp             `json:"eexp"`
 	Status      string            `json:"status"` // OK or PROBLEM
 	Endpoint    string            `json:"endpoint"`
-	LeftValue   float64           `json:"leftValue"`
+	LeftValue   interface{}       `json:"leftValue"`
 	CurrentStep int               `json:"currentStep"`
 	EventTime   int64             `json:"eventTime"`
 	PushedTags  map[string]string `json:"pushedTags"`
@@ -38,13 +40,23 @@ func (this *Event) FormattedTime() string {
 }
 
 func (this *Event) String() string {
+	var leftValue interface{}
+	switch this.LeftValue.(type) {
+	case float64:
+		leftValue = utils.ReadableFloat(this.LeftValue.(float64))
+	default:
+		leftValue = this.LeftValue
+
+	}
+
 	return fmt.Sprintf(
-		"<Endpoint:%s, Status:%s, Strategy:%v, Expression:%v, LeftValue:%s, CurrentStep:%d, PushedTags:%v, TS:%s>",
+		"<Endpoint:%s, Status:%s, Strategy:%v, Expression:%v, EExp:%v LeftValue:%v, CurrentStep:%d, PushedTags:%v, TS:%s>",
 		this.Endpoint,
 		this.Status,
 		this.Strategy,
 		this.Expression,
-		utils.ReadableFloat(this.LeftValue),
+		this.EExp,
+		leftValue,
 		this.CurrentStep,
 		this.PushedTags,
 		this.FormattedTime(),
@@ -59,6 +71,13 @@ func (this *Event) ExpressionId() int {
 	return 0
 }
 
+func (this *Event) EExpID() int {
+	if this.Expression != nil {
+		return this.EExp.ID
+	}
+	return 0
+}
+
 func (this *Event) StrategyId() int {
 	if this.Strategy != nil {
 		return this.Strategy.Id
@@ -88,56 +107,107 @@ func (this *Event) ActionId() int {
 		return this.Expression.ActionId
 	}
 
-	return this.Strategy.Tpl.ActionId
+	if this.Strategy != nil {
+		return this.Strategy.Tpl.ActionId
+	}
+
+	return -1
+
 }
 
 func (this *Event) Priority() int {
 	if this.Strategy != nil {
 		return this.Strategy.Priority
 	}
-	return this.Expression.Priority
+	if this.Expression != nil {
+		return this.Expression.Priority
+	}
+
+	if this.EExp != nil {
+		return this.EExp.Priority
+	}
+	return -1
 }
 
 func (this *Event) Note() string {
 	if this.Strategy != nil {
 		return this.Strategy.Note
 	}
-	return this.Expression.Note
+
+	if this.Expression != nil {
+		return this.Expression.Note
+
+	}
+	if this.EExp != nil {
+		return this.EExp.Note
+	}
+	return ""
 }
 
 func (this *Event) Metric() string {
 	if this.Strategy != nil {
 		return this.Strategy.Metric
 	}
-	return this.Expression.Metric
+	if this.Expression != nil {
+		return this.Expression.Metric
+	}
+	if this.EExp != nil {
+		return this.EExp.Key
+	}
+	return ""
 }
 
 func (this *Event) RightValue() float64 {
 	if this.Strategy != nil {
 		return this.Strategy.RightValue
 	}
-	return this.Expression.RightValue
+
+	if this.Expression != nil {
+		return this.Expression.RightValue
+	}
+
+	return 0.0
 }
 
 func (this *Event) Operator() string {
 	if this.Strategy != nil {
 		return this.Strategy.Operator
 	}
-	return this.Expression.Operator
+
+	if this.Expression != nil {
+		return this.Expression.Operator
+	}
+	return ""
 }
 
 func (this *Event) Func() string {
 	if this.Strategy != nil {
 		return this.Strategy.Func
 	}
-	return this.Expression.Func
+
+	if this.Expression != nil {
+		return this.Expression.Func
+	}
+
+	if this.EExp != nil {
+		out, _ := json.Marshal(this.EExp.Filters)
+		return string(out)
+	}
+	return ""
 }
 
 func (this *Event) MaxStep() int {
 	if this.Strategy != nil {
 		return this.Strategy.MaxStep
 	}
-	return this.Expression.MaxStep
+
+	if this.Expression != nil {
+		return this.Expression.MaxStep
+	}
+	if this.EExp != nil {
+		return this.EExp.MaxStep
+	}
+	return 1
 }
 
 func (this *Event) Counter() string {

common/model/judge.go

@@ -24,16 +24,18 @@ type JudgeItem struct {
 	Endpoint  string            `json:"endpoint"`
 	Metric    string            `json:"metric"`
 	Value     float64           `json:"value"`
+	ValueRaw  string            `json:"valueRaw"`
 	Timestamp int64             `json:"timestamp"`
 	JudgeType string            `json:"judgeType"`
 	Tags      map[string]string `json:"tags"`
 }
 
 func (this *JudgeItem) String() string {
-	return fmt.Sprintf("<Endpoint:%s, Metric:%s, Value:%f, Timestamp:%d, JudgeType:%s Tags:%v>",
+	return fmt.Sprintf("<Endpoint:%s, Metric:%s, Value:%.2f ValueRaw:%s, Timestamp:%d, JudgeType:%s Tags:%v>",
 		this.Endpoint,
 		this.Metric,
 		this.Value,
+		this.ValueRaw,
 		this.Timestamp,
 		this.JudgeType,
 		this.Tags)
@@ -46,4 +48,5 @@ func (this *JudgeItem) PrimaryKey() string {
 type HistoryData struct {
 	Timestamp int64   `json:"timestamp"`
 	Value     float64 `json:"value"`
+	ValueRaw  string  `json:"valueRaw"`
 }