alerting

type Check ¶

type Check struct {
	// do we need these members here?
	//Id           int64
	//OrgId        int64
	//DataSourceId int64
	Definition m.CheckDef
}

type CheckEvaluator ¶

type CheckEvaluator interface {
	Eval() (*m.CheckEvalResult, error)
}

type GraphiteCheckEvaluator ¶

type GraphiteCheckEvaluator struct {
	Context graphite.Context
	Check   m.CheckDef
	// contains filtered or unexported fields
}

func NewGraphiteCheckEvaluator(c graphite.Context, check m.CheckDef) (*GraphiteCheckEvaluator, error)

func (ce *GraphiteCheckEvaluator) Eval(ts time.Time) (m.CheckEvalResult, error)

type GraphiteReturner ¶

type GraphiteReturner func(org_id int64) (bgraphite.Context, error)

type Ticker ¶

type Ticker struct {
	C chan time.Time
	// contains filtered or unexported fields
}

ticker is a ticker to power the alerting scheduler. it's like a time.Ticker, except:

• it doesn't drop ticks for slow receivers, rather, it queues up. so that callers are in control to instrument what's going on.
• it automatically ticks every second, which is the right thing in our current design
• it ticks on second marks or very shortly after. this provides a predictable load pattern (this shouldn't cause too much load contention issues because the next steps in the pipeline just process at their own pace)
• the timestamps are used to mark "last datapoint to query for" and as such, are a configurable amount of seconds in the past
• because we want to allow:
• a clean "resume where we left off" and "don't yield ticks we already did"
• adjusting offset over time to compensate for storage backing up or getting fast and providing lower latency you specify a lastProcessed timestamp as well as an offset at creation, or runtime

func NewTicker(last time.Time, initialOffset time.Duration, c clock.Clock) *Ticker