func (p *Policy) CheckNotMatch(e *event.Event) bool {
for k, m := range p.r_not_match {
if m.MatchString(e.Get(k)) {
return false
}
}
return true
}
// check if any of p's matches are satisfied by the event
func (p *Policy) CheckMatch(e *event.Event) bool {
for k, m := range p.r_match {
// if the element does not match the regex pattern, the event does not fully match
if !m.MatchString(e.Get(k)) {
return false
}
}
return true
}
func (c *Condition) DoOnTracker(e *event.Event, dot func(*eventTracker)) {
// c.Lock()
et, ok := c.eventTrackers[e.IndexName()]
if !ok {
et = c.newTracker()
c.eventTrackers[e.IndexName()] = et
}
dot(et)
// c.Unlock()
}
func (t *Tracker) trackEvent(e *event.Event) {
// don't track internal events
if len(e.Get(INTERNAL_TAG_NAME)) != 0 {
return
}
t.total.inc()
t.updateCounts(e)
t.updateTimes(e)
}
func (c *Condition) getTracker(e *event.Event) *eventTracker {
if c.eventTrackers == nil {
c.eventTrackers = make(map[string]*eventTracker)
}
et, ok := c.eventTrackers[e.IndexName()]
if !ok {
et = c.newTracker()
c.eventTrackers[e.IndexName()] = et
}
return et
}
// Run the given event though the pipeline
func (p *Pipeline) processEvent(e *event.Event) {
// update to current state
e.SetState(event.StatePipeline)
// track stas for this event
p.tracker.TrackEvent(e)
// process this event on every policy
var pol *escalation.Policy
for _, pol = range p.policies {
pol.PassEvent(e)
}
}
// Run the given event though the pipeline
func (p *Pipeline) Process(e *event.Event) {
if p.globalPolicy != nil {
if !p.globalPolicy.CheckMatch(e) || !p.globalPolicy.CheckNotMatch(e) {
return
}
}
// track stas for this event
p.tracker.TrackEvent(e)
// process this event on every policy
var pol *alarm.Policy
for _, pol = range p.policies {
e.WaitInc()
pol.Process(e, func(in *event.Incident) {
p.ProcessIncident(in)
})
}
}
// start the policy listening for events
func (p *Policy) start() {
go func() {
var e *event.Event
for {
select {
case toResolve := <-p.resolve:
var c *Condition
// fetch the condition that created this incident
if toResolve.Status == event.CRITICAL {
c = p.Crit
} else if toResolve.Status == event.WARNING {
c = p.Warn
}
if c != nil {
t := c.getTracker(&toResolve.Event)
t.refresh()
}
case <-p.stop:
logrus.Info("Stopping policy", p.Name)
// cleanup the policy. Sometimes they hangaround.
p.clean()
// stop this policy from being stopped again
p.stop = nil
// catch resolve's that could be sent to this policy
res := p.resolve
p.resolve = nil
go func() {
for {
select {
case <-res:
logrus.Info("Attempted to resolve an incident on a policy that no longer exists")
case <-time.After(1 * time.Minute):
return
}
}
}()
return
case e = <-p.in:
e.SetState(event.StatePolicy)
// process the event if it matches the policy
if p.Matches(e) {
// check critical
if shouldAlert, status := p.ActionCrit(e); shouldAlert {
incident := event.NewIncident(p.Name, status, e)
incident.SetResolve(p.resolve)
// send send it off to the next hop
p.next.PassIncident(incident)
// check warning
} else if shouldAlert, status := p.ActionWarn(e); shouldAlert {
incident := event.NewIncident(p.Name, status, e)
incident.SetResolve(p.resolve)
// send it off to the next hop
p.next.PassIncident(incident)
} else {
e.SetState(event.StateComplete)
}
}
}
}
}()
}
// generate an index name by using group-by statements
func (g grouper) genIndexName(e *event.Event) string {
return e.IndexName()
}