func convert(v *cmodel.MetaData) *cmodel.MetricValue {
	return &cmodel.MetricValue{
		Metric:    v.Metric,
		Endpoint:  v.Endpoint,
		Timestamp: v.Timestamp,
		Step:      v.Step,
		Type:      v.CounterType,
		Tags:      cutils.SortedTags(v.Tags),
		Value:     v.Value,
	}
}
Exemple #2
0
func BuildCommonSMSContent(event *model.Event) string {
	return fmt.Sprintf(
		"[P%d][%s][%s][][%s %s %s %s %s%s%s][O%d %s]",
		event.Priority(),
		event.Status,
		event.Endpoint,
		event.Note(),
		event.Func(),
		event.Metric(),
		utils.SortedTags(event.PushedTags),
		utils.ReadableFloat(event.LeftValue),
		event.Operator(),
		utils.ReadableFloat(event.RightValue()),
		event.CurrentStep,
		event.FormattedTime(),
	)
}
Exemple #3
0
func BuildCommonMailContent(event *model.Event) string {
	link := g.Link(event)
	return fmt.Sprintf(
		"%s\r\nP%d\r\nEndpoint:%s\r\nMetric:%s\r\nTags:%s\r\n%s: %s%s%s\r\nNote:%s\r\nMax:%d, Current:%d\r\nTimestamp:%s\r\n%s\r\n",
		event.Status,
		event.Priority(),
		event.Endpoint,
		event.Metric(),
		utils.SortedTags(event.PushedTags),
		event.Func(),
		utils.ReadableFloat(event.LeftValue),
		event.Operator(),
		utils.ReadableFloat(event.RightValue()),
		event.Note(),
		event.MaxStep(),
		event.CurrentStep,
		event.FormattedTime(),
		link,
	)
}
Exemple #4
0
func CalcInheritStrategies(allTpls map[int]*model.Template, tids []int, tpl2Strategies map[int][]*model.Strategy) []model.Strategy {
	// 根据模板的继承关系,找到每个机器对应的模板全量
	/**
	 * host_id =>
	 * |a |d |a |a |a |
	 * |  |  |b |b |f |
	 * |  |  |  |c |  |
	 * |  |  |  |  |  |
	 */
	tpl_buckets := [][]int{}
	for _, tid := range tids {
		ids := cache.ParentIds(allTpls, tid)
		if len(ids) <= 0 {
			continue
		}
		tpl_buckets = append(tpl_buckets, ids)
	}

	// 每个host 关联的模板,有继承关系的放到同一个bucket中,其他的放在各自单独的bucket中
	/**
	 * host_id =>
	 * |a |d |a |
	 * |b |  |f |
	 * |c |  |  |
	 * |  |  |  |
	 */
	uniq_tpl_buckets := [][]int{}
	for i := 0; i < len(tpl_buckets); i++ {
		var valid bool = true
		for j := 0; j < len(tpl_buckets); j++ {
			if i == j {
				continue
			}
			if slice_int_eq(tpl_buckets[i], tpl_buckets[j]) {
				break
			}
			if slice_int_lt(tpl_buckets[i], tpl_buckets[j]) {
				valid = false
				break
			}
		}
		if valid {
			uniq_tpl_buckets = append(uniq_tpl_buckets, tpl_buckets[i])
		}
	}

	// 继承覆盖父模板策略,得到每个模板聚合后的策略列表
	strategies := []model.Strategy{}

	exists_by_id := make(map[int]struct{})
	for _, bucket := range uniq_tpl_buckets {

		// 开始计算一个桶,先计算老的tid,再计算新的,所以可以覆盖
		// 该桶最终结果
		bucket_stras_map := make(map[string][]*model.Strategy)
		for _, tid := range bucket {

			// 一个tid对应的策略列表
			the_tid_stras := make(map[string][]*model.Strategy)

			if stras, ok := tpl2Strategies[tid]; ok {
				for _, s := range stras {
					uuid := fmt.Sprintf("metric:%s/tags:%v", s.Metric, utils.SortedTags(s.Tags))
					if _, ok2 := the_tid_stras[uuid]; ok2 {
						the_tid_stras[uuid] = append(the_tid_stras[uuid], s)
					} else {
						the_tid_stras[uuid] = []*model.Strategy{s}
					}
				}
			}

			// 覆盖父模板
			for uuid, ss := range the_tid_stras {
				bucket_stras_map[uuid] = ss
			}
		}

		last_tid := bucket[len(bucket)-1]

		// 替换所有策略的模板为最年轻的模板
		for _, ss := range bucket_stras_map {
			for _, s := range ss {
				valStrategy := *s
				// exists_by_id[s.Id] 是根据策略ID去重,不太确定是否真的需要,不过加上肯定没问题
				if _, exist := exists_by_id[valStrategy.Id]; !exist {
					if valStrategy.Tpl.Id != last_tid {
						valStrategy.Tpl = allTpls[last_tid]
					}
					strategies = append(strategies, valStrategy)
					exists_by_id[valStrategy.Id] = struct{}{}
				}
			}
		}
	}

	return strategies
}
Exemple #5
0
func genMock(ts int64, key string, ndcfg *cmodel.NodataConfig) {
	sender.AddMock(key, ndcfg.Endpoint, ndcfg.Metric, cutils.SortedTags(ndcfg.Tags), ts, ndcfg.Type, ndcfg.Step, ndcfg.Mock)
}
// 根据item,更新db存储. 不用本地缓存 优化db访问频率.
func updateIndexFromOneItem(item *cmodel.GraphItem, conn *sql.DB) error {
	if item == nil {
		return nil
	}

	endpoint := item.Endpoint
	ts := item.Timestamp
	var endpointId int64 = -1
	sqlDuplicateString := " ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), ts=VALUES(ts)" //第一个字符是空格

	// endpoint表
	{
		sqlStr := "INSERT INTO endpoint (endpoint, ts, t_create) VALUES (?, ?, now())" + sqlDuplicateString
		ret, err := conn.Exec(sqlStr, endpoint, ts)
		if err != nil {
			log.Println(err)
			return err
		}

		endpointId, err = ret.LastInsertId()
		if err != nil {
			log.Println(err)
			return err
		}
	}

	// tag_endpoint表
	{
		sqlStr := "INSERT INTO tag_endpoint (tag, endpoint_id, ts, t_create) VALUES (?, ?, ?, now())" + sqlDuplicateString
		for tagKey, tagVal := range item.Tags {
			tag := fmt.Sprintf("%s=%s", tagKey, tagVal)

			ret, err := conn.Exec(sqlStr, tag, endpointId, ts)
			if err != nil {
				log.Println(err)
				return err
			}

			_, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		}
	}

	// endpoint_counter表
	{
		counter := item.Metric
		if len(item.Tags) > 0 {
			counter = fmt.Sprintf("%s/%s", counter, cutils.SortedTags(item.Tags))
		}

		sqlStr := "INSERT INTO endpoint_counter (endpoint_id,counter,step,type,ts,t_create) VALUES (?,?,?,?,?,now())" + sqlDuplicateString
		ret, err := conn.Exec(sqlStr, endpointId, counter, item.Step, item.DsType, ts)
		if err != nil {
			log.Println(err)
			return err
		}

		_, err = ret.LastInsertId()
		if err != nil {
			log.Println(err)
			return err
		}
	}

	return nil
}
Exemple #7
0
func (this *NodataConfig) String() string {
	return fmt.Sprintf("{NodataConfig id:%d, name:%s, objType:%s, endpoint:%s, metric:%s, tags:%s, type:%s, step:%d, mock:%f}",
		this.Id, this.Name, this.ObjType, this.Endpoint, this.Metric, utils.SortedTags(this.Tags), this.Type, this.Step, this.Mock)
}
func maybeUpdateIndexFromOneItem(item *cmodel.GraphItem, conn *sql.DB) error {
	if item == nil {
		return nil
	}

	endpoint := item.Endpoint
	ts := item.Timestamp
	var endpointId int64 = -1
	sqlDuplicateString := " ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), ts=VALUES(ts)" //第一个字符是空格

	// endpoint表
	{
		err := conn.QueryRow("SELECT id FROM endpoint WHERE endpoint = ?", endpoint).Scan(&endpointId)
		if err != nil && err != sql.ErrNoRows {
			log.Println(endpoint, err)
			return err
		}
		proc.IndexUpdateIncrDbEndpointSelectCnt.Incr()

		if err == sql.ErrNoRows || endpointId <= 0 { // 数据库中也没有, insert
			sqlStr := "INSERT INTO endpoint(endpoint, ts, t_create) VALUES (?, ?, now())" + sqlDuplicateString
			ret, err := conn.Exec(sqlStr, endpoint, ts)
			if err != nil {
				log.Println(err)
				return err
			}
			proc.IndexUpdateIncrDbEndpointInsertCnt.Incr()

			endpointId, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		} else { // do not update
		}
		// 更新缓存
		//dbEndpointCache.Set(endpoint, endpointId, 0)
	}

	// tag_endpoint表
	{
		for tagKey, tagVal := range item.Tags {
			tag := fmt.Sprintf("%s=%s", tagKey, tagVal)

			var tagEndpointId int64 = -1
			err := conn.QueryRow("SELECT id FROM tag_endpoint WHERE tag = ? and endpoint_id = ?",
				tag, endpointId).Scan(&tagEndpointId)
			if err != nil && err != sql.ErrNoRows {
				log.Println(tag, endpointId, err)
				return err
			}
			proc.IndexUpdateIncrDbTagEndpointSelectCnt.Incr()

			if err == sql.ErrNoRows || tagEndpointId <= 0 {
				sqlStr := "INSERT INTO tag_endpoint(tag, endpoint_id, ts, t_create) VALUES (?, ?, ?, now())" + sqlDuplicateString
				ret, err := conn.Exec(sqlStr, tag, endpointId, ts)
				if err != nil {
					log.Println(err)
					return err
				}
				proc.IndexUpdateIncrDbTagEndpointInsertCnt.Incr()

				tagEndpointId, err = ret.LastInsertId()
				if err != nil {
					log.Println(err)
					return err
				}
			}
		}
	}

	// endpoint_counter表
	{
		counter := item.Metric
		if len(item.Tags) > 0 {
			counter = fmt.Sprintf("%s/%s", counter, cutils.SortedTags(item.Tags))
		}

		var endpointCounterId int64 = -1
		var step int = 0
		var dstype string = "nil"

		err := conn.QueryRow("SELECT id,step,type FROM endpoint_counter WHERE endpoint_id = ? and counter = ?",
			endpointId, counter).Scan(&endpointCounterId, &step, &dstype)
		if err != nil && err != sql.ErrNoRows {
			log.Println(counter, endpointId, err)
			return err
		}
		proc.IndexUpdateIncrDbEndpointCounterSelectCnt.Incr()

		if err == sql.ErrNoRows || endpointCounterId <= 0 {
			sqlStr := "INSERT INTO endpoint_counter(endpoint_id,counter,step,type,ts,t_create) VALUES (?,?,?,?,?,now())" +
				" ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id),ts=VALUES(ts), step=VALUES(step),type=VALUES(type)"
			ret, err := conn.Exec(sqlStr, endpointId, counter, item.Step, item.DsType, ts)
			if err != nil {
				log.Println(err)
				return err
			}
			proc.IndexUpdateIncrDbEndpointCounterInsertCnt.Incr()

			endpointCounterId, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		} else {
			if !(item.Step == step && item.DsType == dstype) {
				_, err := conn.Exec("UPDATE endpoint_counter SET step = ?, type = ? where id = ?",
					item.Step, item.DsType, endpointCounterId)
				proc.IndexUpdateIncrDbEndpointCounterUpdateCnt.Incr()
				if err != nil {
					log.Println(err)
					return err
				}
			}
		}
	}

	return nil
}
Exemple #9
0
func (this *Event) Counter() string {
	return fmt.Sprintf("%s/%s %s", this.Endpoint, this.Metric(), utils.SortedTags(this.PushedTags))
}