// migrate db schema. func (db *DB) migrate() error { log.Debugf("migrate sql schemas..") rule := &models.Rule{} user := &models.User{} proj := &models.Project{} return db.db.AutoMigrate(rule, user, proj).Error }
// match a metric with rules, and return matched rules. // Details: // 1. If no rules matched, return false. // 2. If any black patterns matched, return false. // 3. Else, return true and matched rules. func (d *Detector) match(m *models.Metric) (bool, []*models.Rule) { // Check rules. timer := util.NewTimer() // Filter timer rules := d.flt.MatchedRules(m) elapsed := timer.Elapsed() health.AddFilterCost(elapsed) if len(rules) == 0 { // Hit no rules. return false, rules } // Check blacklist. for _, p := range d.cfg.Detector.BlackList { ok, err := filepath.Match(p, m.Name) if err != nil { // Invalid black pattern. log.Errorf("invalid black pattern: %s, %v", p, err) continue } if ok { // Hit black pattern. log.Debugf("%s hit black pattern %s", m.Name, p) return false, rules } } return true, rules // OK }
// startIdleTracking starts a goroutine to track idle metrics by interval. func (d *Detector) startIdleTracking() { go func() { log.Debugf("starting idle metrics tracking..") interval := time.Duration(d.cfg.Detector.IdleMetricCheckInterval) * time.Second ticker := time.NewTicker(interval) for _ = range ticker.C { d.checkIdles() } }() }
// initFromDB inits rules from db. func (f *Filter) initFromDB(db *storage.DB) { log.Debugf("init filter's rules from cache..") // Listen rules changes. db.Admin.RulesCache.OnAdd(f.addRuleCh) db.Admin.RulesCache.OnDel(f.delRuleCh) // Add rules from cache rules := db.Admin.RulesCache.All() for _, rule := range rules { f.addRule(rule) } }
// UpdateWithYamlFile updates the config from a yaml file. func (c *Config) UpdateWithYamlFile(fileName string) error { log.Debugf("read config from %s..", fileName) b, err := ioutil.ReadFile(fileName) if err != nil { return err } err = yaml.Unmarshal(b, c) if err != nil { return err } return err }
// MatchedRules returns the matched rules by metric name. func (f *Filter) MatchedRules(m *models.Metric) (rules []*models.Rule) { d := f.trie.Matched(m.Name) for _, v := range d { n := v.(*node) if f.cfg.Detector.EnableIntervalHitLimit { hits := atomic.AddUint32(&n.hits, 1) if hits > f.cfg.Detector.IntervalHitLimit { log.Debugf("%s hits over interval hit limit", n.rule.Pattern) return []*models.Rule{} } } rules = append(rules, n.rule) } return }
// Open a DB by filename. func Open(fileName string, opts *Options) (*DB, error) { _, err := os.Stat(fileName) if os.IsNotExist(err) { // Create if not exist if err := os.Mkdir(fileName, filemode); err != nil { return nil, err } log.Debugf("dir %s created", fileName) } db := &DB{opts: opts, name: fileName} if err = db.init(); err != nil { return nil, err } return db, nil }
// Init cache from db. func (c *rulesCache) Init(db *gorm.DB) error { log.Debugf("init rules from admindb..") // Query var rules []models.Rule err := db.Find(&rules).Error if err != nil { return err } // Load for i := 0; i < len(rules); i++ { rule := &rules[i] rule.Share() c.rules.Set(rule.ID, rule) } return nil }
// init opens all storages on DB open. func (db *DB) init() error { infos, err := ioutil.ReadDir(db.name) if err != nil { return err } for _, info := range infos { fileName := path.Join(db.name, info.Name()) s, err := openStorage(fileName) if err != nil { return err } db.pool = append(db.pool, s) log.Debugf("storage %d opened", s.id) } sort.Sort(byID(db.pool)) return nil }
// migrate storage schmea. func (s *storage) migrate() error { log.Debugf("migrate storage %d schema", s.id) return s.db.AutoMigrate(&EventWrapper{}).Error }