OpenTsdb驱动简单实现

时序时空数据库TSDB简介和使用方案可以看文档 https://www.docs4dev.com/docs/zh/opentsdb/2.3/reference

TSDB对外只提供restful api，而且TSDB作为时序数据库，在后台的微服务的使用大部分场景只做查询，数据的写入交由其他的数据采集服务负责。我们之前有个使用场景是通过canal去监听mysql binlog,将实时的数据写入TSDB中。由其他服务通过http post方式去读取。

阿里云提供的TSDB HTTP API方法看以看https://help.aliyun.com/document_detail/63557.html?spm=a2c4g.11186623.6.643.1c3641eboXiKe6
TSDB查询的http api方法如下：

http://ip:port/api/query

TSDB查询的包体如下：

/*单值查询*/
type Query struct {
	Aggregator string            `json:"aggregator"`           //表示 OpenTSDB 查询时的预聚合方法,
	Metric     string            `json:"metric"`               //指标名
	Rate       bool              `json:"rate,omitempty"`       //是否计算指定指标值的增长速率；计算公式： Vt-Vt-1/t1-t-1
	Tags       map[string]string `json:"tags,omitempty"`       //指定标签过滤，和filters冲突,这里用tags,不用filters
	Downsample string            `json:"downsample,omitempty"` //表示 OpenTSDB 查询时的采样方法,目前统一设置为: 0all-last 全局采样
	Limit      int               `json:"limit,omitempty"`      //数据分页，子查询返回数据点的最大数目
	Offset     int               `json:"offset,omitempty"`     //数据分页，子查询返回数据点的偏移量
	DpValue    string            `json:"dpValue,omitempty"`    //根据提供条件过滤返回数据点，支持”>”, “<”, “=”,”<=”, “>=”, “!=”。
}

type QueryParams struct {
	Start   interface{} `json:"start"`
	End     interface{} `json:"end,omitempty"`
	Queries []Query     `json:"queries,omitempty"`
}

Metric是查询你需要的 指标名，可以理解为mysql或者mongodb里面的表，这些表里面有很多字段，想要查询的字段写在Tags中
TSDB查询成功会返回这样的参数：

type QueryResponse struct {
	Metric        string             `json:"metric"`
	Tags          map[string]string  `json:"tags"`
	AggregateTags []string           `json:"aggregateTags"`
	Dps           map[string]float64 `json:"dps"`
}

如果查询失败不是直接在http上返回error，而是直接返回一个error的报文：

/*返回错误结构体*/
type QueryErrorMsg struct {
	Error ErrorMsg `json:"error"`
}

type ErrorMsg struct {
	Code    int    `json:"code"`    //错误码
	Message string `json:"message"` //错误消息
	Trace   string `json:"trace"`   //打印的服务端堆栈信息
}

TSDB 时序数据库的含义指它能方便的查出从数据第一次写入时间到任意时间段的值，比如我们需要获取哪一天的哪一秒的值，就可以构造这样的参数：这里用curl 先模拟一下：

 curl  -X POST -H "Accept:application/json" -H  "Content-Type:application/json" http://10.1.0.11:4242/api/query  -d '
              {
                  "start": "1474387200000", 
                  "end": "1537459200000",
                  "queries": [
                      {
                          "aggregator": "last",   				//聚合方法，有sum , count , min, max，last等等，具体含义看上面给的链接
                          "downsample": "0all-last",			//降采样 (Downsample) 说明,具体如下，这里设置为0all-last表示全局采样
                          "index": 0,
                          "metric": "xxxxxx",						//这里用指标名，写入的时候设置的值
                          "tags": {
                              "field": "name"						//这里如果需要查询多个值可以用 | ，比如同时查询name 和year 可以用"name|year",如果设置为”*“表示查询所有值
                          }
                      }
                  ]
              }
              '

返回：

[
                  {
                      "metric": "xxxxxx",
                      "tags": {
                          "field": "name"
                      },
                      "aggregateTags": [
                          
                      ],
                      "dps": {
                          "1474387200": 1231.9999999999998
                      }
                  }
              ]

dps的value表示查询得到的值

在线上服务的使用过程我们不能每来一个请求就创建一个http连接去请求TSDB，再加上后台可能有多台TSDB服务器做集群，为了保证高可用，所以需要做连接池，负载均衡，错误重试，超时调度，熔断等等一系列措施。

首先我们设计一个TSDB Balance，主要用来做负载均衡。这里可以为每一个TSDB的ip设计相应的权重，如果某台TSDB服务器出现故障，可以自动的降低权重，并且可以设计一个配置的超时时间恢复该连接的权重，这个时间对TSDB服务器进行修复，这样就可以达到高可用的目的。

type TsdbInstance struct {
	Host          string
	Weight        int //配置权重
	CurrentWeight int //当前权重
}

type TsdbBalance struct {
	sync.RWMutex
	ip          []*TsdbInstance
}

func NewTsdbBalance() *TsdbBalance {
	Tsdb := &TsdbBalance{}
	Tsdb.ip = make([]*TsdbInstance, 0)
	return Tsdb
}

func (t *TsdbBalance) Register(ts []TsdbInstance) {
	for i := 0; i < len(ts); i++ {
		t.ip = append(t.ip, &ts[i])
	}
}

func (t *TsdbBalance) GetRandTsdbInstance() *TsdbInstance {
	if len(t.ip) == 0 {
		return nil
	}
	var best *TsdbInstance
	total := 0
	t.RLock()
	for i := 0; i < len(t.ip); i++ {
		instance := t.ip[i]
		instance.CurrentWeight += instance.Weight
		total += instance.Weight
		if best == nil || instance.CurrentWeight > best.CurrentWeight {
			best = instance
		}
	}
	t.RUnlock()
	if best == nil {
		return nil
	}
	best.CurrentWeight -= total

	return best
}

func (t *TsdbBalance) UpDateWeight(ts *TsdbInstance) error {
	for i := 0; i < len(t.ip); i++ {
		if t.ip[i].Host == ts.Host {
			t.Lock()
			t.ip[i].Weight = ts.Weight
			t.Unlock()
			return nil
		}
	}
	return fmt.Errorf("tsdb instance not found ")
}

对于TSDB服务器请求，需要设计一个连接池去进行连接的复用，可以使用net/http自带的连接池：

func createHTTPClient() *http.Client {

	client := &http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyFromEnvironment,
			DialContext: (&net.Dialer{
				Timeout:   30 * time.Second,
				KeepAlive: 30 * time.Second,
			}).DialContext,
			MaxIdleConns:        MaxIdleConns,			  //最大空闲连接数
			MaxIdleConnsPerHost: MaxIdleConnsPerHost,		//最大与服务器的连接数  默认是2
			IdleConnTimeout:     IdleConnTimeout * time.Second,	//空闲连接保持时间
		},
	}
	return client
}

这里参数需要对TSDB服务器所在的机器配置进行合理的评估，通过压测分析最合理的配置~~，不然会发现和不用连接池的时间差别不大。连接池主要作用是连接的复用，合理配置参数才能有更高的效率，不要盲目的套用网上某些博客上配置。

请求连接的过程如下：

q := &QueryParams{
			Start: v.StartTime,
			End:   v.EndTime,
		}
		query := Query{
			Aggregator: aggregator,
			Downsample: downsample,
			Metric:    "xxxxxx",
			Tags:       map[string]string{"field": v.FieldName},
		}
		q.Queries = append(q.Queries, query)
		data, err := json.Marshal(*q)
		if err != nil {
			return nil, err
		}
		instance := tsdbBalance.GetRandTsdbInstance()
		req, err := http.NewRequest("POST", fmt.Sprintf("http://%s/api/query", instance.Host), bytes.NewBuffer(data))
		if err != nil {
			return nil, err
		}
		req.Header.Set("Content-Type", "application/json")
		resp, err := httpClient.Do(req)
		if err != nil {
			return nil, err
		}
		defer resp.Body.Close()
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return nil, err
		}
		var rsp []QueryResponse
		err = json.Unmarshal(body, &rsp)
		if err != nil {
			var errMsg QueryErrorMsg
			err = json.Unmarshal(body, &errMsg)
			if err != nil {
				return nil, err
			}
			/*如果是服务端出错，应该中断与该服务端的连接*/
			if errMsg.Error.Code == 500 || errMsg.Error.Code == 501 {
				err := tsdbBalance.UpDateWeight(&TsdbInstance{
					Host:   instance.Host,
					Weight: 0,
				})
				if err != nil {
					return nil, err
				}
			} else if errMsg.Error.Code == 503 { /*如果是服务端过载，应该降低与该服务端连接的权重，暂时先除2，后期设计一个定时系统恢复权重*/
				_ = tsdbBalance.UpDateWeight(&TsdbInstance{
					Host:   instance.Host,
					Weight: instance.Weight / 2,
				})
			} else {
				return nil, err
			}
		}