Merge remote-tracking branch 'origin/develop' into feature/os

alert/.gitignore

+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+vendor/
+
+# Project specific files
+cmd/alert/alert
+cmd/alert/alert.log
+*.db
+*.gz
\ No newline at end of file

alert/README.md

+# Alert
+
+The Alert application reads data from [TDEngine](https://www.taosdata.com/), calculating according to predefined rules to generate alerts, and pushes alerts to downstream applications like [AlertManager](https://github.com/prometheus/alertmanager).
+
+## Install
+
+### From Binary
+
+Precompiled binaries is available at [taosdata website](https://www.taosdata.com/en/getting-started/), please download and unpack it by below shell command.
+
+```
+$ tar -xzf tdengine-alert-$version-$OS-$ARCH.tar.gz 
+```
+
+If you have no TDengine server or client installed, please execute below command to install the required driver library:
+
+```
+$ ./install_driver.sh
+```
+
+### From Source Code
+
+Two prerequisites are required to install from source.
+
+1. TDEngine server or client must be installed.
+2. Latest [Go](https://golang.org) language must be installed.
+
+When these two prerequisites are ready, please follow steps below to build the application:
+
+```
+$ mkdir taosdata
+$ cd taosdata
+$ git clone https://github.com/taosdata/tdengine.git
+$ cd tdengine/alert/cmd/alert
+$ go build
+```
+
+If `go build` fails because some of the dependency packages cannot be downloaded, please follow steps in [goproxy.io](https://goproxy.io) to configure `GOPROXY` and try `go build` again.
+
+## Configure
+
+The configuration file format of Alert application is standard `json`, below is its default content, please revise according to actual scenario.
+
+```json
+{
+  "port": 8100,
+  "database": "file:alert.db",
+  "tdengine": "root:taosdata@/tcp(127.0.0.1:0)/",
+  "log": {
+    "level": "production",
+    "path": "alert.log"
+  },
+  "receivers": {
+    "alertManager": "http://127.0.0.1:9093/api/v1/alerts",
+    "console": true
+  }
+}
+```
+
+The use of each configuration item is:
+
+* **port**: This is the `http` service port which enables other application to manage rules by `restful API`.
+* **database**: rules are stored in a `sqlite` database, this is the path of the database file (if the file does not exist, the alert application creates it automatically).
+* **tdengine**: connection string of `TDEngine` server, note in most cases the database information should be put in a rule, thus it should NOT be included here.
+* **log > level**: log level, could be `production` or `debug`.
+* **log > path**: log output file path.
+* **receivers > alertManager**: the alert application pushes alerts to `AlertManager` at this URL.
+* **receivers > console**: print out alerts to console (stdout) or not.
+
+When the configruation file is ready, the alert application can be started with below command (`alert.cfg` is the path of the configuration file):
+
+```
+$ ./alert -cfg alert.cfg
+```
+
+## Prepare an alert rule
+
+From technical aspect, an alert could be defined as: query and filter recent data from `TDEngine`, and calculating out a boolean value from these data according to a formula, and trigger an alert if the boolean value last for a certain duration.
+
+This is a rule example in `json` format:
+
+```json
+{
+  "name": "rule1",
+  "sql": "select sum(col1) as sumCol1 from test.meters where ts > now - 1h group by areaid",
+  "expr": "sumCol1 > 10",
+  "for": "10m",
+  "period": "1m",
+  "labels": {
+    "ruleName": "rule1"
+  },
+  "annotations": {
+    "summary": "sum of rule {{$labels.ruleName}} of area {{$values.areaid}} is {{$values.sumCol1}}"
+  }
+}
+```
+
+The fields of the rule is explained below:
+
+* **name**: the name of the rule, must be unique.
+* **sql**: this is the `sql` statement used to query data from `TDEngine`, columns of the query result are used in later processing, so please give the column an alias if aggregation functions are used.
+* **expr**: an expression whose result is a boolean value, arithmatic and logical calculations can be included in the expression, and builtin functions (see below) are also supported. Alerts are only triggered when the expression evaluates to `true`.
+* **for**: this item is a duration which default value is zero second. when `expr` evaluates to `true` and last at least this duration, an alert is triggered.
+* **period**: the interval for the alert application to check the rule, default is 1 minute.
+* **labels**: a label list, labels are used to generate alert information. note if the `sql` statement includes a `group by` clause, the `group by` columns are inserted into this list automatically.
+* **annotations**: the template of alert information which is in [go template](https://golang.org/pkg/text/template) syntax, labels can be referenced by `$labels.<label name>` and columns of the query result can be referenced by `$values.<column name>`.
+
+### Operators
+
+Operators which can be used in the `expr` field of a rule are list below, `()` can be to change precedence if default does not meet requirement.
+
+<table>
+<thead>
+<tr> <td>Operator</td><td>Unary/Binary</td><td>Precedence</td><td>Effect</td> </tr>
+</thead>
+<tbody>
+<tr> <td>~</td><td>Unary</td><td>6</td><td>Bitwise Not</td> </tr>
+<tr> <td>!</td><td>Unary</td><td>6</td><td>Logical Not</td> </tr>
+<tr> <td>+</td><td>Unary</td><td>6</td><td>Positive Sign</td> </tr>
+<tr> <td>-</td><td>Unary</td><td>6</td><td>Negative Sign</td> </tr>
+<tr> <td>*</td><td>Binary</td><td>5</td><td>Multiplication</td> </tr>
+<tr> <td>/</td><td>Binary</td><td>5</td><td>Division</td> </tr>
+<tr> <td>%</td><td>Binary</td><td>5</td><td>Modulus</td> </tr>
+<tr> <td><<</td><td>Binary</td><td>5</td><td>Bitwise Left Shift</td> </tr>
+<tr> <td>>></td><td>Binary</td><td>5</td><td>Bitwise Right Shift</td> </tr>
+<tr> <td>&</td><td>Binary</td><td>5</td><td>Bitwise And</td> </tr>
+<tr> <td>+</td><td>Binary</td><td>4</td><td>Addition</td> </tr>
+<tr> <td>-</td><td>Binary</td><td>4</td><td>Subtraction</td> </tr>
+<tr> <td>|</td><td>Binary</td><td>4</td><td>Bitwise Or</td> </tr>
+<tr> <td>^</td><td>Binary</td><td>4</td><td>Bitwise Xor</td> </tr>
+<tr> <td>==</td><td>Binary</td><td>3</td><td>Equal</td> </tr>
+<tr> <td>!=</td><td>Binary</td><td>3</td><td>Not Equal</td> </tr>
+<tr> <td><</td><td>Binary</td><td>3</td><td>Less Than</td> </tr>
+<tr> <td><=</td><td>Binary</td><td>3</td><td>Less Than or Equal</td> </tr>
+<tr> <td>></td><td>Binary</td><td>3</td><td>Great Than</td> </tr>
+<tr> <td>>=</td><td>Binary</td><td>3</td><td>Great Than or Equal</td> </tr>
+<tr> <td>&&</td><td>Binary</td><td>2</td><td>Logical And</td> </tr>
+<tr> <td>||</td><td>Binary</td><td>1</td><td>Logical Or</td> </tr>
+</tbody>
+</table>
+
+### Built-in Functions
+
+Built-in function can be used in the `expr` field of a rule.
+
+* **min**: returns the minimum one of its arguments, for example: `min(1, 2, 3)` returns `1`.
+* **max**: returns the maximum one of its arguments, for example: `max(1, 2, 3)` returns `3`.
+* **sum**: returns the sum of its arguments, for example: `sum(1, 2, 3)` returns `6`.
+* **avg**: returns the average of its arguments, for example: `avg(1, 2, 3)` returns `2`.
+* **sqrt**: returns the square root of its argument, for example: `sqrt(9)` returns `3`.
+* **ceil**: returns the minimum integer which greater or equal to its argument, for example: `ceil(9.1)` returns `10`.
+* **floor**: returns the maximum integer which lesser or equal to its argument, for example: `floor(9.9)` returns `9`.
+* **round**: round its argument to nearest integer, for examples: `round(9.9)` returns `10` and `round(9.1)` returns `9`.
+* **log**: returns the natural logarithm of its argument, for example: `log(10)` returns `2.302585`. 
+* **log10**: returns base 10 logarithm of its argument, for example: `log10(10)` return `1`.
+* **abs**: returns the absolute value of its argument, for example: `abs(-1)` returns `1`.
+* **if**: if the first argument is `true` returns its second argument, and returns its third argument otherwise, for examples: `if(true, 10, 100)` returns `10` and `if(false, 10, 100)` returns `100`.
+
+## Rule Management
+
+* Add / Update
+
+    * API address: http://\<server\>:\<port\>/api/update-rule
+    * Method: POST
+    * Body: the rule
+    * Example：curl -d '@rule.json' http://localhost:8100/api/update-rule
+
+* Delete
+
+    * API address: http://\<server\>:\<port\>/api/delete-rule?name=\<rule name\>
+    * Method：DELETE
+    * Example：curl -X DELETE http://localhost:8100/api/delete-rule?name=rule1
+
+* Enable / Disable
+
+    * API address: http://\<server\>:\<port\>/api/enable-rule?name=\<rule name\>&enable=[true | false]
+    * Method POST
+    * Example：curl -X POST http://localhost:8100/api/enable-rule?name=rule1&enable=true
+
+* Retrieve rule list
+
+    * API address: http://\<server\>:\<port\>/api/list-rule
+    * Method: GET
+    * Example：curl http://localhost:8100/api/list-rule

alert/README_cn.md

+# Alert
+
+报警监测程序，从 [TDEngine](https://www.taosdata.com/) 读取数据后，根据预定义的规则计算和生成报警，并将它们推送到 [AlertManager](https://github.com/prometheus/alertmanager) 或其它下游应用。
+
+## 安装
+
+### 使用编译好的二进制文件
+
+您可以从 [涛思数据](https://www.taosdata.com/cn/getting-started/) 官网下载最新的安装包。下载完成后，使用以下命令解压：
+
+```
+$ tar -xzf tdengine-alert-$version-$OS-$ARCH.tar.gz 
+```
+
+如果您之前没有安装过 TDengine 的服务端或客户端，您需要使用下面的命令安装 TDengine 的动态库：
+
+```
+$ ./install_driver.sh
+```
+
+### 从源码安装
+
+从源码安装需要在您用于编译的计算机上提前安装好 TDEngine 的服务端或客户端，如果您还没有安装，可以参考 TDEngine 的文档。
+
+报警监测程序使用 [Go语言](https://golang.org) 开发，请安装最新版的 Go 语言编译环境。
+
+```
+$ mkdir taosdata
+$ cd taosdata
+$ git clone https://github.com/taosdata/tdengine.git
+$ cd tdengine/alert/cmd/alert
+$ go build
+```
+
+如果由于部分包无法下载导致 `go build` 失败，请根据 [goproxy.io](https://goproxy.io) 上的说明配置好 `GOPROXY` 再重新执行 `go build`。
+
+## 配置
+
+报警监测程序的配置文件采用标准`json`格式，下面是默认的文件内容，请根据实际情况修改。
+
+```json
+{
+  "port": 8100,
+  "database": "file:alert.db",
+  "tdengine": "root:taosdata@/tcp(127.0.0.1:0)/",
+  "log": {
+    "level": "production",
+    "path": "alert.log"
+  },
+  "receivers": {
+    "alertManager": "http://127.0.0.1:9093/api/v1/alerts",
+    "console": true
+  }
+}
+```
+
+其中：
+
+* **port**：报警监测程序支持使用 `restful API` 对规则进行管理，这个参数用于配置 `http` 服务的侦听端口。
+* **database**：报警监测程序将规则保存到了一个 `sqlite` 数据库中，这个参数用于指定数据库文件的路径（不需要提前创建这个文件，如果它不存在，程序会自动创建它）。
+* **tdengine**：`TDEngine` 的连接信息，一般来说，数据库信息应该在报警规则中指定，所以这里 **不** 应包含这一部分信息。
+* **log > level**：日志的记录级别，可选 `production` 或 `debug`。
+* **log > path**：日志文件的路径。
+* **receivers > alertManager**：报警监测程序会将报警推送到 `AlertManager`，在这里指定 `AlertManager` 的接收地址。
+* **receivers > console**：是否输出到控制台 (stdout)。
+
+准备好配置文件后，可使用下面的命令启动报警监测程序（ `alert.cfg` 是配置文件的路径）：
+
+```
+$ ./alert -cfg alert.cfg
+```
+
+## 编写报警规则
+
+从技术角度，可以将报警描述为：从 `TDEngine` 中查询最近一段时间、符合一定过滤条件的数据，并基于这些数据根据定义好的计算方法得出一个结果，当结果符合某个条件且持续一定时间后，触发报警。
+
+根据上面的描述，可以很容易的知道报警规则中需要包含的大部分信息。 以下是一个完整的报警规则，采用标准 `json` 格式：
+
+```json
+{
+  "name": "rule1",
+  "sql": "select sum(col1) as sumCol1 from test.meters where ts > now - 1h group by areaid",
+  "expr": "sumCol1 > 10",
+  "for": "10m",
+  "period": "1m",
+  "labels": {
+    "ruleName": "rule1"
+  },
+  "annotations": {
+    "summary": "sum of rule {{$labels.ruleName}} of area {{$values.areaid}} is {{$values.sumCol1}}"
+  }
+}
+```
+
+其中：
+
+* **name**：用于为规则指定一个唯一的名字。
+* **sql**：从 `TDEngine` 中查询数据时使用的 `sql` 语句，查询结果中的列将被后续计算使用，所以，如果使用了聚合函数，请为这一列指定一个别名。
+* **expr**：一个计算结果为布尔型的表达式，支持算数运算、逻辑运算，并且内置了部分函数，也可以引用查询结果中的列。 当表达式计算结果为 `true` 时，进入报警状态。
+* **for**：当表达式计算结果为 `true` 的连续时长超过这个选项时，触发报警，否则报警处于“待定”状态。默认为0，表示一旦计算结果为 `true`，立即触发报警。
+* **period**：规则的检查周期，默认1分钟。
+* **labels**：人为指定的标签列表，标签可以在生成报警信息引用。如果 `sql` 中包含 `group by` 子句，则所有用于分组的字段会被自动加入这个标签列表中。
+* **annotations**：用于定义报警信息，使用 [go template](https://golang.org/pkg/text/template) 语法，其中，可以通过 `$labels.<label name>` 引用标签，也可以通过 `$values.<column name>` 引用查询结果中的列。
+
+### 运算符
+
+以下是 `expr` 字段中支持的运算符，您可以使用 `()` 改变运算的优先级。
+
+<table>
+<thead>
+<tr> <td>运算符</td><td>单目/双目</td><td>优先级</td><td>作用</td> </tr>
+</thead>
+<tbody>
+<tr> <td>~</td><td>单目</td><td>6</td><td>按位取反</td> </tr>
+<tr> <td>!</td><td>单目</td><td>6</td><td>逻辑非</td> </tr>
+<tr> <td>+</td><td>单目</td><td>6</td><td>正号</td> </tr>
+<tr> <td>-</td><td>单目</td><td>6</td><td>负号</td> </tr>
+<tr> <td>*</td><td>双目</td><td>5</td><td>乘法</td> </tr>
+<tr> <td>/</td><td>双目</td><td>5</td><td>除法</td> </tr>
+<tr> <td>%</td><td>双目</td><td>5</td><td>取模（余数）</td> </tr>
+<tr> <td><<</td><td>双目</td><td>5</td><td>按位左移</td> </tr>
+<tr> <td>>></td><td>双目</td><td>5</td><td>按位右移</td> </tr>
+<tr> <td>&</td><td>双目</td><td>5</td><td>按位与</td> </tr>
+<tr> <td>+</td><td>双目</td><td>4</td><td>加法</td> </tr>
+<tr> <td>-</td><td>双目</td><td>4</td><td>减法</td> </tr>
+<tr> <td>|</td><td>双目</td><td>4</td><td>按位或</td> </tr>
+<tr> <td>^</td><td>双目</td><td>4</td><td>按位异或</td> </tr>
+<tr> <td>==</td><td>双目</td><td>3</td><td>等于</td> </tr>
+<tr> <td>!=</td><td>双目</td><td>3</td><td>不等于</td> </tr>
+<tr> <td><</td><td>双目</td><td>3</td><td>小于</td> </tr>
+<tr> <td><=</td><td>双目</td><td>3</td><td>小于或等于</td> </tr>
+<tr> <td>></td><td>双目</td><td>3</td><td>大于</td> </tr>
+<tr> <td>>=</td><td>双目</td><td>3</td><td>大于或等于</td> </tr>
+<tr> <td>&&</td><td>双目</td><td>2</td><td>逻辑与</td> </tr>
+<tr> <td>||</td><td>双目</td><td>1</td><td>逻辑或</td> </tr>
+</tbody>
+</table>
+
+### 内置函数
+
+目前支持以下内置函数，可以在报警规则的 `expr` 字段中使用这些函数：
+
+* **min**：取多个值中的最小值，例如 `min(1, 2, 3)` 返回 `1`。
+* **max**：取多个值中的最大值，例如 `max(1, 2, 3)` 返回 `3`。
+* **sum**：求和，例如 `sum(1, 2, 3)` 返回 `6`。
+* **avg**：求算术平均值，例如 `avg(1, 2, 3)` 返回 `2`。
+* **sqrt**：计算平方根，例如 `sqrt(9)` 返回 `3`。
+* **ceil**：上取整，例如 `ceil(9.1)` 返回 `10`。
+* **floor**：下取整，例如 `floor(9.9)` 返回 `9`。
+* **round**：四舍五入，例如 `round(9.9)` 返回 `10`， `round(9.1)` 返回 `9`。
+* **log**：计算自然对数，例如 `log(10)` 返回 `2.302585`。
+* **log10**：计算以10为底的对数，例如 `log10(10)` 返回 `1`。
+* **abs**：计算绝对值，例如 `abs(-1)` 返回 `1`。
+* **if**：如果第一个参数为 `true`，返回第二个参数，否则返回第三个参数，例如 `if(true, 10, 100)` 返回 `10`， `if(false, 10, 100)` 返回 `100`。
+
+## 规则管理
+
+* 添加或修改
+
+    * API地址：http://\<server\>:\<port\>/api/update-rule
+    * Method：POST
+    * Body：规则定义
+    * 示例：curl -d '@rule.json' http://localhost:8100/api/update-rule
+
+* 删除
+
+    * API地址：http://\<server\>:\<port\>/api/delete-rule?name=\<rule name\>
+    * Method：DELETE
+    * 示例：curl -X DELETE http://localhost:8100/api/delete-rule?name=rule1
+
+* 挂起或恢复
+
+    * API地址：http://\<server\>:\<port\>/api/enable-rule?name=\<rule name\>&enable=[true | false]
+    * Method：POST
+    * 示例：curl -X POST http://localhost:8100/api/enable-rule?name=rule1&enable=true
+
+* 获取列表
+
+    * API地址：http://\<server\>:\<port\>/api/list-rule
+    * Method：GET
+    * 示例：curl http://localhost:8100/api/list-rule

alert/app/app.go

+package app
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/taosdata/alert/models"
+	"github.com/taosdata/alert/utils"
+	"github.com/taosdata/alert/utils/log"
+)
+
+func Init() error {
+	if e := initRule(); e != nil {
+		return e
+	}
+
+	http.HandleFunc("/api/list-rule", onListRule)
+	http.HandleFunc("/api/list-alert", onListAlert)
+	http.HandleFunc("/api/update-rule", onUpdateRule)
+	http.HandleFunc("/api/enable-rule", onEnableRule)
+	http.HandleFunc("/api/delete-rule", onDeleteRule)
+
+	return nil
+}
+
+func Uninit() error {
+	uninitRule()
+	return nil
+}
+
+func onListRule(w http.ResponseWriter, r *http.Request) {
+	var res []*Rule
+	rules.Range(func(k, v interface{}) bool {
+		res = append(res, v.(*Rule))
+		return true
+	})
+
+	w.Header().Add("Content-Type", "application/json; charset=utf-8")
+	json.NewEncoder(w).Encode(res)
+}
+
+func onListAlert(w http.ResponseWriter, r *http.Request) {
+	var alerts []*Alert
+	rn := r.URL.Query().Get("rule")
+	rules.Range(func(k, v interface{}) bool {
+		if len(rn) > 0 && rn != k.(string) {
+			return true
+		}
+
+		rule := v.(*Rule)
+		rule.Alerts.Range(func(k, v interface{}) bool {
+			alert := v.(*Alert)
+			// TODO: not go-routine safe
+			if alert.State != AlertStateWaiting {
+				alerts = append(alerts, v.(*Alert))
+			}
+			return true
+		})
+		return true
+	})
+	w.Header().Add("Content-Type", "application/json; charset=utf-8")
+	json.NewEncoder(w).Encode(alerts)
+}
+
+func onUpdateRule(w http.ResponseWriter, r *http.Request) {
+	data, e := ioutil.ReadAll(r.Body)
+	if e != nil {
+		log.Error("failed to read request body: ", e.Error())
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	rule, e := newRule(string(data))
+	if e != nil {
+		log.Error("failed to parse rule: ", e.Error())
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	if e = doUpdateRule(rule, string(data)); e != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+	}
+}
+
+func doUpdateRule(rule *Rule, ruleStr string) error {
+	if _, ok := rules.Load(rule.Name); ok {
+		if len(utils.Cfg.Database) > 0 {
+			e := models.UpdateRule(rule.Name, ruleStr)
+			if e != nil {
+				log.Errorf("[%s]: update failed: %s", rule.Name, e.Error())
+				return e
+			}
+		}
+		log.Infof("[%s]: update succeeded.", rule.Name)
+	} else {
+		if len(utils.Cfg.Database) > 0 {
+			e := models.AddRule(&models.Rule{
+				Name:    rule.Name,
+				Content: ruleStr,
+			})
+			if e != nil {
+				log.Errorf("[%s]: add failed: %s", rule.Name, e.Error())
+				return e
+			}
+		}
+		log.Infof("[%s]: add succeeded.", rule.Name)
+	}
+
+	rules.Store(rule.Name, rule)
+	return nil
+}
+
+func onEnableRule(w http.ResponseWriter, r *http.Request) {
+	var rule *Rule
+	name := r.URL.Query().Get("name")
+	enable := strings.ToLower(r.URL.Query().Get("enable")) == "true"
+
+	if x, ok := rules.Load(name); ok {
+		rule = x.(*Rule)
+	} else {
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	if rule.isEnabled() == enable {
+		return
+	}
+
+	if len(utils.Cfg.Database) > 0 {
+		if e := models.EnableRule(name, enable); e != nil {
+			if enable {
+				log.Errorf("[%s]: enable failed: ", name, e.Error())
+			} else {
+				log.Errorf("[%s]: disable failed: ", name, e.Error())
+			}
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	}
+
+	if enable {
+		rule = rule.clone()
+		rule.setNextRunTime(time.Now())
+		rules.Store(rule.Name, rule)
+		log.Infof("[%s]: enable succeeded.", name)
+	} else {
+		rule.setState(RuleStateDisabled)
+		log.Infof("[%s]: disable succeeded.", name)
+	}
+}
+
+func onDeleteRule(w http.ResponseWriter, r *http.Request) {
+	name := r.URL.Query().Get("name")
+	if len(name) == 0 {
+		return
+	}
+	if e := doDeleteRule(name); e != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+	}
+}
+
+func doDeleteRule(name string) error {
+	if len(utils.Cfg.Database) > 0 {
+		if e := models.DeleteRule(name); e != nil {
+			log.Errorf("[%s]: delete failed: %s", name, e.Error())
+			return e
+		}
+	}
+	rules.Delete(name)
+	log.Infof("[%s]: delete succeeded.", name)
+	return nil
+}

alert/app/expr/expr.go

+package expr
+
+import (
+	"errors"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+var (
+	// compile errors
+	ErrorExpressionSyntax     = errors.New("expression syntax error")
+	ErrorUnrecognizedFunction = errors.New("unrecognized function")
+	ErrorArgumentCount        = errors.New("too many/few arguments")
+	ErrorInvalidFloat         = errors.New("invalid float")
+	ErrorInvalidInteger       = errors.New("invalid integer")
+
+	// eval errors
+	ErrorUnsupportedDataType     = errors.New("unsupported data type")
+	ErrorInvalidOperationFloat   = errors.New("invalid operation for float")
+	ErrorInvalidOperationInteger = errors.New("invalid operation for integer")
+	ErrorInvalidOperationBoolean = errors.New("invalid operation for boolean")
+	ErrorOnlyIntegerAllowed      = errors.New("only integers is allowed")
+	ErrorDataTypeMismatch        = errors.New("data type mismatch")
+)
+
+// binary operator precedence
+//    5             *   /   %  <<  >>  &
+//    4             +   -   |  ^
+//    3             ==  !=  <  <=  >   >=
+//    2             &&
+//    1             ||
+const (
+	opOr         = -(iota + 1000) // ||
+	opAnd                         // &&
+	opEqual                       // ==
+	opNotEqual                    // !=
+	opGTE                         // >=
+	opLTE                         // <=
+	opLeftShift                   // <<
+	opRightShift                  // >>
+)
+
+type lexer struct {
+	scan scanner.Scanner
+	tok  rune
+}
+
+func (l *lexer) init(src io.Reader) {
+	l.scan.Error = func(s *scanner.Scanner, msg string) {
+		panic(errors.New(msg))
+	}
+	l.scan.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats | scanner.ScanStrings
+	l.scan.Init(src)
+	l.tok = l.next()
+}
+
+func (l *lexer) next() rune {
+	l.tok = l.scan.Scan()
+
+	switch l.tok {
+	case '|':
+		if l.scan.Peek() == '|' {
+			l.tok = opOr
+			l.scan.Scan()
+		}
+
+	case '&':
+		if l.scan.Peek() == '&' {
+			l.tok = opAnd
+			l.scan.Scan()
+		}
+
+	case '=':
+		if l.scan.Peek() == '=' {
+			l.tok = opEqual
+			l.scan.Scan()
+		} else {
+			// TODO: error
+		}
+
+	case '!':
+		if l.scan.Peek() == '=' {
+			l.tok = opNotEqual
+			l.scan.Scan()
+		} else {
+			// TODO: error
+		}
+
+	case '<':
+		if tok := l.scan.Peek(); tok == '<' {
+			l.tok = opLeftShift
+			l.scan.Scan()
+		} else if tok == '=' {
+			l.tok = opLTE
+			l.scan.Scan()
+		}
+
+	case '>':
+		if tok := l.scan.Peek(); tok == '>' {
+			l.tok = opRightShift
+			l.scan.Scan()
+		} else if tok == '=' {
+			l.tok = opGTE
+			l.scan.Scan()
+		}
+	}
+	return l.tok
+}
+
+func (l *lexer) token() rune {
+	return l.tok
+}
+
+func (l *lexer) text() string {
+	switch l.tok {
+	case opOr:
+		return "||"
+	case opAnd:
+		return "&&"
+	case opEqual:
+		return "=="
+	case opNotEqual:
+		return "!="
+	case opLeftShift:
+		return "<<"
+	case opLTE:
+		return "<="
+	case opRightShift:
+		return ">>"
+	case opGTE:
+		return ">="
+	default:
+		return l.scan.TokenText()
+	}
+}
+
+type Expr interface {
+	Eval(env func(string) interface{}) interface{}
+}
+
+type unaryExpr struct {
+	op      rune
+	subExpr Expr
+}
+
+func (ue *unaryExpr) Eval(env func(string) interface{}) interface{} {
+	val := ue.subExpr.Eval(env)
+	switch v := val.(type) {
+	case float64:
+		if ue.op != '-' {
+			panic(ErrorInvalidOperationFloat)
+		}
+		return -v
+	case int64:
+		switch ue.op {
+		case '-':
+			return -v
+		case '~':
+			return ^v
+		default:
+			panic(ErrorInvalidOperationInteger)
+		}
+	case bool:
+		if ue.op != '!' {
+			panic(ErrorInvalidOperationBoolean)
+		}
+		return !v
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+type binaryExpr struct {
+	op  rune
+	lhs Expr
+	rhs Expr
+}
+
+func (be *binaryExpr) Eval(env func(string) interface{}) interface{} {
+	lval := be.lhs.Eval(env)
+	rval := be.rhs.Eval(env)
+
+	switch be.op {
+	case '*':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv * rv
+			case int64:
+				return lv * float64(rv)
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) * rv
+			case int64:
+				return lv * rv
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case '/':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				if rv == 0 {
+					return math.Inf(int(lv))
+				} else {
+					return lv / rv
+				}
+			case int64:
+				if rv == 0 {
+					return math.Inf(int(lv))
+				} else {
+					return lv / float64(rv)
+				}
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				if rv == 0 {
+					return math.Inf(int(lv))
+				} else {
+					return float64(lv) / rv
+				}
+			case int64:
+				if rv == 0 {
+					return math.Inf(int(lv))
+				} else {
+					return lv / rv
+				}
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case '%':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return math.Mod(lv, rv)
+			case int64:
+				return math.Mod(lv, float64(rv))
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return math.Mod(float64(lv), rv)
+			case int64:
+				if rv == 0 {
+					return math.Inf(int(lv))
+				} else {
+					return lv % rv
+				}
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case opLeftShift:
+		switch lv := lval.(type) {
+		case int64:
+			switch rv := rval.(type) {
+			case int64:
+				return lv << rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case opRightShift:
+		switch lv := lval.(type) {
+		case int64:
+			switch rv := rval.(type) {
+			case int64:
+				return lv >> rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case '&':
+		switch lv := lval.(type) {
+		case int64:
+			switch rv := rval.(type) {
+			case int64:
+				return lv & rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case '+':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv + rv
+			case int64:
+				return lv + float64(rv)
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) + rv
+			case int64:
+				return lv + rv
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case '-':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv - rv
+			case int64:
+				return lv - float64(rv)
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) - rv
+			case int64:
+				return lv - rv
+			case bool:
+				panic(ErrorInvalidOperationBoolean)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case '|':
+		switch lv := lval.(type) {
+		case int64:
+			switch rv := rval.(type) {
+			case int64:
+				return lv | rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case '^':
+		switch lv := lval.(type) {
+		case int64:
+			switch rv := rval.(type) {
+			case int64:
+				return lv ^ rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case opEqual:
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv == rv
+			case int64:
+				return lv == float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) == rv
+			case int64:
+				return lv == rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			switch rv := rval.(type) {
+			case float64:
+			case int64:
+			case bool:
+				return lv == rv
+			}
+		}
+
+	case opNotEqual:
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv != rv
+			case int64:
+				return lv != float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) != rv
+			case int64:
+				return lv != rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			switch rv := rval.(type) {
+			case float64:
+			case int64:
+			case bool:
+				return lv != rv
+			}
+		}
+
+	case '<':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv < rv
+			case int64:
+				return lv < float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) < rv
+			case int64:
+				return lv < rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case opLTE:
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv <= rv
+			case int64:
+				return lv <= float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) <= rv
+			case int64:
+				return lv <= rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case '>':
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv > rv
+			case int64:
+				return lv > float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) > rv
+			case int64:
+				return lv > rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case opGTE:
+		switch lv := lval.(type) {
+		case float64:
+			switch rv := rval.(type) {
+			case float64:
+				return lv >= rv
+			case int64:
+				return lv >= float64(rv)
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case int64:
+			switch rv := rval.(type) {
+			case float64:
+				return float64(lv) >= rv
+			case int64:
+				return lv >= rv
+			case bool:
+				panic(ErrorDataTypeMismatch)
+			}
+		case bool:
+			panic(ErrorInvalidOperationBoolean)
+		}
+
+	case opAnd:
+		switch lv := lval.(type) {
+		case bool:
+			switch rv := rval.(type) {
+			case bool:
+				return lv && rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+
+	case opOr:
+		switch lv := lval.(type) {
+		case bool:
+			switch rv := rval.(type) {
+			case bool:
+				return lv || rv
+			default:
+				panic(ErrorOnlyIntegerAllowed)
+			}
+		default:
+			panic(ErrorOnlyIntegerAllowed)
+		}
+	}
+
+	return nil
+}
+
+type funcExpr struct {
+	name string
+	args []Expr
+}
+
+func (fe *funcExpr) Eval(env func(string) interface{}) interface{} {
+	argv := make([]interface{}, 0, len(fe.args))
+	for _, arg := range fe.args {
+		argv = append(argv, arg.Eval(env))
+	}
+	return funcs[fe.name].call(argv)
+}
+
+type floatExpr struct {
+	val float64
+}
+
+func (fe *floatExpr) Eval(env func(string) interface{}) interface{} {
+	return fe.val
+}
+
+type intExpr struct {
+	val int64
+}
+
+func (ie *intExpr) Eval(env func(string) interface{}) interface{} {
+	return ie.val
+}
+
+type boolExpr struct {
+	val bool
+}
+
+func (be *boolExpr) Eval(env func(string) interface{}) interface{} {
+	return be.val
+}
+
+type stringExpr struct {
+	val string
+}
+
+func (se *stringExpr) Eval(env func(string) interface{}) interface{} {
+	return se.val
+}
+
+type varExpr struct {
+	name string
+}
+
+func (ve *varExpr) Eval(env func(string) interface{}) interface{} {
+	return env(ve.name)
+}
+
+func Compile(src string) (expr Expr, err error) {
+	defer func() {
+		switch x := recover().(type) {
+		case nil:
+		case error:
+			err = x
+		default:
+		}
+	}()
+
+	lexer := lexer{}
+	lexer.init(strings.NewReader(src))
+	expr = parseBinary(&lexer, 0)
+	if lexer.token() != scanner.EOF {
+		panic(ErrorExpressionSyntax)
+	}
+	return expr, nil
+}
+
+func precedence(op rune) int {
+	switch op {
+	case opOr:
+		return 1
+	case opAnd:
+		return 2
+	case opEqual, opNotEqual, '<', '>', opGTE, opLTE:
+		return 3
+	case '+', '-', '|', '^':
+		return 4
+	case '*', '/', '%', opLeftShift, opRightShift, '&':
+		return 5
+	}
+	return 0
+}
+
+// binary = unary ('+' binary)*
+func parseBinary(lexer *lexer, lastPrec int) Expr {
+	lhs := parseUnary(lexer)
+
+	for {
+		op := lexer.token()
+		prec := precedence(op)
+		if prec <= lastPrec {
+			break
+		}
+		lexer.next() // consume operator
+		rhs := parseBinary(lexer, prec)
+		lhs = &binaryExpr{op: op, lhs: lhs, rhs: rhs}
+	}
+
+	return lhs
+}
+
+// unary = '+|-' expr | primary
+func parseUnary(lexer *lexer) Expr {
+	flag := false
+	for tok := lexer.token(); ; tok = lexer.next() {
+		if tok == '-' {
+			flag = !flag
+		} else if tok != '+' {
+			break
+		}
+	}
+	if flag {
+		return &unaryExpr{op: '-', subExpr: parsePrimary(lexer)}
+	}
+
+	flag = false
+	for tok := lexer.token(); tok == '!'; tok = lexer.next() {
+		flag = !flag
+	}
+	if flag {
+		return &unaryExpr{op: '!', subExpr: parsePrimary(lexer)}
+	}
+
+	flag = false
+	for tok := lexer.token(); tok == '~'; tok = lexer.next() {
+		flag = !flag
+	}
+	if flag {
+		return &unaryExpr{op: '~', subExpr: parsePrimary(lexer)}
+	}
+
+	return parsePrimary(lexer)
+}
+
+// primary = id
+//         | id '(' expr ',' ... ',' expr ')'
+//         | num
+//         | '(' expr ')'
+func parsePrimary(lexer *lexer) Expr {
+	switch lexer.token() {
+	case '+', '-', '!', '~':
+		return parseUnary(lexer)
+
+	case '(':
+		lexer.next() // consume '('
+		node := parseBinary(lexer, 0)
+		if lexer.token() != ')' {
+			panic(ErrorExpressionSyntax)
+		}
+		lexer.next() // consume ')'
+		return node
+
+	case scanner.Ident:
+		id := strings.ToLower(lexer.text())
+		if lexer.next() != '(' {
+			if id == "true" {
+				return &boolExpr{val: true}
+			} else if id == "false" {
+				return &boolExpr{val: false}
+			} else {
+				return &varExpr{name: id}
+			}
+		}
+		node := funcExpr{name: id}
+		for lexer.next() != ')' {
+			arg := parseBinary(lexer, 0)
+			node.args = append(node.args, arg)
+			if lexer.token() != ',' {
+				break
+			}
+		}
+		if lexer.token() != ')' {
+			panic(ErrorExpressionSyntax)
+		}
+
+		if fn, ok := funcs[id]; !ok {
+			panic(ErrorUnrecognizedFunction)
+		} else if fn.minArgs >= 0 && len(node.args) < fn.minArgs {
+			panic(ErrorArgumentCount)
+		} else if fn.maxArgs >= 0 && len(node.args) > fn.maxArgs {
+			panic(ErrorArgumentCount)
+		}
+
+		lexer.next() // consume it
+		return &node
+
+	case scanner.Int:
+		val, e := strconv.ParseInt(lexer.text(), 0, 64)
+		if e != nil {
+			panic(ErrorInvalidFloat)
+		}
+		lexer.next()
+		return &intExpr{val: val}
+
+	case scanner.Float:
+		val, e := strconv.ParseFloat(lexer.text(), 0)
+		if e != nil {
+			panic(ErrorInvalidInteger)
+		}
+		lexer.next()
+		return &floatExpr{val: val}
+
+	case scanner.String:
+		panic(errors.New("strings are not allowed in expression at present"))
+		val := lexer.text()
+		lexer.next()
+		return &stringExpr{val: val}
+
+	default:
+		panic(ErrorExpressionSyntax)
+	}
+}

alert/app/expr/expr_test.go

+package expr
+
+import "testing"
+
+func TestIntArithmetic(t *testing.T) {
+	cases := []struct {
+		expr     string
+		expected int64
+	}{
+		{"+10", 10},
+		{"-10", -10},
+		{"3 + 4 + 5 + 6 * 7 + 8", 62},
+		{"3 + 4 + (5 + 6) * 7 + 8", 92},
+		{"3 + 4 + (5 + 6) * 7 / 11 + 8", 22},
+		{"3 + 4 + -5 * 6 / 7 % 8", 3},
+		{"10 - 5", 5},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(nil); res.(int64) != c.expected {
+			t.Errorf("result for expression '%s' is %v, but expected is %v", c.expr, res, c.expected)
+		}
+	}
+}
+
+func TestFloatArithmetic(t *testing.T) {
+	cases := []struct {
+		expr     string
+		expected float64
+	}{
+		{"+10.5", 10.5},
+		{"-10.5", -10.5},
+		{"3.1 + 4.2 + 5 + 6 * 7 + 8", 62.3},
+		{"3.1 + 4.2 + (5 + 6) * 7 + 8.3", 92.6},
+		{"3.1 + 4.2 + (5.1 + 5.9) * 7 / 11 + 8", 22.3},
+		{"3.3 + 4.2 - 4.0 * 7.5 / 3", -2.5},
+		{"3.3 + 4.2 - 4 * 7.0 / 2", -6.5},
+		{"3.5/2.0", 1.75},
+		{"3.5/2", 1.75},
+		{"7 / 3.5", 2},
+		{"3.5 % 2.0", 1.5},
+		{"3.5 % 2", 1.5},
+		{"7 % 2.5", 2},
+		{"7.3 - 2", 5.3},
+		{"7 - 2.3", 4.7},
+		{"1 + 1.5", 2.5},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(nil); res.(float64) != c.expected {
+			t.Errorf("result for expression '%s' is %v, but expected is %v", c.expr, res, c.expected)
+		}
+	}
+}
+
+func TestVariable(t *testing.T) {
+	variables := map[string]interface{}{
+		"a": int64(6),
+		"b": int64(7),
+	}
+	env := func(key string) interface{} {
+		return variables[key]
+	}
+
+	cases := []struct {
+		expr     string
+		expected int64
+	}{
+		{"3 + 4 + (+5) + a * b + 8", 62},
+		{"3 + 4 + (5 + a) * b + 8", 92},
+		{"3 + 4 + (5 + a) * b / 11 + 8", 22},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(env); res.(int64) != c.expected {
+			t.Errorf("result for expression '%s' is %v, but expected is %v", c.expr, res, c.expected)
+		}
+	}
+}
+
+func TestFunction(t *testing.T) {
+	variables := map[string]interface{}{
+		"a": int64(6),
+		"b": 7.0,
+	}
+
+	env := func(key string) interface{} {
+		return variables[key]
+	}
+
+	cases := []struct {
+		expr     string
+		expected float64
+	}{
+		{"sum(3, 4,  5, a * b, 8)", 62},
+		{"sum(3, 4, (5 + a) * b, 8)", 92},
+		{"sum(3, 4, (5 + a) * b / 11, 8)", 22},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(env); res.(float64) != c.expected {
+			t.Errorf("result for expression '%s' is %v, but expected is %v", c.expr, res, c.expected)
+		}
+	}
+}
+
+func TestLogical(t *testing.T) {
+	cases := []struct {
+		expr     string
+		expected bool
+	}{
+		{"true", true},
+		{"false", false},
+		{"true == true", true},
+		{"true == false", false},
+		{"true != true", false},
+		{"true != false", true},
+		{"5 > 3", true},
+		{"5 < 3", false},
+		{"5.2 > 3", true},
+		{"5.2 < 3", false},
+		{"5 > 3.1", true},
+		{"5 < 3.1", false},
+		{"5.1 > 3.3", true},
+		{"5.1 < 3.3", false},
+		{"5 >= 3", true},
+		{"5 <= 3", false},
+		{"5.2 >= 3", true},
+		{"5.2 <= 3", false},
+		{"5 >= 3.1", true},
+		{"5 <= 3.1", false},
+		{"5.1 >= 3.3", true},
+		{"5.1 <= 3.3", false},
+		{"5 != 3", true},
+		{"5.2 != 3.2", true},
+		{"5.2 != 3", true},
+		{"5 != 3.2", true},
+		{"5 == 3", false},
+		{"5.2 == 3.2", false},
+		{"5.2 == 3", false},
+		{"5 == 3.2", false},
+		{"!(5 > 3)", false},
+		{"5>3 && 3>1", true},
+		{"5<3 || 3<1", false},
+		{"4<=4 || 3<1", true},
+		{"4<4 || 3>=1", true},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(nil); res.(bool) != c.expected {
+			t.Errorf("result for expression '%s' is %v, but expected is %v", c.expr, res, c.expected)
+		}
+	}
+}
+
+func TestBitwise(t *testing.T) {
+	cases := []struct {
+		expr     string
+		expected int64
+	}{
+		{"0x0C & 0x04", 0x04},
+		{"0x08 | 0x04", 0x0C},
+		{"0x0C ^ 0x04", 0x08},
+		{"0x01 << 2", 0x04},
+		{"0x04 >> 2", 0x01},
+		{"~0x04", ^0x04},
+	}
+
+	for _, c := range cases {
+		expr, e := Compile(c.expr)
+		if e != nil {
+			t.Errorf("failed to compile expression '%s': %s", c.expr, e.Error())
+		}
+		if res := expr.Eval(nil); res.(int64) != c.expected {
+			t.Errorf("result for expression '%s' is 0x%X, but expected is 0x%X", c.expr, res, c.expected)
+		}
+	}
+}

alert/app/expr/funcs.go

+package expr
+
+import (
+	"math"
+)
+
+type builtInFunc struct {
+	minArgs, maxArgs int
+	call             func([]interface{}) interface{}
+}
+
+func fnMin(args []interface{}) interface{} {
+	res := args[0]
+	for _, arg := range args[1:] {
+		switch v1 := res.(type) {
+		case int64:
+			switch v2 := arg.(type) {
+			case int64:
+				if v2 < v1 {
+					res = v2
+				}
+			case float64:
+				res = math.Min(float64(v1), v2)
+			default:
+				panic(ErrorUnsupportedDataType)
+			}
+		case float64:
+			switch v2 := arg.(type) {
+			case int64:
+				res = math.Min(v1, float64(v2))
+			case float64:
+				res = math.Min(v1, v2)
+			default:
+				panic(ErrorUnsupportedDataType)
+			}
+		default:
+			panic(ErrorUnsupportedDataType)
+		}
+	}
+	return res
+}
+
+func fnMax(args []interface{}) interface{} {
+	res := args[0]
+	for _, arg := range args[1:] {
+		switch v1 := res.(type) {
+		case int64:
+			switch v2 := arg.(type) {
+			case int64:
+				if v2 > v1 {
+					res = v2
+				}
+			case float64:
+				res = math.Max(float64(v1), v2)
+			default:
+				panic(ErrorUnsupportedDataType)
+			}
+		case float64:
+			switch v2 := arg.(type) {
+			case int64:
+				res = math.Max(v1, float64(v2))
+			case float64:
+				res = math.Max(v1, v2)
+			default:
+				panic(ErrorUnsupportedDataType)
+			}
+		default:
+			panic(ErrorUnsupportedDataType)
+		}
+	}
+	return res
+}
+
+func fnSum(args []interface{}) interface{} {
+	res := float64(0)
+	for _, arg := range args {
+		switch v := arg.(type) {
+		case int64:
+			res += float64(v)
+		case float64:
+			res += v
+		default:
+			panic(ErrorUnsupportedDataType)
+		}
+	}
+	return res
+}
+
+func fnAvg(args []interface{}) interface{} {
+	return fnSum(args).(float64) / float64(len(args))
+}
+
+func fnSqrt(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return math.Sqrt(float64(v))
+	case float64:
+		return math.Sqrt(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnFloor(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return v
+	case float64:
+		return math.Floor(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnCeil(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return v
+	case float64:
+		return math.Ceil(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnRound(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return v
+	case float64:
+		return math.Round(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnLog(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return math.Log(float64(v))
+	case float64:
+		return math.Log(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnLog10(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		return math.Log10(float64(v))
+	case float64:
+		return math.Log10(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnAbs(args []interface{}) interface{} {
+	switch v := args[0].(type) {
+	case int64:
+		if v < 0 {
+			return -v
+		}
+		return v
+	case float64:
+		return math.Abs(v)
+	default:
+		panic(ErrorUnsupportedDataType)
+	}
+}
+
+func fnIf(args []interface{}) interface{} {
+	v, ok := args[0].(bool)
+	if !ok {
+		panic(ErrorUnsupportedDataType)
+	}
+	if v {
+		return args[1]
+	} else {
+		return args[2]
+	}
+}
+
+var funcs = map[string]builtInFunc{
+	"min":   builtInFunc{minArgs: 1, maxArgs: -1, call: fnMin},
+	"max":   builtInFunc{minArgs: 1, maxArgs: -1, call: fnMax},
+	"sum":   builtInFunc{minArgs: 1, maxArgs: -1, call: fnSum},
+	"avg":   builtInFunc{minArgs: 1, maxArgs: -1, call: fnAvg},
+	"sqrt":  builtInFunc{minArgs: 1, maxArgs: 1, call: fnSqrt},
+	"ceil":  builtInFunc{minArgs: 1, maxArgs: 1, call: fnCeil},
+	"floor": builtInFunc{minArgs: 1, maxArgs: 1, call: fnFloor},
+	"round": builtInFunc{minArgs: 1, maxArgs: 1, call: fnRound},
+	"log":   builtInFunc{minArgs: 1, maxArgs: 1, call: fnLog},
+	"log10": builtInFunc{minArgs: 1, maxArgs: 1, call: fnLog10},
+	"abs":   builtInFunc{minArgs: 1, maxArgs: 1, call: fnAbs},
+	"if":    builtInFunc{minArgs: 3, maxArgs: 3, call: fnIf},
+}

alert/app/expr/funcs_test.go

+package expr
+
+import (
+	"math"
+	"testing"
+)
+
+func TestMax(t *testing.T) {
+	cases := []struct {
+		args     []interface{}
+		expected float64
+	}{
+		{[]interface{}{int64(1), int64(2), int64(3), int64(4), int64(5)}, 5},
+		{[]interface{}{int64(1), int64(2), float64(3), int64(4), float64(5)}, 5},
+		{[]interface{}{int64(-1), int64(-2), float64(-3), int64(-4), float64(-5)}, -1},
+		{[]interface{}{int64(-1), int64(-1), float64(-1), int64(-1), float64(-1)}, -1},
+		{[]interface{}{int64(-1), int64(0), float64(-1), int64(-1), float64(-1)}, 0},
+	}
+
+	for _, c := range cases {
+		r := fnMax(c.args)
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("max(%v) = %v, want %v", c.args, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("max(%v) = %v, want %v", c.args, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type max(%v)", c.args)
+		}
+	}
+}
+
+func TestMin(t *testing.T) {
+	cases := []struct {
+		args     []interface{}
+		expected float64
+	}{
+		{[]interface{}{int64(1), int64(2), int64(3), int64(4), int64(5)}, 1},
+		{[]interface{}{int64(5), int64(4), float64(3), int64(2), float64(1)}, 1},
+		{[]interface{}{int64(-1), int64(-2), float64(-3), int64(-4), float64(-5)}, -5},
+		{[]interface{}{int64(-1), int64(-1), float64(-1), int64(-1), float64(-1)}, -1},
+		{[]interface{}{int64(1), int64(0), float64(1), int64(1), float64(1)}, 0},
+	}
+
+	for _, c := range cases {
+		r := fnMin(c.args)
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("min(%v) = %v, want %v", c.args, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("min(%v) = %v, want %v", c.args, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type min(%v)", c.args)
+		}
+	}
+}
+
+func TestSumAvg(t *testing.T) {
+	cases := []struct {
+		args     []interface{}
+		expected float64
+	}{
+		{[]interface{}{int64(1)}, 1},
+		{[]interface{}{int64(1), int64(2), int64(3), int64(4), int64(5)}, 15},
+		{[]interface{}{int64(5), int64(4), float64(3), int64(2), float64(1)}, 15},
+		{[]interface{}{int64(-1), int64(-2), float64(-3), int64(-4), float64(-5)}, -15},
+		{[]interface{}{int64(-1), int64(-1), float64(-1), int64(-1), float64(-1)}, -5},
+		{[]interface{}{int64(1), int64(0), float64(1), int64(1), float64(1)}, 4},
+	}
+
+	for _, c := range cases {
+		r := fnSum(c.args)
+		switch v := r.(type) {
+		case float64:
+			if v != c.expected {
+				t.Errorf("sum(%v) = %v, want %v", c.args, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type sum(%v)", c.args)
+		}
+	}
+
+	for _, c := range cases {
+		r := fnAvg(c.args)
+		expected := c.expected / float64(len(c.args))
+		switch v := r.(type) {
+		case float64:
+			if v != expected {
+				t.Errorf("avg(%v) = %v, want %v", c.args, v, expected)
+			}
+		default:
+			t.Errorf("unknown result type avg(%v)", c.args)
+		}
+	}
+}
+
+func TestSqrt(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(0), 0},
+		{int64(1), 1},
+		{int64(256), 16},
+		{10.0, math.Sqrt(10)},
+		{10000.0, math.Sqrt(10000)},
+	}
+
+	for _, c := range cases {
+		r := fnSqrt([]interface{}{c.arg})
+		switch v := r.(type) {
+		case float64:
+			if v != c.expected {
+				t.Errorf("sqrt(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type sqrt(%v)", c.arg)
+		}
+	}
+}
+
+func TestFloor(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(0), 0},
+		{int64(1), 1},
+		{int64(-1), -1},
+		{10.4, 10},
+		{-10.4, -11},
+		{10.8, 10},
+		{-10.8, -11},
+	}
+
+	for _, c := range cases {
+		r := fnFloor([]interface{}{c.arg})
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("floor(%v) = %v, want %v", c.arg, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("floor(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type floor(%v)", c.arg)
+		}
+	}
+}
+
+func TestCeil(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(0), 0},
+		{int64(1), 1},
+		{int64(-1), -1},
+		{10.4, 11},
+		{-10.4, -10},
+		{10.8, 11},
+		{-10.8, -10},
+	}
+
+	for _, c := range cases {
+		r := fnCeil([]interface{}{c.arg})
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("ceil(%v) = %v, want %v", c.arg, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("ceil(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type ceil(%v)", c.arg)
+		}
+	}
+}
+
+func TestRound(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(0), 0},
+		{int64(1), 1},
+		{int64(-1), -1},
+		{10.4, 10},
+		{-10.4, -10},
+		{10.8, 11},
+		{-10.8, -11},
+	}
+
+	for _, c := range cases {
+		r := fnRound([]interface{}{c.arg})
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("round(%v) = %v, want %v", c.arg, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("round(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type round(%v)", c.arg)
+		}
+	}
+}
+
+func TestLog(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(1), math.Log(1)},
+		{0.1, math.Log(0.1)},
+		{10.4, math.Log(10.4)},
+		{10.8, math.Log(10.8)},
+	}
+
+	for _, c := range cases {
+		r := fnLog([]interface{}{c.arg})
+		switch v := r.(type) {
+		case float64:
+			if v != c.expected {
+				t.Errorf("log(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type log(%v)", c.arg)
+		}
+	}
+}
+
+func TestLog10(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(1), math.Log10(1)},
+		{0.1, math.Log10(0.1)},
+		{10.4, math.Log10(10.4)},
+		{10.8, math.Log10(10.8)},
+		{int64(100), math.Log10(100)},
+	}
+
+	for _, c := range cases {
+		r := fnLog10([]interface{}{c.arg})
+		switch v := r.(type) {
+		case float64:
+			if v != c.expected {
+				t.Errorf("log10(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type log10(%v)", c.arg)
+		}
+	}
+}
+
+func TestAbs(t *testing.T) {
+	cases := []struct {
+		arg      interface{}
+		expected float64
+	}{
+		{int64(1), 1},
+		{int64(0), 0},
+		{int64(-1), 1},
+		{10.4, 10.4},
+		{-10.4, 10.4},
+	}
+
+	for _, c := range cases {
+		r := fnAbs([]interface{}{c.arg})
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("abs(%v) = %v, want %v", c.arg, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("abs(%v) = %v, want %v", c.arg, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type abs(%v)", c.arg)
+		}
+	}
+}
+
+func TestIf(t *testing.T) {
+	cases := []struct {
+		args     []interface{}
+		expected float64
+	}{
+		{[]interface{}{true, int64(10), int64(20)}, 10},
+		{[]interface{}{false, int64(10), int64(20)}, 20},
+		{[]interface{}{true, 10.3, 20.6}, 10.3},
+		{[]interface{}{false, 10.3, 20.6}, 20.6},
+		{[]interface{}{true, int64(10), 20.6}, 10},
+		{[]interface{}{false, int64(10), 20.6}, 20.6},
+	}
+
+	for _, c := range cases {
+		r := fnIf(c.args)
+		switch v := r.(type) {
+		case int64:
+			if v != int64(c.expected) {
+				t.Errorf("if(%v) = %v, want %v", c.args, v, int64(c.expected))
+			}
+		case float64:
+			if v != c.expected {
+				t.Errorf("if(%v) = %v, want %v", c.args, v, c.expected)
+			}
+		default:
+			t.Errorf("unknown result type if(%v)", c.args)
+		}
+	}
+}

alert/app/route.go

+package app
+
+import (
+	"regexp"
+	"strings"
+)
+
+type RouteMatchCriteria struct {
+	Tag   string         `yaml:"tag"`
+	Value string         `yaml:"match"`
+	Re    *regexp.Regexp `yaml:"-"`
+}
+
+func (c *RouteMatchCriteria) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var v map[string]string
+	if e := unmarshal(&v); e != nil {
+		return e
+	}
+
+	for k, a := range v {
+		c.Tag = k
+		c.Value = a
+		if strings.HasPrefix(a, "re:") {
+			re, e := regexp.Compile(a[3:])
+			if e != nil {
+				return e
+			}
+			c.Re = re
+		}
+	}
+
+	return nil
+}
+
+type Route struct {
+	Continue       bool                 `yaml:"continue"`
+	Receiver       string               `yaml:"receiver"`
+	GroupWait      Duration             `yaml:"group_wait"`
+	GroupInterval  Duration             `yaml:"group_interval"`
+	RepeatInterval Duration             `yaml:"repeat_interval"`
+	GroupBy        []string             `yaml:"group_by"`
+	Match          []RouteMatchCriteria `yaml:"match"`
+	Routes         []*Route             `yaml:"routes"`
+}

alert/app/rule.go

+package app
+
+import (
+	"bytes"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"text/scanner"
+	"text/template"
+	"time"
+
+	"github.com/taosdata/alert/app/expr"
+	"github.com/taosdata/alert/models"
+	"github.com/taosdata/alert/utils"
+	"github.com/taosdata/alert/utils/log"
+)
+
+type Duration struct{ time.Duration }
+
+func (d Duration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+func (d *Duration) doUnmarshal(v interface{}) error {
+	switch value := v.(type) {
+	case float64:
+		*d = Duration{time.Duration(value)}
+		return nil
+	case string:
+		if duration, e := time.ParseDuration(value); e != nil {
+			return e
+		} else {
+			*d = Duration{duration}
+		}
+		return nil
+	default:
+		return errors.New("invalid duration")
+	}
+}
+
+func (d *Duration) UnmarshalJSON(b []byte) error {
+	var v interface{}
+	if e := json.Unmarshal(b, &v); e != nil {
+		return e
+	}
+	return d.doUnmarshal(v)
+}
+
+const (
+	AlertStateWaiting = iota
+	AlertStatePending
+	AlertStateFiring
+)
+
+type Alert struct {
+	State         uint8                  `json:"-"`
+	LastRefreshAt time.Time              `json:"-"`
+	StartsAt      time.Time              `json:"startsAt,omitempty"`
+	EndsAt        time.Time              `json:"endsAt,omitempty"`
+	Values        map[string]interface{} `json:"values"`
+	Labels        map[string]string      `json:"labels"`
+	Annotations   map[string]string      `json:"annotations"`
+}
+
+func (alert *Alert) doRefresh(firing bool, rule *Rule) bool {
+	switch {
+	case (!firing) && (alert.State == AlertStateWaiting):
+		return false
+
+	case (!firing) && (alert.State == AlertStatePending):
+		alert.State = AlertStateWaiting
+		return false
+
+	case (!firing) && (alert.State == AlertStateFiring):
+		alert.State = AlertStateWaiting
+		alert.EndsAt = time.Now()
+
+	case firing && (alert.State == AlertStateWaiting):
+		alert.StartsAt = time.Now()
+		if rule.For.Nanoseconds() > 0 {
+			alert.State = AlertStatePending
+			return false
+		}
+		alert.State = AlertStateFiring
+
+	case firing && (alert.State == AlertStatePending):
+		if time.Now().Sub(alert.StartsAt) < rule.For.Duration {
+			return false
+		}
+		alert.StartsAt = alert.StartsAt.Add(rule.For.Duration)
+		alert.State = AlertStateFiring
+
+	case firing && (alert.State == AlertStateFiring):
+	}
+
+	return true
+}
+
+func (alert *Alert) refresh(rule *Rule, values map[string]interface{}) {
+	alert.LastRefreshAt = time.Now()
+
+	defer func() {
+		switch x := recover().(type) {
+		case nil:
+		case error:
+			rule.setState(RuleStateError)
+			log.Errorf("[%s]: failed to evaluate: %s", rule.Name, x.Error())
+		default:
+			rule.setState(RuleStateError)
+			log.Errorf("[%s]: failed to evaluate: unknown error", rule.Name)
+		}
+	}()
+
+	alert.Values = values
+	res := rule.Expr.Eval(func(key string) interface{} {
+		// ToLower is required as column name in result is in lower case
+		return alert.Values[strings.ToLower(key)]
+	})
+
+	val, ok := res.(bool)
+	if !ok {
+		rule.setState(RuleStateError)
+		log.Errorf("[%s]: result type is not bool", rule.Name)
+		return
+	}
+
+	if !alert.doRefresh(val, rule) {
+		return
+	}
+
+	buf := bytes.Buffer{}
+	alert.Annotations = map[string]string{}
+	for k, v := range rule.Annotations {
+		if e := v.Execute(&buf, alert); e != nil {
+			log.Errorf("[%s]: failed to generate annotation '%s': %s", rule.Name, k, e.Error())
+		} else {
+			alert.Annotations[k] = buf.String()
+		}
+		buf.Reset()
+	}
+
+	buf.Reset()
+	if e := json.NewEncoder(&buf).Encode(alert); e != nil {
+		log.Errorf("[%s]: failed to serialize alert to JSON: %s", rule.Name, e.Error())
+	} else {
+		chAlert <- buf.String()
+	}
+}
+
+const (
+	RuleStateNormal = iota
+	RuleStateError
+	RuleStateDisabled
+	RuleStateRunning = 0x04
+)
+
+type Rule struct {
+	Name           string                        `json:"name"`
+	State          uint32                        `json:"state"`
+	SQL            string                        `json:"sql"`
+	GroupByCols    []string                      `json:"-"`
+	For            Duration                      `json:"for"`
+	Period         Duration                      `json:"period"`
+	NextRunTime    time.Time                     `json:"-"`
+	RawExpr        string                        `json:"expr"`
+	Expr           expr.Expr                     `json:"-"`
+	Labels         map[string]string             `json:"labels"`
+	RawAnnotations map[string]string             `json:"annotations"`
+	Annotations    map[string]*template.Template `json:"-"`
+	Alerts         sync.Map                      `json:"-"`
+}
+
+func (rule *Rule) clone() *Rule {
+	return &Rule{
+		Name:           rule.Name,
+		State:          RuleStateNormal,
+		SQL:            rule.SQL,
+		GroupByCols:    rule.GroupByCols,
+		For:            rule.For,
+		Period:         rule.Period,
+		NextRunTime:    time.Time{},
+		RawExpr:        rule.RawExpr,
+		Expr:           rule.Expr,
+		Labels:         rule.Labels,
+		RawAnnotations: rule.RawAnnotations,
+		Annotations:    rule.Annotations,
+		// don't copy alerts
+	}
+}
+
+func (rule *Rule) setState(s uint32) {
+	for {
+		old := atomic.LoadUint32(&rule.State)
+		new := old&0xffffffc0 | s
+		if atomic.CompareAndSwapUint32(&rule.State, old, new) {
+			break
+		}
+	}
+}
+
+func (rule *Rule) state() uint32 {
+	return atomic.LoadUint32(&rule.State) & 0xffffffc0
+}
+
+func (rule *Rule) isEnabled() bool {
+	state := atomic.LoadUint32(&rule.State)
+	return state&RuleStateDisabled == 0
+}
+
+func (rule *Rule) setNextRunTime(tm time.Time) {
+	rule.NextRunTime = tm.Round(rule.Period.Duration)
+	if rule.NextRunTime.Before(tm) {
+		rule.NextRunTime = rule.NextRunTime.Add(rule.Period.Duration)
+	}
+}
+
+func parseGroupBy(sql string) (cols []string, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			err = e.(error)
+		}
+	}()
+
+	s := scanner.Scanner{
+		Error: func(s *scanner.Scanner, msg string) {
+			panic(errors.New(msg))
+		},
+		Mode: scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats,
+	}
+
+	s.Init(strings.NewReader(sql))
+	if s.Scan() != scanner.Ident || strings.ToLower(s.TokenText()) != "select" {
+		err = errors.New("only select statement is allowed.")
+		return
+	}
+
+	hasGroupBy := false
+	for t := s.Scan(); t != scanner.EOF; t = s.Scan() {
+		if t != scanner.Ident {
+			continue
+		}
+		if strings.ToLower(s.TokenText()) != "group" {
+			continue
+		}
+		if s.Scan() != scanner.Ident {
+			continue
+		}
+		if strings.ToLower(s.TokenText()) == "by" {
+			hasGroupBy = true
+			break
+		}
+	}
+
+	if !hasGroupBy {
+		return
+	}
+
+	for {
+		if s.Scan() != scanner.Ident {
+			err = errors.New("SQL statement syntax error.")
+			return
+		}
+		col := strings.ToLower(s.TokenText())
+		cols = append(cols, col)
+		if s.Scan() != ',' {
+			break
+		}
+	}
+
+	return
+}
+
+func (rule *Rule) parseGroupBy() (err error) {
+	cols, e := parseGroupBy(rule.SQL)
+	if e == nil {
+		rule.GroupByCols = cols
+	}
+	return nil
+}
+
+func (rule *Rule) getAlert(values map[string]interface{}) *Alert {
+	sb := strings.Builder{}
+	for _, name := range rule.GroupByCols {
+		value := values[name]
+		if value == nil {
+		} else {
+			sb.WriteString(fmt.Sprint(value))
+		}
+		sb.WriteByte('_')
+	}
+
+	var alert *Alert
+	key := sb.String()
+
+	if v, ok := rule.Alerts.Load(key); ok {
+		alert = v.(*Alert)
+	}
+	if alert == nil {
+		alert = &Alert{Labels: map[string]string{}}
+		for k, v := range rule.Labels {
+			alert.Labels[k] = v
+		}
+		for _, name := range rule.GroupByCols {
+			value := values[name]
+			if value == nil {
+				alert.Labels[name] = ""
+			} else {
+				alert.Labels[name] = fmt.Sprint(value)
+			}
+		}
+		rule.Alerts.Store(key, alert)
+	}
+
+	return alert
+}
+
+func (rule *Rule) preRun(tm time.Time) bool {
+	if tm.Before(rule.NextRunTime) {
+		return false
+	}
+	rule.setNextRunTime(tm)
+
+	for {
+		state := atomic.LoadUint32(&rule.State)
+		if state != RuleStateNormal {
+			return false
+		}
+		if atomic.CompareAndSwapUint32(&rule.State, state, RuleStateRunning) {
+			break
+		}
+	}
+	return true
+}
+
+func (rule *Rule) run(db *sql.DB) {
+	rows, e := db.Query(rule.SQL)
+	if e != nil {
+		log.Errorf("[%s]: failed to query TDengine: %s", rule.Name, e.Error())
+		return
+	}
+
+	cols, e := rows.ColumnTypes()
+	if e != nil {
+		log.Errorf("[%s]: unable to get column information: %s", rule.Name, e.Error())
+		return
+	}
+
+	for rows.Next() {
+		values := make([]interface{}, 0, len(cols))
+		for range cols {
+			var v interface{}
+			values = append(values, &v)
+		}
+		rows.Scan(values...)
+
+		m := make(map[string]interface{})
+		for i, col := range cols {
+			name := strings.ToLower(col.Name())
+			m[name] = *(values[i].(*interface{}))
+		}
+
+		alert := rule.getAlert(m)
+		alert.refresh(rule, m)
+	}
+
+	now := time.Now()
+	rule.Alerts.Range(func(k, v interface{}) bool {
+		alert := v.(*Alert)
+		if now.Sub(alert.LastRefreshAt) > rule.Period.Duration*10 {
+			rule.Alerts.Delete(k)
+		}
+		return true
+	})
+}
+
+func (rule *Rule) postRun() {
+	for {
+		old := atomic.LoadUint32(&rule.State)
+		new := old & ^uint32(RuleStateRunning)
+		if atomic.CompareAndSwapUint32(&rule.State, old, new) {
+			break
+		}
+	}
+}
+
+func newRule(str string) (*Rule, error) {
+	rule := Rule{}
+
+	e := json.NewDecoder(strings.NewReader(str)).Decode(&rule)
+	if e != nil {
+		return nil, e
+	}
+
+	if rule.Period.Nanoseconds() <= 0 {
+		rule.Period = Duration{time.Minute}
+	}
+	rule.setNextRunTime(time.Now())
+
+	if rule.For.Nanoseconds() < 0 {
+		rule.For = Duration{0}
+	}
+
+	if e = rule.parseGroupBy(); e != nil {
+		return nil, e
+	}
+
+	if expr, e := expr.Compile(rule.RawExpr); e != nil {
+		return nil, e
+	} else {
+		rule.Expr = expr
+	}
+
+	rule.Annotations = map[string]*template.Template{}
+	for k, v := range rule.RawAnnotations {
+		v = reValue.ReplaceAllStringFunc(v, func(s string) string {
+			// as column name in query result is always in lower case,
+			// we need to convert value reference in annotations to
+			// lower case
+			return strings.ToLower(s)
+		})
+		text := "{{$labels := .Labels}}{{$values := .Values}}" + v
+		tmpl, e := template.New(k).Parse(text)
+		if e != nil {
+			return nil, e
+		}
+		rule.Annotations[k] = tmpl
+	}
+
+	return &rule, nil
+}
+
+const (
+	batchSize = 1024
+)
+
+var (
+	rules   sync.Map
+	wg      sync.WaitGroup
+	chStop  = make(chan struct{})
+	chAlert = make(chan string, batchSize)
+	reValue = regexp.MustCompile(`\$values\.[_a-zA-Z0-9]+`)
+)
+
+func runRules() {
+	defer wg.Done()
+
+	db, e := sql.Open("taosSql", utils.Cfg.TDengine)
+	if e != nil {
+		log.Fatal("failed to connect to TDengine: ", e.Error())
+	}
+	defer db.Close()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+
+LOOP:
+	for {
+		var tm time.Time
+		select {
+		case <-chStop:
+			close(chAlert)
+			break LOOP
+		case tm = <-ticker.C:
+		}
+
+		rules.Range(func(k, v interface{}) bool {
+			rule := v.(*Rule)
+			if !rule.preRun(tm) {
+				return true
+			}
+
+			wg.Add(1)
+			go func(rule *Rule) {
+				defer wg.Done()
+				defer rule.postRun()
+				rule.run(db)
+			}(rule)
+
+			return true
+		})
+	}
+}
+
+func doPushAlerts(alerts []string) {
+	defer wg.Done()
+
+	if len(utils.Cfg.Receivers.AlertManager) == 0 {
+		return
+	}
+
+	buf := bytes.Buffer{}
+	buf.WriteByte('[')
+	for i, alert := range alerts {
+		if i > 0 {
+			buf.WriteByte(',')
+		}
+		buf.WriteString(alert)
+	}
+	buf.WriteByte(']')
+
+	log.Debug(buf.String())
+
+	resp, e := http.DefaultClient.Post(utils.Cfg.Receivers.AlertManager, "application/json", &buf)
+	if e != nil {
+		log.Errorf("failed to push alerts to downstream: %s", e.Error())
+		return
+	}
+	resp.Body.Close()
+}
+
+func pushAlerts() {
+	defer wg.Done()
+
+	ticker := time.NewTicker(time.Millisecond * 100)
+	defer ticker.Stop()
+
+	alerts := make([]string, 0, batchSize)
+
+LOOP:
+	for {
+		select {
+		case alert := <-chAlert:
+			if utils.Cfg.Receivers.Console {
+				fmt.Print(alert)
+			}
+			if len(alert) == 0 {
+				if len(alerts) > 0 {
+					wg.Add(1)
+					doPushAlerts(alerts)
+				}
+				break LOOP
+			}
+			if len(alerts) == batchSize {
+				wg.Add(1)
+				go doPushAlerts(alerts)
+				alerts = make([]string, 0, batchSize)
+			}
+			alerts = append(alerts, alert)
+
+		case <-ticker.C:
+			if len(alerts) > 0 {
+				wg.Add(1)
+				go doPushAlerts(alerts)
+				alerts = make([]string, 0, batchSize)
+			}
+		}
+	}
+}
+
+func loadRuleFromDatabase() error {
+	allRules, e := models.LoadAllRule()
+	if e != nil {
+		log.Error("failed to load rules from database:", e.Error())
+		return e
+	}
+
+	count := 0
+	for _, r := range allRules {
+		rule, e := newRule(r.Content)
+		if e != nil {
+			log.Errorf("[%s]: parse failed: %s", r.Name, e.Error())
+			continue
+		}
+		if !r.Enabled {
+			rule.setState(RuleStateDisabled)
+		}
+		rules.Store(rule.Name, rule)
+		count++
+	}
+	log.Infof("total %d rules loaded", count)
+	return nil
+}
+
+func loadRuleFromFile() error {
+	f, e := os.Open(utils.Cfg.RuleFile)
+	if e != nil {
+		log.Error("failed to load rules from file:", e.Error())
+		return e
+	}
+	defer f.Close()
+
+	var allRules []Rule
+	e = json.NewDecoder(f).Decode(&allRules)
+	if e != nil {
+		log.Error("failed to parse rule file:", e.Error())
+		return e
+	}
+
+	for i := 0; i < len(allRules); i++ {
+		rule := &allRules[i]
+		rules.Store(rule.Name, rule)
+	}
+	log.Infof("total %d rules loaded", len(allRules))
+
+	return nil
+}
+
+func initRule() error {
+	if len(utils.Cfg.Database) > 0 {
+		if e := loadRuleFromDatabase(); e != nil {
+			return e
+		}
+	} else {
+		if e := loadRuleFromFile(); e != nil {
+			return e
+		}
+	}
+
+	wg.Add(2)
+	go runRules()
+	go pushAlerts()
+
+	return nil
+}
+
+func uninitRule() error {
+	close(chStop)
+	wg.Wait()
+	return nil
+}

alert/app/rule_test.go

+package app
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/taosdata/alert/utils/log"
+)
+
+func TestParseGroupBy(t *testing.T) {
+	cases := []struct {
+		sql  string
+		cols []string
+	}{
+		{
+			sql:  "select * from a",
+			cols: []string{},
+		},
+		{
+			sql:  "select * from a group by abc",
+			cols: []string{"abc"},
+		},
+		{
+			sql:  "select * from a group by abc, def",
+			cols: []string{"abc", "def"},
+		},
+		{
+			sql:  "select * from a Group by abc, def order by abc",
+			cols: []string{"abc", "def"},
+		},
+	}
+
+	for _, c := range cases {
+		cols, e := parseGroupBy(c.sql)
+		if e != nil {
+			t.Errorf("failed to parse sql '%s': %s", c.sql, e.Error())
+		}
+		for i := range cols {
+			if i >= len(c.cols) {
+				t.Errorf("count of group by columns of '%s' is wrong", c.sql)
+			}
+			if c.cols[i] != cols[i] {
+				t.Errorf("wrong group by columns for '%s'", c.sql)
+			}
+		}
+	}
+}
+
+func TestManagement(t *testing.T) {
+	const format = `{"name":"rule%d", "sql":"select count(*) as count from meters", "expr":"count>2"}`
+
+	log.Init()
+
+	for i := 0; i < 5; i++ {
+		s := fmt.Sprintf(format, i)
+		rule, e := newRule(s)
+		if e != nil {
+			t.Errorf("failed to create rule: %s", e.Error())
+		}
+		e = doUpdateRule(rule, s)
+		if e != nil {
+			t.Errorf("failed to add or update rule: %s", e.Error())
+		}
+	}
+
+	for i := 0; i < 5; i++ {
+		name := fmt.Sprintf("rule%d", i)
+		if _, ok := rules.Load(name); !ok {
+			t.Errorf("rule '%s' does not exist", name)
+		}
+	}
+
+	name := "rule1"
+	if e := doDeleteRule(name); e != nil {
+		t.Errorf("failed to delete rule: %s", e.Error())
+	}
+
+	if _, ok := rules.Load(name); ok {
+		t.Errorf("rule '%s' should not exist any more", name)
+	}
+}

alert/cmd/alert/alert.cfg

+{
+	"port": 8100,
+	"database": "file:alert.db",
+	"tdengine": "root:taosdata@/tcp(127.0.0.1:0)/",
+	"log": {
+		"level": "debug",
+		"path": ""
+	},
+	"receivers": {
+		"alertManager": "http://127.0.0.1:9093/api/v1/alerts",
+		"console": true
+	}
+}

alert/cmd/alert/install_driver.sh

+#!/bin/bash
+#
+# This file is used to install TDengine client library on linux systems.
+
+set -e
+#set -x
+
+# -----------------------Variables definition---------------------
+script_dir=$(dirname $(readlink -f "$0"))
+# Dynamic directory
+lib_link_dir="/usr/lib"
+
+#install main path
+install_main_dir="/usr/local/taos"
+
+# Color setting
+RED='\033[0;31m'
+GREEN='\033[1;32m'
+GREEN_DARK='\033[0;32m'
+GREEN_UNDERLINE='\033[4;32m'
+NC='\033[0m'
+
+csudo=""
+if command -v sudo > /dev/null; then
+    csudo="sudo"
+fi
+
+function clean_driver() {
+    ${csudo} rm -f /usr/lib/libtaos.so || :
+}
+
+function install_driver() {
+    echo -e "${GREEN}Start to install TDengine client driver ...${NC}"
+    
+    #create install main dir and all sub dir
+    ${csudo} mkdir -p ${install_main_dir}  
+    ${csudo} mkdir -p ${install_main_dir}/driver
+
+    ${csudo} rm -f ${lib_link_dir}/libtaos.*         || :
+    ${csudo} cp -rf ${script_dir}/driver/* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*  
+    ${csudo} ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1
+    ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
+ 
+    echo
+    echo -e "\033[44;32;1mTDengine client driver is successfully installed!${NC}"
+}
+
+install_driver

alert/cmd/alert/main.go

+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/taosdata/alert/app"
+	"github.com/taosdata/alert/models"
+	"github.com/taosdata/alert/utils"
+	"github.com/taosdata/alert/utils/log"
+
+	_ "github.com/mattn/go-sqlite3"
+	_ "github.com/taosdata/driver-go/taosSql"
+)
+
+type httpHandler struct {
+}
+
+func (h *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	start := time.Now()
+	path := r.URL.Path
+	http.DefaultServeMux.ServeHTTP(w, r)
+	duration := time.Now().Sub(start)
+	log.Debugf("[%s]\t%s\t%s", r.Method, path, duration)
+}
+
+func serveWeb() *http.Server {
+	log.Info("Listening at port: ", utils.Cfg.Port)
+
+	srv := &http.Server{
+		Addr:    ":" + strconv.Itoa(int(utils.Cfg.Port)),
+		Handler: &httpHandler{},
+	}
+	go func() {
+		if e := srv.ListenAndServe(); e != nil {
+			log.Error(e.Error())
+		}
+	}()
+
+	return srv
+}
+
+func copyFile(dst, src string) error {
+	if dst == src {
+		return nil
+	}
+
+	in, e := os.Open(src)
+	if e != nil {
+		return e
+	}
+	defer in.Close()
+
+	out, e := os.Create(dst)
+	if e != nil {
+		return e
+	}
+	defer out.Close()
+
+	_, e = io.Copy(out, in)
+	return e
+}
+
+func doSetup(cfgPath string) error {
+	exePath, e := os.Executable()
+	if e != nil {
+		fmt.Fprintf(os.Stderr, "failed to get executable path: %s\n", e.Error())
+		return e
+	}
+
+	if !filepath.IsAbs(cfgPath) {
+		dir := filepath.Dir(exePath)
+		cfgPath = filepath.Join(dir, cfgPath)
+	}
+
+	e = copyFile("/etc/taos/alert.cfg", cfgPath)
+	if e != nil {
+		fmt.Fprintf(os.Stderr, "failed copy configuration file: %s\n", e.Error())
+		return e
+	}
+
+	f, e := os.Create("/etc/systemd/system/alert.service")
+	if e != nil {
+		fmt.Printf("failed to create alert service: %s\n", e.Error())
+		return e
+	}
+	defer f.Close()
+
+	const content = `[Unit]
+Description=Alert (TDengine Alert Service)
+After=syslog.target
+After=network.target
+
+[Service]
+RestartSec=2s
+Type=simple
+WorkingDirectory=/var/lib/taos/
+ExecStart=%s -cfg /etc/taos/alert.cfg
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+`
+	_, e = fmt.Fprintf(f, content, exePath)
+	if e != nil {
+		fmt.Printf("failed to create alert.service: %s\n", e.Error())
+		return e
+	}
+
+	return nil
+}
+
+const version = "TDengine alert v1.0.0"
+
+func main() {
+	var (
+		cfgPath     string
+		setup       bool
+		showVersion bool
+	)
+	flag.StringVar(&cfgPath, "cfg", "alert.cfg", "path of configuration file")
+	flag.BoolVar(&setup, "setup", false, "setup the service as a daemon")
+	flag.BoolVar(&showVersion, "version", false, "show version information")
+	flag.Parse()
+
+	if showVersion {
+		fmt.Println(version)
+		return
+	}
+
+	if setup {
+		if runtime.GOOS == "linux" {
+			doSetup(cfgPath)
+		} else {
+			fmt.Fprintln(os.Stderr, "can only run as a daemon mode in linux.")
+		}
+		return
+	}
+
+	if e := utils.LoadConfig(cfgPath); e != nil {
+		fmt.Fprintln(os.Stderr, "failed to load configuration")
+		return
+	}
+
+	if e := log.Init(); e != nil {
+		fmt.Fprintln(os.Stderr, "failed to initialize logger:", e.Error())
+		return
+	}
+	defer log.Sync()
+
+	if e := models.Init(); e != nil {
+		log.Fatal("failed to initialize database:", e.Error())
+	}
+
+	if e := app.Init(); e != nil {
+		log.Fatal("failed to initialize application:", e.Error())
+	}
+	// start web server
+	srv := serveWeb()
+
+	// wait `Ctrl-C` or `Kill` to exit, `Kill` does not work on Windows
+	interrupt := make(chan os.Signal)
+	signal.Notify(interrupt, os.Interrupt)
+	signal.Notify(interrupt, os.Kill)
+	<-interrupt
+	fmt.Println("'Ctrl + C' received, exiting...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	srv.Shutdown(ctx)
+	cancel()
+
+	app.Uninit()
+	models.Uninit()
+}

alert/cmd/alert/rule.json

+{
+    "name": "CarTooFast",
+    "period": "10s",
+    "sql": "select avg(speed) as avgspeed from test.cars where ts > now - 5m group by id",
+    "expr": "avgSpeed > 100",
+    "for": "0s",
+    "labels": {
+        "ruleName": "CarTooFast"
+    },
+    "annotations": {
+        "summary": "car {{$values.id}} is too fast, its average speed is {{$values.avgSpeed}}km/h"
+    }
+}
\ No newline at end of file

alert/go.mod

+module github.com/taosdata/alert
+
+go 1.14
+
+require (
+	github.com/jmoiron/sqlx v1.2.0
+	github.com/mattn/go-sqlite3 v2.0.3+incompatible
+	github.com/taosdata/driver-go master
+	go.uber.org/zap v1.14.1
+	google.golang.org/appengine v1.6.5 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
+)

alert/models/models.go

+package models
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/taosdata/alert/utils"
+	"github.com/taosdata/alert/utils/log"
+)
+
+var db *sqlx.DB
+
+func Init() error {
+	xdb, e := sqlx.Connect("sqlite3", utils.Cfg.Database)
+	if e == nil {
+		db = xdb
+	}
+	return upgrade()
+}
+
+func Uninit() error {
+	db.Close()
+	return nil
+}
+
+func getStringOption(tx *sqlx.Tx, name string) (string, error) {
+	const qs = "SELECT * FROM `option` WHERE `name`=?"
+
+	var (
+		e error
+		o struct {
+			Name  string `db:"name"`
+			Value string `db:"value"`
+		}
+	)
+
+	if tx != nil {
+		e = tx.Get(&o, qs, name)
+	} else {
+		e = db.Get(&o, qs, name)
+	}
+
+	if e != nil {
+		return "", e
+	}
+
+	return o.Value, nil
+}
+
+func getIntOption(tx *sqlx.Tx, name string) (int, error) {
+	s, e := getStringOption(tx, name)
+	if e != nil {
+		return 0, e
+	}
+	v, e := strconv.ParseInt(s, 10, 64)
+	return int(v), e
+}
+
+func setOption(tx *sqlx.Tx, name string, value interface{}) error {
+	const qs = "REPLACE INTO `option`(`name`, `value`) VALUES(?, ?);"
+
+	var (
+		e  error
+		sv string
+	)
+
+	switch v := value.(type) {
+	case time.Time:
+		sv = v.Format(time.RFC3339)
+	default:
+		sv = fmt.Sprint(value)
+	}
+
+	if tx != nil {
+		_, e = tx.Exec(qs, name, sv)
+	} else {
+		_, e = db.Exec(qs, name, sv)
+	}
+
+	return e
+}
+
+var upgradeScripts = []struct {
+	ver   int
+	stmts []string
+}{
+	{
+		ver: 0,
+		stmts: []string{
+			"CREATE TABLE `option`( `name` VARCHAR(63) PRIMARY KEY, `value` VARCHAR(255) NOT NULL) WITHOUT ROWID;",
+			"CREATE TABLE `rule`( `name` VARCHAR(63) PRIMARY KEY, `enabled` TINYINT(1) NOT NULL, `created_at` DATETIME NOT NULL, `updated_at` DATETIME NOT NULL, `content` TEXT(65535) NOT NULL);",
+		},
+	},
+}
+
+func upgrade() error {
+	const dbVersion = "database version"
+
+	ver, e := getIntOption(nil, dbVersion)
+	if e != nil { // regards all errors as schema not created
+		ver = -1 // set ver to -1 to execute all statements
+	}
+
+	tx, e := db.Beginx()
+	if e != nil {
+		return e
+	}
+
+	for _, us := range upgradeScripts {
+		if us.ver <= ver {
+			continue
+		}
+		log.Info("upgrading database to version: ", us.ver)
+		for _, s := range us.stmts {
+			if _, e = tx.Exec(s); e != nil {
+				tx.Rollback()
+				return e
+			}
+		}
+		ver = us.ver
+	}
+
+	if e = setOption(tx, dbVersion, ver); e != nil {
+		tx.Rollback()
+		return e
+	}
+
+	return tx.Commit()
+}

alert/models/rule.go

+package models
+
+import "time"
+
+const (
+	sqlSelectAllRule = "SELECT * FROM `rule`;"
+	sqlSelectRule    = "SELECT * FROM `rule` WHERE `name` = ?;"
+	sqlInsertRule    = "INSERT INTO `rule`(`name`, `enabled`, `created_at`, `updated_at`, `content`) VALUES(:name, :enabled, :created_at, :updated_at, :content);"
+	sqlUpdateRule    = "UPDATE `rule` SET `content` = :content, `updated_at` = :updated_at WHERE `name` = :name;"
+	sqlEnableRule    = "UPDATE `rule` SET `enabled` = :enabled, `updated_at` = :updated_at WHERE `name` = :name;"
+	sqlDeleteRule    = "DELETE FROM `rule` WHERE `name` = ?;"
+)
+
+type Rule struct {
+	Name      string    `db:"name"`
+	Enabled   bool      `db:"enabled"`
+	CreatedAt time.Time `db:"created_at"`
+	UpdatedAt time.Time `db:"updated_at"`
+	Content   string    `db:"content"`
+}
+
+func AddRule(r *Rule) error {
+	r.CreatedAt = time.Now()
+	r.Enabled = true
+	r.UpdatedAt = r.CreatedAt
+	_, e := db.NamedExec(sqlInsertRule, r)
+	return e
+}
+
+func UpdateRule(name string, content string) error {
+	r := Rule{
+		Name:      name,
+		UpdatedAt: time.Now(),
+		Content:   content,
+	}
+	_, e := db.NamedExec(sqlUpdateRule, &r)
+	return e
+}
+
+func EnableRule(name string, enabled bool) error {
+	r := Rule{
+		Name:      name,
+		Enabled:   enabled,
+		UpdatedAt: time.Now(),
+	}
+
+	if res, e := db.NamedExec(sqlEnableRule, &r); e != nil {
+		return e
+	} else if n, e := res.RowsAffected(); n != 1 {
+		return e
+	}
+
+	return nil
+}
+
+func DeleteRule(name string) error {
+	_, e := db.Exec(sqlDeleteRule, name)
+	return e
+}
+
+func GetRuleByName(name string) (*Rule, error) {
+	r := Rule{}
+	if e := db.Get(&r, sqlSelectRule, name); e != nil {
+		return nil, e
+	}
+	return &r, nil
+}
+
+func LoadAllRule() ([]Rule, error) {
+	var rules []Rule
+	if e := db.Select(&rules, sqlSelectAllRule); e != nil {
+		return nil, e
+	}
+	return rules, nil
+}

alert/release.sh

+set -e
+
+# releash.sh  -c [arm | arm64 | x64 | x86] 
+#             -o [linux | darwin | windows]  
+
+# set parameters by default value
+cpuType=x64    # [arm | arm64 | x64 | x86]
+osType=linux   # [linux | darwin | windows]
+
+while getopts "h:c:o:" arg
+do
+  case $arg in
+    c)
+      #echo "cpuType=$OPTARG"
+      cpuType=$(echo $OPTARG)
+      ;;
+    o)
+      #echo "osType=$OPTARG"
+      osType=$(echo $OPTARG)
+      ;;
+    h)
+      echo "Usage: `basename $0` -c [arm | arm64 | x64 | x86] -o [linux | darwin | windows]"
+      exit 0
+      ;;
+    ?) #unknown option 
+      echo "unknown argument"
+      exit 1
+      ;;
+  esac
+done
+
+
+startdir=$(pwd)
+scriptdir=$(dirname $(readlink -f $0))
+cd ${scriptdir}/cmd/alert
+version=$(grep 'const version =' main.go | awk '{print $NF}')
+version=${version%\"}
+
+echo "cpuType=${cpuType}"
+echo "osType=${osType}"
+echo "version=${version}"
+
+GOOS=${osType} GOARCH=${cpuType} go build
+
+GZIP=-9 tar -zcf ${startdir}/tdengine-alert-${version}-${osType}-${cpuType}.tar.gz alert alert.cfg install_driver.sh driver/

alert/test/prepare.sim

+sql connect
+sleep 100
+
+sql drop database if exists test
+sql create database test
+sql use test
+
+print ====== create super table
+sql create table cars (ts timestamp, speed int) tags(id int)
+
+print ====== create tables
+$i = 0
+while $i < 5
+    $tb = car . $i
+    sql create table $tb using cars tags( $i )
+    $i = $i + 1
+endw

alert/test/rule.json

+{
+    "name": "test1",
+    "period": "10s",
+    "sql": "select avg(speed) as avgspeed from test.cars group by id",
+    "expr": "avgSpeed >= 3",
+    "for": "0s",
+    "labels": {
+        "ruleName": "test1"
+    },
+    "annotations": {
+        "summary": "speed of car(id = {{$labels.id}}) is too high: {{$values.avgSpeed}}"
+    }
+}
\ No newline at end of file

alert/test/step1.sim

+sql connect
+sleep 100
+
+print ====== insert 10 records to table 0
+$i = 10
+while $i > 0
+    $ms = $i . s
+    sql insert into test.car0 values(now - $ms , 1)
+    $i = $i - 1
+endw

alert/test/step2.sim

+sql connect
+sleep 100
+
+print ====== insert another records table 0
+sql insert into test.car0 values(now , 100)

alert/test/step3.sim

+sql connect
+sleep 100
+
+print ====== insert 10 records to table 0, 1, 2
+$i = 10
+while $i > 0
+    $ms = $i . s
+    sql insert into test.car0 values(now - $ms , 1)
+    sql insert into test.car1 values(now - $ms , $i )
+    sql insert into test.car2 values(now - $ms , 10)
+    $i = $i - 1
+endw

alert/test/test.sh

+# wait until $1 alerts are generates, and at most wait $2 seconds
+# return 0 if wait succeeded, 1 if wait timeout
+function waitAlert() {
+  local i=0
+
+  while [ $i -lt $2 ]; do
+    local c=$(wc -l alert.out | awk '{print $1}')
+
+    if [ $c -ge $1 ]; then
+      return 0
+    fi
+
+    let "i=$i+1"
+    sleep 1s
+  done
+
+  return 1
+}
+
+# prepare environment
+kill -INT `ps aux | grep 'alert -cfg' | grep -v grep | awk '{print $2}'`
+
+rm -f alert.db
+rm -f alert.out
+../cmd/alert/alert -cfg ../cmd/alert/alert.cfg > alert.out &
+
+../../td/debug/build/bin/tsim -c /etc/taos -f ./prepare.sim
+
+# add a rule to alert application
+curl -d '@rule.json' http://localhost:8100/api/update-rule
+
+# step 1: add some data but not trigger an alert
+../../td/debug/build/bin/tsim -c /etc/taos -f ./step1.sim
+
+# wait 20 seconds, should not get an alert
+waitAlert 1 20
+res=$?
+if [ $res -eq 0 ]; then
+  echo 'should not have alerts here'
+  exit 1
+fi
+
+# step 2: trigger an alert
+../../td/debug/build/bin/tsim -c /etc/taos -f ./step2.sim
+
+# wait 30 seconds for the alert
+waitAlert 1 30 
+res=$?
+if [ $res -eq 1 ]; then
+  echo 'there should be an alert now'
+  exit 1
+fi
+
+# compare whether the generate alert meet expectation
+diff <(uniq alert.out | sed -n 1p | jq -cS 'del(.startsAt, .endsAt)') <(jq -cSn '{"values":{"avgspeed":10,"id":0},"labels":{"id":"0","ruleName":"test1"},"annotations":{"summary":"speed of car(id = 0) is too high: 10"}}')
+if [ $? -ne 0 ]; then
+  echo 'the generated alert does not meet expectation'
+  exit 1
+fi
+
+# step 3: add more data, trigger another 3 alerts
+../../td/debug/build/bin/tsim -c /etc/taos -f ./step3.sim
+
+# wait 30 seconds for the alerts
+waitAlert 4 30 
+res=$?
+if [ $res -eq 1 ]; then
+  echo 'there should be 4 alerts now'
+  exit 1
+fi
+
+# compare whether the generate alert meet expectation
+diff <(uniq alert.out | sed -n 2p | jq -cS 'del(.startsAt, .endsAt)') <(jq -cSn '{"annotations":{"summary":"speed of car(id = 0) is too high: 5.714285714285714"},"labels":{"id":"0","ruleName":"test1"},"values":{"avgspeed":5.714285714285714,"id":0}}')
+if [ $? -ne 0 ]; then
+  echo 'the generated alert does not meet expectation'
+  exit 1
+fi
+
+diff <(uniq alert.out | sed -n 3p | jq -cS 'del(.startsAt, .endsAt)') <(jq -cSn '{"annotations":{"summary":"speed of car(id = 1) is too high: 5.5"},"labels":{"id":"1","ruleName":"test1"},"values":{"avgspeed":5.5,"id":1}}')
+if [ $? -ne 0 ]; then
+  echo 'the generated alert does not meet expectation'
+  exit 1
+fi
+
+diff <(uniq alert.out | sed -n 4p | jq -cS 'del(.startsAt, .endsAt)') <(jq -cSn '{"annotations":{"summary":"speed of car(id = 2) is too high: 10"},"labels":{"id":"2","ruleName":"test1"},"values":{"avgspeed":10,"id":2}}')
+if [ $? -ne 0 ]; then
+  echo 'the generated alert does not meet expectation'
+  exit 1
+fi
+
+kill -INT `ps aux | grep 'alert -cfg' | grep -v grep | awk '{print $2}'`

alert/utils/config.go

+package utils
+
+import (
+	"encoding/json"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Config struct {
+	Port     uint16 `json:"port,omitempty" yaml:"port,omitempty"`
+	Database string `json:"database,omitempty" yaml:"database,omitempty"`
+	RuleFile string `json:"ruleFile,omitempty" yaml:"ruleFile,omitempty"`
+	Log      struct {
+		Level string `json:"level,omitempty" yaml:"level,omitempty"`
+		Path  string `json:"path,omitempty" yaml:"path,omitempty"`
+	} `json:"log" yaml:"log"`
+	TDengine  string `json:"tdengine,omitempty" yaml:"tdengine,omitempty"`
+	Receivers struct {
+		AlertManager string `json:"alertManager,omitempty" yaml:"alertManager,omitempty"`
+		Console      bool   `json:"console"`
+	} `json:"receivers" yaml:"receivers"`
+}
+
+var Cfg Config
+
+func LoadConfig(path string) error {
+	f, e := os.Open(path)
+	if e != nil {
+		return e
+	}
+	defer f.Close()
+
+	e = yaml.NewDecoder(f).Decode(&Cfg)
+	if e != nil {
+		f.Seek(0, 0)
+		e = json.NewDecoder(f).Decode(&Cfg)
+	}
+
+	return e
+}

alert/utils/log/log.go

+package log
+
+import (
+	"github.com/taosdata/alert/utils"
+	"go.uber.org/zap"
+)
+
+var logger *zap.SugaredLogger
+
+func Init() error {
+	var cfg zap.Config
+
+	if utils.Cfg.Log.Level == "debug" {
+		cfg = zap.NewDevelopmentConfig()
+	} else {
+		cfg = zap.NewProductionConfig()
+	}
+
+	if len(utils.Cfg.Log.Path) > 0 {
+		cfg.OutputPaths = []string{utils.Cfg.Log.Path}
+	}
+
+	l, e := cfg.Build()
+	if e != nil {
+		return e
+	}
+
+	logger = l.Sugar()
+	return nil
+}
+
+// Debug package logger
+func Debug(args ...interface{}) {
+	logger.Debug(args...)
+}
+
+// Debugf package logger
+func Debugf(template string, args ...interface{}) {
+	logger.Debugf(template, args...)
+}
+
+// Info package logger
+func Info(args ...interface{}) {
+	logger.Info(args...)
+}
+
+// Infof package logger
+func Infof(template string, args ...interface{}) {
+	logger.Infof(template, args...)
+}
+
+// Warn package logger
+func Warn(args ...interface{}) {
+	logger.Warn(args...)
+}
+
+// Warnf package logger
+func Warnf(template string, args ...interface{}) {
+	logger.Warnf(template, args...)
+}
+
+// Error package logger
+func Error(args ...interface{}) {
+	logger.Error(args...)
+}
+
+// Errorf package logger
+func Errorf(template string, args ...interface{}) {
+	logger.Errorf(template, args...)
+}
+
+// Fatal package logger
+func Fatal(args ...interface{}) {
+	logger.Fatal(args...)
+}
+
+// Fatalf package logger
+func Fatalf(template string, args ...interface{}) {
+	logger.Fatalf(template, args...)
+}
+
+// Panic package logger
+func Panic(args ...interface{}) {
+	logger.Panic(args...)
+}
+
+// Panicf package logger
+func Panicf(template string, args ...interface{}) {
+	logger.Panicf(template, args...)
+}
+
+func Sync() error {
+	return logger.Sync()
+}

documentation20/Connections with other Tools-ch.md

+# 与其他工具的连接
+
+
+## Grafana
+
+TDengine能够与开源数据可视化系统[Grafana](https://www.grafana.com/)快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。
+
+### 安装Grafana
+
+目前TDengine支持Grafana 5.2.4以上的版本。用户可以根据当前的操作系统，到Grafana官网下载安装包，并执行安装。下载地址如下：https://grafana.com/grafana/download。
+
+### 配置Grafana
+
+TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafana目录下。
+
+以CentOS 7.2操作系统为例，将tdengine目录拷贝到/var/lib/grafana/plugins目录下，重新启动grafana即可。
+
+### 使用 Grafana
+
+#### 配置数据源
+
+用户可以直接通过 localhost:3000 的网址，登录 Grafana 服务器(用户名/密码:admin/admin)，通过左侧 `Configuration -> Data Sources` 可以添加数据源，如下图所示：
+
+![img](../assets/add_datasource1.jpg)
+
+点击 `Add data source` 可进入新增数据源页面，在查询框中输入 TDengine 可选择添加，如下图所示：
+
+![img](../assets/add_datasource2.jpg)
+
+进入数据源配置页面，按照默认提示修改相应配置即可：
+
+![img](../assets/add_datasource3.jpg)
+
+* Host： TDengine 集群的中任意一台服务器的 IP 地址与 TDengine RESTful 接口的端口号(6020)，默认 http://localhost:6020。
+* User：TDengine 用户名。
+* Password：TDengine 用户密码。
+
+点击 `Save & Test` 进行测试，成功会有如下提示：
+
+![img](../assets/add_datasource4.jpg)
+
+#### 创建 Dashboard
+
+回到主界面创建 Dashboard，点击 Add Query 进入面板查询页面：
+
+![img](../assets/create_dashboard1.jpg)
+
+如上图所示，在 Query 中选中 `TDengine` 数据源，在下方查询框可输入相应 sql 进行查询，具体说明如下：
+
+* INPUT SQL：输入要查询的语句（该 SQL 语句的结果集应为两列多行），例如：`select avg(mem_system) from log.dn where  ts >= $from and ts < $to interval($interval)` ，其中，from、to 和 interval 为 TDengine插件的内置变量，表示从Grafana插件面板获取的查询范围和时间间隔。除了内置变量外，`也支持可以使用自定义模板变量`。
+* ALIAS BY：可设置当前查询别名。 
+* GENERATE SQL： 点击该按钮会自动替换相应变量，并生成最终执行的语句。
+  
+
+按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：
+
+![img](../assets/create_dashboard2.jpg)
+
+> 关于如何使用Grafana创建相应的监测界面以及更多有关使用Grafana的信息，请参考Grafana官方的[文档](https://grafana.com/docs/)。
+
+#### 导入 Dashboard
+
+在 Grafana 插件目录 /usr/local/taos/connector/grafana/tdengine/dashboard/ 下提供了一个 `tdengine-grafana.json` 可导入的 dashboard。
+
+点击左侧 `Import` 按钮，并上传 `tdengine-grafana.json` 文件：
+
+![img](../assets/import_dashboard1.jpg)
+
+导入完成之后可看到如下效果：
+
+![img](../assets/import_dashboard2.jpg)
+
+
+## Matlab
+
+MatLab可以通过安装包内提供的JDBC Driver直接连接到TDengine获取数据到本地工作空间。
+
+### MatLab的JDBC接口适配
+
+MatLab的适配有下面几个步骤，下面以Windows10上适配MatLab2017a为例：
+
+- 将TDengine安装包内的驱动程序JDBCDriver-1.0.0-dist.jar拷贝到${matlab_root}\MATLAB\R2017a\java\jar\toolbox
+- 将TDengine安装包内的taos.lib文件拷贝至${matlab_ root _dir}\MATLAB\R2017a\lib\win64
+- 将新添加的驱动jar包加入MatLab的classpath。在${matlab_ root _dir}\MATLAB\R2017a\toolbox\local\classpath.txt文件中添加下面一行
+
+​          `$matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar`
+
+- 在${user_home}\AppData\Roaming\MathWorks\MATLAB\R2017a\下添加一个文件javalibrarypath.txt, 并在该文件中添加taos.dll的路径，比如您的taos.dll是在安装时拷贝到了C:\Windows\System32下，那么就应该在javalibrarypath.txt中添加如下一行：
+
+​          `C:\Windows\System32`
+
+### 在MatLab中连接TDengine获取数据
+
+在成功进行了上述配置后，打开MatLab。
+
+- 创建一个连接：
+
+  `conn = database(‘db’, ‘root’, ‘taosdata’, ‘com.taosdata.jdbc.TSDBDriver’, ‘jdbc:TSDB://127.0.0.1:0/’)`
+
+- 执行一次查询：
+
+  `sql0 = [‘select * from tb’]`
+
+  `data = select(conn, sql0);`
+
+- 插入一条记录:
+
+  `sql1 = [‘insert into tb values (now, 1)’]`
+
+  `exec(conn, sql1)`
+
+更多例子细节请参考安装包内examples\Matlab\TDengineDemo.m文件。
+
+## R 
+
+R语言支持通过JDBC接口来连接TDengine数据库。首先需要安装R语言的JDBC包。启动R语言环境，然后执行以下命令安装R语言的JDBC支持库：
+
+```R
+install.packages('RJDBC', repos='http://cran.us.r-project.org')
+```
+
+安装完成以后，通过执行`library('RJDBC')`命令加载 _RJDBC_ 包：
+
+然后加载TDengine的JDBC驱动：
+
+```R
+drv<-JDBC("com.taosdata.jdbc.TSDBDriver","JDBCDriver-2.0.0-dist.jar", identifier.quote="\"")
+```
+如果执行成功，不会出现任何错误信息。之后通过以下命令尝试连接数据库：
+
+```R
+conn<-dbConnect(drv,"jdbc:TSDB://192.168.0.1:0/?user=root&password=taosdata","root","taosdata")
+```
+
+注意将上述命令中的IP地址替换成正确的IP地址。如果没有任务错误的信息，则连接数据库成功，否则需要根据错误提示调整连接的命令。TDengine支持以下的 _RJDBC_ 包中函数：
+
+
+-	dbWriteTable(conn, "test", iris, overwrite=FALSE, append=TRUE)：将数据框iris写入表test中，overwrite必须设置为false，append必须设为TRUE,且数据框iris要与表test的结构一致。
+-	dbGetQuery(conn, "select count(*) from test")：查询语句
+-	dbSendUpdate(conn, "use db")：执行任何非查询sql语句。例如dbSendUpdate(conn, "use db")， 写入数据dbSendUpdate(conn, "insert into t1 values(now, 99)")等。
+-	dbReadTable(conn, "test")：读取表test中数据
+-	dbDisconnect(conn)：关闭连接
+-	dbRemoveTable(conn, "test")：删除表test
+
+TDengine客户端暂不支持如下函数：
+- dbExistsTable(conn, "test")：是否存在表test
+- dbListTables(conn)：显示连接中的所有表
+
+

documentation20/Connections with other Tools.md

+# Connect with other tools
+
+## Telegraf
+
+TDengine is easy to integrate with [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/), an open-source server agent for collecting and sending metrics and events, without more development.
+
+### Install Telegraf
+
+At present, TDengine supports Telegraf newer than version 1.7.4. Users can go to the [download link] and choose the proper package to install on your system.
+
+### Configure Telegraf
+
+Telegraf is configured by changing items in the configuration file */etc/telegraf/telegraf.conf*.
+
+
+In **output plugins** section，add _[[outputs.http]]_ iterm： 
+
+- _url_: http://ip:6020/telegraf/udb, in which _ip_ is the IP address of any node in TDengine cluster. Port 6020 is the RESTful APT port used by TDengine. _udb_ is the name of the database to save data, which needs to create beforehand.
+- _method_: "POST" 
+- _username_: username to login TDengine
+- _password_: password to login TDengine 
+- _data_format_: "json"
+- _json_timestamp_units_: "1ms"
+
+In **agent** part：
+
+- hostname: used to distinguish different machines. Need to be unique.
+- metric_batch_size: 30，the maximum number of records allowed to write in Telegraf. The larger the value is, the less frequent requests are sent. For TDengine, the value should be less than 50.
+
+Please refer to the [Telegraf docs](https://docs.influxdata.com/telegraf/v1.11/) for more information.
+
+## Grafana
+
+[Grafana] is an open-source system for time-series data display. It is easy to integrate TDengine and Grafana to build a monitor system. Data saved in TDengine can be fetched and shown on the Grafana dashboard.
+
+### Install Grafana
+
+For now, TDengine only supports Grafana newer than version 5.2.4. Users can go to the [Grafana download page] for the proper package to download.
+
+### Configure Grafana
+
+TDengine Grafana plugin is in the _/usr/local/taos/connector/grafana_ directory.
+Taking Centos 7.2 as an example, just copy TDengine directory to _/var/lib/grafana/plugins_ directory and restart Grafana.
+
+### Use Grafana
+
+Users can log in the Grafana server (username/password:admin/admin) through localhost:3000 to configure TDengine as the data source. As is shown in the picture below, TDengine as a data source option is shown in the box:
+
+
+![img](../assets/clip_image001.png)
+
+When choosing TDengine as the data source, the Host in HTTP configuration should be configured as the IP address of any node of a TDengine cluster. The port should be set as 6020. For example, when TDengine and Grafana are on the same machine, it should be configured as _http://localhost:6020. 
+
+
+Besides, users also should set the username and password used to log into TDengine. Then click _Save&Test_ button to save.
+
+![img](../assets/clip_image001-2474914.png)
+
+Then, TDengine as a data source should show in the Grafana data source list.
+
+![img](../assets/clip_image001-2474939.png)
+
+
+Then, users can create Dashboards in Grafana using TDengine as the data source:
+
+
+![img](../assets/clip_image001-2474961.png)
+
+ 
+
+Click _Add Query_ button to add a query and input the SQL command you want to run in the _INPUT SQL_ text box. The SQL command should expect a two-row, multi-column result, such as _SELECT count(*) FROM sys.cpu WHERE ts>=from and ts<​to interval(interval)_, in which, _from_, _to_ and _inteval_ are TDengine inner variables representing query time range and time interval.
+
+
+_ALIAS BY_ field is to set the query alias. Click _GENERATE SQL_ to send the command to TDengine:
+
+![img](../assets/clip_image001-2474987.png)
+
+Please refer to the [Grafana official document] for more information about Grafana.
+
+
+## Matlab
+
+Matlab can connect to and retrieve data from TDengine by TDengine JDBC Driver.
+
+### MatLab and TDengine JDBC adaptation
+
+Several steps are required to adapt Matlab to TDengine. Taking adapting Matlab2017a on Windows10 as an example:
+
+1. Copy the file _JDBCDriver-1.0.0-dist.jar_ in TDengine package to the directory _${matlab_root}\MATLAB\R2017a\java\jar\toolbox_
+2. Copy the file _taos.lib_ in TDengine package to _${matlab_ root _dir}\MATLAB\R2017a\lib\win64_
+3. Add the .jar package just copied to the Matlab classpath. Append the line below as the end of the file of _${matlab_ root _dir}\MATLAB\R2017a\toolbox\local\classpath.txt_
+
+​          `$matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar`
+
+4. Create a file called _javalibrarypath.txt_ in directory _${user_home}\AppData\Roaming\MathWorks\MATLAB\R2017a\_, and add the _taos.dll_ path in the file. For example, if the file _taos.dll_ is in the directory of _C:\Windows\System32_，then add the following line in file *javalibrarypath.txt*:
+
+​          `C:\Windows\System32`
+
+### TDengine operations in Matlab
+
+After correct configuration, open Matlab:
+
+- build a connection：
+
+  `conn = database(‘db’, ‘root’, ‘taosdata’, ‘com.taosdata.jdbc.TSDBDriver’, ‘jdbc:TSDB://127.0.0.1:0/’)`
+
+- Query：
+
+  `sql0 = [‘select * from tb’]`
+
+  `data = select(conn, sql0);`
+
+- Insert a record:
+
+  `sql1 = [‘insert into tb values (now, 1)’]`
+
+  `exec(conn, sql1)`
+
+Please refer to the file _examples\Matlab\TDengineDemo.m_ for more information.
+
+## R 
+
+Users can use R language to access the TDengine server with the JDBC interface. At first, install JDBC package in R:
+
+```R
+install.packages('rJDBC', repos='http://cran.us.r-project.org')
+```
+
+Then use _library_ function to load the package:
+
+```R
+library('RJDBC')
+```
+
+Then load the TDengine JDBC driver:
+
+```R
+drv<-JDBC("com.taosdata.jdbc.TSDBDriver","JDBCDriver-1.0.0-dist.jar", identifier.quote="\"")
+```
+If succeed, no error message will display. Then use the following command to try a database connection:
+
+```R
+conn<-dbConnect(drv,"jdbc:TSDB://192.168.0.1:0/?user=root&password=taosdata","root","taosdata")
+```
+
+Please replace the IP address in the command above to the correct one. If no error message is shown, then the connection is established successfully. TDengine supports below functions in _RJDBC_ package:
+
+
+-	_dbWriteTable(conn, "test", iris, overwrite=FALSE, append=TRUE)_: write the data in a data frame _iris_ to the table _test_ in the TDengine server. Parameter _overwrite_ must be _false_. _append_ must be _TRUE_ and the schema of the data frame _iris_ should be the same as the table _test_.
+-	_dbGetQuery(conn, "select count(*) from test")_: run a query command
+-	_dbSendUpdate(conn, "use db")_: run any non-query command.
+-	_dbReadTable(conn, "test"_): read all the data in table _test_
+-	_dbDisconnect(conn)_: close a connection
+-	_dbRemoveTable(conn, "test")_: remove table _test_
+
+Below functions are **not supported** currently:
+- _dbExistsTable(conn, "test")_: if talbe _test_ exists
+- _dbListTables(conn)_: list all tables in the connection
+
+
+[Telegraf]: www.taosdata.com
+[download link]: https://portal.influxdata.com/downloads
+[Telegraf document]: www.taosdata.com
+[Grafana]: https://grafana.com
+[Grafana download page]: https://grafana.com/grafana/download
+[Grafana official document]: https://grafana.com/docs/
+

documentation20/Contributor_License_Agreement.md

+# TaosData Contributor License Agreement
+
+This TaosData Contributor License Agreement (CLA) applies to any contribution you make to any TaosData projects. If you are representing your employing organization to sign this agreement, please warrant that you have the authority to grant the agreement.
+
+## Terms
+
+**"TaosData"**, **"we"**, **"our"** and **"us"** means TaosData, inc.
+
+**"You"** and **"your"** means you or the organization you are on behalf of to sign this agreement.
+
+**"Contribution"** means any original work you, or the organization you represent submit to TaosData for any project in any manner.
+
+## Copyright License
+
+All rights of your Contribution submitted to TaosData in any manner are granted to TaosData and recipients of software distributed by TaosData. You waive any rights that my affect our ownership of the copyright and grant to us a perpetual, worldwide, transferable, non-exclusive, no-charge, royalty-free, irrevocable, and sublicensable license to use, reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Contributions and any derivative work created based on a Contribution.
+
+## Patent License
+
+With respect to any patents you own or that you can license without payment to any third party, you grant to us and to any recipient of software distributed by us, a perpetual, worldwide, transferable, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have make, use, sell, offer to sell, import, and otherwise transfer the Contribution in whole or in part, alone or included in any product under any patent you own, or license from a third party, that is necessarily infringed by the Contribution or by combination of the Contribution with any Work.
+
+## Your Representations and Warranties
+
+You represent and warrant that:
+
+- the Contribution you submit is an original work that you can legally grant the rights set out in this agreement.
+
+- the Contribution you submit and licenses you granted does not and will not, infringe the rights of any third party.
+
+- you are not aware of any pending or threatened claims, suits, actions, or charges pertaining to the contributions. You also warrant to notify TaosData immediately if you become aware of any such actual or potential claims, suits, actions, allegations or charges.
+
+## Support
+
+You are not obligated to support your Contribution except you volunteer to provide support. If you want, you can provide for a fee.
+
+**I agree and accept on behalf of myself and behalf of my organization:**
\ No newline at end of file

documentation20/Documentation-ch.md

+#TDengine文档
+
+TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是[数据模型](data-model-and-architecture)与数据建模一节。除本文档之外，欢迎[下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
+
+##TDengine 介绍
+- TDengine 简介及特色
+- TDengine 适用场景
+- TDengine 性能指标介绍和验证方法
+
+##立即开始
+- 快捷安装：可通过源码、安装包或docker安装，三秒钟搞定
+- 轻松启动：使用systemctl 启停TDengine
+- 命令行程序TAOS：访问TDengine的简便方式 
+- [极速体验](https://www.taosdata.com/cn/getting-started/#TDengine-极速体验)：运行示例程序，快速体验高效的数据插入、查询
+
+##数据模型和整体架构
+- 数据模型：关系型数据库模型，但要求每个采集点单独建表  
+- 集群与基本逻辑单元：吸取NoSQL优点，支持水平扩展，支持高可靠
+- 存储模型与数据分区：标签数据与时序数据完全分离，按vnode和时间两个维度对数据切分
+- 数据写入与复制流程：先写入WAL、之后写入缓存，再给应用确认，支持多副本
+- 缓存与持久化：最新数据缓存在内存中，但落盘时采用列式存储、超高压缩比 
+- 高效查询：支持各种函数、时间轴聚合、插值、多表聚合
+
+##数据建模
+- 创建库：为具有相似数据特征的数据采集点创建一个库
+- 创建超级表：为同一类型的数据采集点创建一个超级表
+- 创建表：使用超级表做模板，为每一个具体的数据采集点单独建表
+
+##高效写入数据
+- SQL写入：使用SQL insert命令向一张或多张表写入单条或多条记录
+- Telegraf 写入：配置Telegraf, 不用任何代码，将采集数据直接写入
+- Prometheus写入：配置Prometheus, 不用任何代码，将数据直接写入
+- EMQ X Broker：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
+
+##高效查询数据
+- 主要查询功能：支持各种标准函数，设置过滤条件，时间段查询
+- 多表聚合查询：使用超级表，设置标签过滤条件，进行高效聚合查询
+- 降采样查询：按时间段分段聚合，支持插值
+
+##高级功能
+- 连续查询(Continuous Query)：基于滑动窗口，定时自动的对数据流进行查询计算
+- 数据订阅(Publisher/Subscriber)：象典型的消息队列，应用可订阅接收到的最新数据
+- [缓存 (Cache)](https://www.taosdata.com/cn/documentation/advanced-features/#缓存-(Cache))：每个设备最新的数据都会缓存在内存中，可快速获取
+- [报警监测(Alarm monitoring)](https://www.taosdata.com/blog/2020/04/14/1438.html/)：根据配置规则，自动监测超限行为数据，并主动推送
+
+##连接器
+- C/C++ Connector：通过libtaos客户端的库，连接TDengine服务器的主要方法
+- Java Connector(JDBC)：通过标准的JDBC API，给Java应用提供到TDengine的连接
+- Python Connector：给Python应用提供一个连接TDengine服务器的驱动 
+- RESTful Connector：提供一最简单的连接TDengine服务器的方式
+- Go Connector：给Go应用提供一个连接TDengine服务器的驱动
+- Node.js Connector：给node应用提供一个链接TDengine服务器的驱动
+
+##与其他工具的连接
+- Grafana：获取并可视化保存在TDengine的数据
+- Matlab：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
+- R：通过配置R的JDBC数据源访问保存在TDengine的数据 
+
+## TDengine集群的安装、管理
+
+- 安装：与单节点的安装一样，但要设好配置文件里的参数first
+- 节点管理：增加、删除、查看集群的节点
+- mnode的管理：系统自动创建、无需任何人工干预
+- 负载均衡：一旦节点个数或负载有变化，自动进行
+- 节点离线处理：节点离线超过一定时长，将从集群中剔除
+- Arbitrator：对于偶数个副本的情形，使用它可以防止split brain。
+
+##TDengine的运营和维护
+
+- 容量规划：根据场景，估算硬件资源
+- 容错和灾备：设置正确的WAL和数据副本数 
+- 系统配置：端口，缓存大小，文件块大小和其他系统配置
+- 用户管理：添加、删除TDengine用户，修改用户密码
+- 数据导入：可按脚本文件导入，也可按数据文件导入
+- 数据导出：从shell按表导出，也可用taosdump工具做各种导出
+- 系统监控：检查系统现有的连接、查询、流式计算，日志和事件等
+- 文件目录结构：TDengine数据文件、配置文件等所在目录 Hui Li
+
+##TAOS SQL 
+- 支持的数据类型：支持时间戳、整型、浮点型、布尔型、字符型等多种数据类型 
+- 数据库管理：添加、删除、查看数据库
+- 表管理：添加、删除、查看、修改表
+- 超级表管理：添加、删除、查看、修改超级表
+- 标签管理：增加、删除、修改标签
+- 数据写入：支持单表单条、多条、多表多条写入，支持历史数据写入
+- 数据查询：支持时间段、值过滤、排序、查询结果手动分页等
+- SQL函数：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
+- 时间维度聚合：将表中数据按照时间段进行切割后聚合，降维处理
+
+##TDengine的技术设计
+- 系统模块：taosd的功能和模块划分
+- 技术博客：更多的技术分析和架构设计文章
+
+## 常用工具
+
+- [TDengine样例数据导入工具](https://www.taosdata.com/cn/documentation/blog/2020/01/18/如何快速验证性能和主要功能？tdengine样例数据导入工/)
+- [TDengine性能对比测试工具](https://www.taosdata.com/cn/documentation/blog/2020/01/13/用influxdb开源的性能测试工具对比influxdb和tdengine/)
+
+##TDengine与其他数据库的对比测试
+
+- [用InfluxDB开源的性能测试工具对比InfluxDB和TDengine](https://www.taosdata.com/cn/documentation/blog/2020/01/13/用influxdb开源的性能测试工具对比influxdb和tdengine/)
+- [TDengine与OpenTSDB对比测试](https://www.taosdata.com/cn/documentation/blog/2019/08/21/tdengine与opentsdb对比测试/)
+- [TDengine与Cassandra对比测试](https://www.taosdata.com/cn/documentation/blog/2019/08/14/tdengine与cassandra对比测试/)
+- [TDengine与InfluxDB对比测试](https://www.taosdata.com/cn/documentation/blog/2019/07/19/tdengine与influxdb对比测试/)
+- [TDengine与InfluxDB、OpenTSDB、Cassandra、MySQL、ClickHouse等数据库的对比测试报告](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)
+
+##物联网大数据
+- [物联网、工业互联网大数据的特点](https://www.taosdata.com/blog/2019/07/09/物联网、工业互联网大数据的特点/)
+- [物联网大数据平台应具备的功能和特点](https://www.taosdata.com/blog/2019/07/29/物联网大数据平台应具备的功能和特点/)
+- [通用大数据架构为什么不适合处理物联网数据？](https://www.taosdata.com/blog/2019/07/09/通用互联网大数据处理架构为什么不适合处理物联/)
+- [物联网、车联网、工业互联网大数据平台，为什么推荐使用TDengine？](https://www.taosdata.com/blog/2019/07/09/物联网、车联网、工业互联网大数据平台，为什么/)
+
+##培训和FAQ
+- <a href='https://www.taosdata.com/en/faq'>FAQ</a>：常见问题与答案
+- <a href='https://www.taosdata.com/en/blog/?categories=4'>应用案列</a>：一些使用实例来解释如何使用TDengine
+
+ 
\ No newline at end of file

documentation20/Evaluation-ch.md

+# TDengine 适用场景介绍（草案）
+
+## TDengine 简介
+
+<!-- 本节内容来源于白皮书 -->
+
+TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
+
+* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒就能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快了十倍以上。
+* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10
+* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。临时查询可通过Shell, Python, R, Matlab随时进行。
+* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
+* __零运维成本、零学习成本__：安装、集群一秒搞定，无需分库分表，实时备份。标准SQL，支持JDBC, RESTful, 支持Python/Java/C/C++/Go, 与MySQL相似，零学习成本。
+
+
+
+<!--sdASF -->
+
+## TDengine 总体适用场景
+
+作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
+
+
+## 数据源特点和需求
+从数据源角度，设计人员可以从已经角度分析TDengine在目标应用系统里面的适用性。
+
+|数据源特点和需求|不适用|可能适用|非常适用|简单说明|
+|---|---|---|---|---|
+|总体数据量巨大|  |  | ✅ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
+|数据输入速度偶尔或者持续巨大|   |   | ✅  | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
+|数据源数目巨大|   |   | ✅ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
+
+
+
+## 系统架构要求
+|系统架构要求|不适用|可能适用|非常适用|简单说明|
+|---|---|---|---|---|
+|要求简单可靠的系统架构|  |  | ✅ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
+|要求容错和高可靠|  |  | ✅ |TDengine的集群功能，自动提供容错灾备等高可靠功能|
+|标准化规范|  |  | ✅ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范|
+
+## 系统功能需求
+|系统功能需求|不适用|可能适用|非常适用|简单说明|
+|---|---|---|---|---|
+|要求完整的内置数据处理算法|  | ✅ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
+|需要大量的交叉查询处理|  | ✅ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能|
+
+
+## 系统性能需求
+|系统性能需求|不适用|可能适用|非常适用|简单说明|
+|---|---|---|---|---|
+|要求较大的总体处理能力|  |  | ✅ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
+|要求高速处理数据  | | | ✅ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
+|要求快速处理小粒度数据|  |  | ✅ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
+
+
+## 系统维护需求
+|系统维护需求|不适用|可能适用|非常适用|简单说明|
+|---|---|---|---|---|
+|要求系统可靠运行|  |  | ✅ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
+|要求运维学习成本可控|  |  | ✅ |同上|
+|要求市场有大量人才储备| ✅ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务|
+