You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
7.4 KiB
282 lines
7.4 KiB
package monitor |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"errors" |
|
"fmt" |
|
"go-common/app/admin/main/videoup/model/monitor" |
|
"go-common/library/cache/redis" |
|
"go-common/library/log" |
|
"sort" |
|
"strconv" |
|
"time" |
|
) |
|
|
|
const ( |
|
FieldKeyFormat = "%d_%d_%d" //监控规则配置的Redis key中的field格式 |
|
) |
|
|
|
// StatsResult 获取稿件停留统计 |
|
func (d *Dao) StatsResult(c context.Context, key string, conf *monitor.RuleConf) (res *monitor.Stats, err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
totalC, moniC, maxT int |
|
now = time.Now().Unix() |
|
tFrom, tTo int64 |
|
timeCdt int64 |
|
compCdt string |
|
ok bool |
|
) |
|
defer conn.Close() |
|
if _, ok = conf.NotifyCdt["time"]; !ok { |
|
err = errors.New("配置的 NotifyCdt 中不存在 time") |
|
return |
|
} |
|
timeCdt = conf.NotifyCdt["time"].Value |
|
compCdt = conf.NotifyCdt["time"].Comp |
|
switch compCdt { |
|
case monitor.CompGT: |
|
tFrom = 0 |
|
tTo = now - timeCdt |
|
case monitor.CompLT: |
|
tFrom = now - timeCdt |
|
tTo = now |
|
default: |
|
err = errors.New("配置的 NotifyCdt 中 comparison 不合法: " + compCdt) |
|
return |
|
} |
|
if totalC, err = redis.Int(conn.Do("ZCOUNT", key, 0, now)); err != nil { |
|
log.Error("conn.Do(ZCOUNT,%s,0,%d) error(%v)", key, now, err) |
|
return |
|
} |
|
if moniC, err = redis.Int(conn.Do("ZCOUNT", key, tFrom, tTo)); err != nil { |
|
log.Error("conn.Do(ZCOUNT,%s,%d,%d) error(%v)", key, tFrom, tTo, err) |
|
return |
|
} |
|
var oldest map[string]string //进入列表最久的项 |
|
oldest, err = redis.StringMap(conn.Do("ZRANGE", key, 0, 0, "WITHSCORES")) |
|
for _, t := range oldest { |
|
var i int |
|
if i, err = strconv.Atoi(t); err != nil { |
|
return |
|
} |
|
maxT = int(now) - i |
|
} |
|
res = &monitor.Stats{ |
|
TotalCount: totalC, |
|
MoniCount: moniC, |
|
MaxTime: maxT, |
|
} |
|
return |
|
} |
|
|
|
// GetAllRules 获取所有规则 |
|
func (d *Dao) GetAllRules(c context.Context, all bool) (rules []*monitor.Rule, err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
res = make(map[string]string) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.StringMap(conn.Do("HGETALL", monitor.RulesKey)); err != nil { |
|
if err != redis.ErrNil { |
|
log.Error("conn.Do(HGETALL, %s) error(%v)", monitor.RulesKey, err) |
|
return |
|
} |
|
} |
|
for _, v := range res { |
|
rule := &monitor.Rule{} |
|
if err = json.Unmarshal([]byte(v), rule); err != nil { |
|
log.Error("json.Unmarshal(%v) error(%v)", v, err) |
|
break |
|
} |
|
if !all && rule.State != 1 { |
|
continue |
|
} |
|
rules = append(rules, rule) |
|
} |
|
return |
|
} |
|
|
|
// GetRules 获取业务下的规则 |
|
func (d *Dao) GetRules(c context.Context, tp, bid int8, all bool) (rules []*monitor.Rule, err error) { |
|
if rules, err = d.GetAllRules(c, all); err != nil { |
|
return |
|
} |
|
for k := 0; k < len(rules); k++ { |
|
v := rules[k] |
|
if v.Type != tp || v.Business != bid { //去掉非当前业务开头的配置 |
|
rules = append(rules[:k], rules[k+1:]...) |
|
k-- |
|
continue |
|
} |
|
} |
|
return |
|
} |
|
|
|
// SetRule 修改/添加监控规则 |
|
func (d *Dao) SetRule(c context.Context, rule *monitor.Rule) (err error) { |
|
if rule.ID == 0 { |
|
if rule.ID, err = d.RuleIDIncKey(c); err != nil { |
|
return |
|
} |
|
} |
|
var ( |
|
conn = d.redis.Get(c) |
|
field = fmt.Sprintf(FieldKeyFormat, rule.Type, rule.Business, rule.ID) |
|
bs []byte |
|
) |
|
defer conn.Close() |
|
if bs, err = json.Marshal(rule); err != nil { |
|
log.Error("json.Marshal(%v) error(%v)", rule, err) |
|
return |
|
} |
|
if _, err = conn.Do("HSET", monitor.RulesKey, field, bs); err != nil { |
|
log.Error("conn.Do(HSET,%s,%s,%s) error(%v)", monitor.RulesKey, field, bs, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// GetRule 获取某条监控规则 |
|
func (d *Dao) GetRule(c context.Context, tp, bid int8, id int64) (rule *monitor.Rule, err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
field = fmt.Sprintf(FieldKeyFormat, tp, bid, id) |
|
bs []byte |
|
) |
|
defer conn.Close() |
|
if bs, err = redis.Bytes(conn.Do("HGET", monitor.RulesKey, field)); err != nil { |
|
log.Error("conn.Do(HGET,%s,%s) error(%v)", monitor.RulesKey, field, err) |
|
return |
|
} |
|
rule = &monitor.Rule{} |
|
if err = json.Unmarshal(bs, rule); err != nil { |
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// SetRuleState 修改监控规则的状态 |
|
func (d *Dao) SetRuleState(c context.Context, tp, bid int8, id int64, state int8) (err error) { |
|
var ( |
|
rule *monitor.Rule |
|
) |
|
if rule, err = d.GetRule(c, tp, bid, id); err != nil { |
|
return |
|
} |
|
rule.State = state |
|
if err = d.SetRule(c, rule); err != nil { |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RuleIDIncKey 自增配置id |
|
func (d *Dao) RuleIDIncKey(c context.Context) (id int64, err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
) |
|
defer conn.Close() |
|
if id, err = redis.Int64(conn.Do("INCR", monitor.RuleIDIncKey)); err != nil { |
|
log.Error("conn.Do(INCR,%s) error(%v)", monitor.RuleIDIncKey, err) |
|
} |
|
return |
|
} |
|
|
|
// BusStatsKeys 获取某业务统计的所有keys |
|
func (d *Dao) BusStatsKeys(c context.Context, bid int8) (prefix string, keys []string, err error) { |
|
var ( |
|
conf *monitor.KeyConf |
|
ok bool |
|
) |
|
if conf, ok = monitor.RedisKeyConf[bid]; !ok { |
|
err = errors.New("业务redis key配置不存在") |
|
log.Error("d.BusStatsKeys(%d) error(%v)", bid, err) |
|
return |
|
} |
|
prefix = fmt.Sprintf(monitor.BusPrefix, bid) |
|
//TODO 递归实现 |
|
if bid == monitor.BusVideo { |
|
for _, v := range conf.KFields["state"] { |
|
key := prefix + fmt.Sprintf(monitor.SuffixVideo, v) |
|
keys = append(keys, key) |
|
} |
|
} else if bid == monitor.BusArc { |
|
for _, round := range conf.KFields["round"] { |
|
for _, state := range conf.KFields["state"] { |
|
key := prefix + fmt.Sprintf(monitor.SuffixArc, round, state) |
|
keys = append(keys, key) |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// StayOids 获取多个key 中的滞留oid |
|
func (d *Dao) StayOids(c context.Context, rule *monitor.Rule, keys []string) (oidMap map[int64]int, total int, err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
intMap map[string]int |
|
min, max int64 |
|
now = time.Now().Unix() |
|
) |
|
defer conn.Close() |
|
oidMap = make(map[int64]int) |
|
intMap = make(map[string]int) |
|
if _, ok := rule.RuleConf.NotifyCdt["time"]; !ok { |
|
log.Error("StayOids(%+v) Rule配置中NotifyCdt 没有time", *rule) |
|
err = errors.New(fmt.Sprintf("Rule(%d) NotifyCdt Error: no time", rule.ID)) |
|
return |
|
} |
|
timeConf := rule.RuleConf.NotifyCdt["time"] |
|
switch timeConf.Comp { |
|
case monitor.CompGT: |
|
min = 0 |
|
max = now - timeConf.Value |
|
case monitor.CompLT: |
|
min = now - timeConf.Value |
|
max = now |
|
default: |
|
log.Error("StayOids(%+v) Rule配置NotifyCdt中time的表达式错误", *rule) |
|
err = errors.New(fmt.Sprintf("Rule(%d) NotifyCdt Error: unknown time comp", rule.ID)) |
|
return |
|
} |
|
//key排序 |
|
sort.Strings(keys) |
|
//计算count 翻页 |
|
for _, key := range keys { |
|
count := 0 |
|
if count, err = redis.Int(conn.Do("ZCOUNT", key, min, max)); err != nil { |
|
log.Error("redis.Int(conn.Do(\"ZCOUNT\", %s, %d, %d)) error(%v)", key, min, max, err) |
|
return |
|
} |
|
total += count |
|
|
|
if intMap, err = redis.IntMap(conn.Do("ZRANGEBYSCORE", key, min, max, "WITHSCORES")); err != nil { |
|
log.Error("redis.IntMap(conn.Do(\"ZRANGEBYSCORE\", %s, %d, %d, \"WITHSCORES\")) error(%v)", key, min, max, err) |
|
return |
|
} |
|
for k, v := range intMap { |
|
oid := 0 |
|
if oid, err = strconv.Atoi(k); err != nil { |
|
log.Error("strconv.Atoi(%s) error(%v)", k, err) |
|
} |
|
oidMap[int64(oid)] = v |
|
} |
|
} |
|
return |
|
} |
|
|
|
// RemMonitorStats remove stay stats |
|
func (d *Dao) RemMonitorStats(c context.Context, key string, oid int64) (err error) { |
|
var ( |
|
conn = d.redis.Get(c) |
|
) |
|
defer conn.Close() |
|
if _, err = conn.Do("ZREM", key, oid); err != nil { |
|
log.Error("conn.Do(ZADD, %s, %d) error(%v)", key, oid, err) |
|
} |
|
return |
|
}
|
|
|