alerting

type AlertEngine ¶

type AlertEngine struct {
	Scheduler scheduler
	// contains filtered or unexported fields
}

AlertEngine is the background process that schedules alert evaluations and makes sure notifications are sent.

func (e *AlertEngine) Init() error

func (e *AlertEngine) IsDisabled() bool

func (e *AlertEngine) Run(ctx context.Context) error

type AlertRuleTester ¶

type AlertRuleTester struct{}

func (_ AlertRuleTester) DoTest(ruleDef *models.SAlert, userCred mcclient.TokenCredential, input monitor.AlertTestRunInput) (*monitor.AlertTestRunOutput, error)

type Condition ¶

type Condition interface {
	Eval(result *EvalContext) (*ConditionResult, error)
}

Condition is responsible for evaluating an alert condition.

type ConditionFactory ¶

type ConditionFactory func(model *monitor.AlertCondition, index int) (Condition, error)

ConditionFactory is the function signature for creating `Conditions`

type ConditionResult ¶

type ConditionResult struct {
	Firing             bool
	NoDataFound        bool
	Operator           string
	EvalMatches        []*monitor.EvalMatch
	AlertOkEvalMatches []*monitor.EvalMatch
}

ConditionResult is the result of a condition evaluation.

type DefaultEvalHandler ¶

type DefaultEvalHandler struct {
	// contains filtered or unexported fields
}

DefaultEvalHandler is responsible for evaluating the alert rule.

func NewEvalHandler() *DefaultEvalHandler

func (e *DefaultEvalHandler) Eval(context *EvalContext)

type EvalContext ¶

type EvalContext struct {
	Firing             bool
	IsTestRun          bool
	IsDebug            bool
	EvalMatches        []*monitor.EvalMatch
	AlertOkEvalMatches []*monitor.EvalMatch
	Logs               []*monitor.ResultLogEntry
	Error              error
	ConditionEvals     string
	StartTime          time.Time
	EndTime            time.Time
	Rule               *Rule

	NoDataFound    bool
	PrevAlertState monitor.AlertStateType

	Ctx      context.Context
	UserCred mcclient.TokenCredential
}

EvalContext is the context object for an alert evaluation.

func NewEvalContext(alertCtx context.Context, userCred mcclient.TokenCredential, rule *Rule) *EvalContext

func (c *EvalContext) GetCallbackURLPrefix() string

func (c *EvalContext) GetDurationMs() float64

func (c *EvalContext) GetEvalMatches() []monitor.EvalMatch

func (c *EvalContext) GetNewState() monitor.AlertStateType

func (c *EvalContext) GetNotificationTemplateConfig() monitor.NotificationTemplateConfig

func (c *EvalContext) GetNotificationTitle() string

func (c *EvalContext) GetResourceNameOfMathes(matches []monitor.EvalMatch) string

func (c *EvalContext) GetRuleTitle() string

func (c *EvalContext) GetStateModel() *StateDescription

func (ctx *EvalContext) ToTestRunResult() *monitor.AlertTestRunOutput

type Job ¶

type Job struct {
	Offset     int64
	OffsetWait bool
	Delay      bool

	Rule *Rule
	// contains filtered or unexported fields
}

Job holds state about when the alert rule should be evaluated.

func (j *Job) GetRunning() bool

func (j *Job) SetRunning(b bool)

type NotificationConfig ¶

type NotificationConfig notifydrivers.NotificationConfig

type Notifier ¶

type Notifier interface {
	notifydrivers.Notifier

	Notify(evalContext *EvalContext, params jsonutils.JSONObject) error

	// ShouldNotify checks this evaluation should send an alert notification
	ShouldNotify(ctx context.Context, evalContext *EvalContext, notificationState *models.SAlertnotification) bool
}

func InitNotifier(config NotificationConfig) (Notifier, error)

type NotifierFactory ¶

type NotifierFactory func(config NotificationConfig) (Notifier, error)

NotifierFactory is a signature for creating notifiers

type NotifierPlugin ¶

type NotifierPlugin struct {
	Type               string
	Factory            NotifierFactory
	ValidateCreateData func(cred mcclient.IIdentityProvider, input monitor.NotificationCreateInput) (monitor.NotificationCreateInput, error)
}

type Rule ¶

type Rule struct {
	Id                  string
	Frequency           int64
	Title               string
	Name                string
	Message             string
	LastStateChange     time.Time
	For                 time.Duration
	NoDataState         monitor.NoDataOption
	ExecutionErrorState monitor.ExecutionErrorOption
	State               monitor.AlertStateType
	Conditions          []Condition
	Notifications       []string
	// AlertRuleTags       []*models.AlertRuleTag
	Level           string
	RuleDescription []*RuleDescription

	StateChanges int

	CustomizeConfig jsonutils.JSONObject
	// 静默期
	SilentPeriod int64
}

Rule is the in-memory version of an alert rule.

func NewRuleFromDBAlert(ruleDef *models.SAlert) (*Rule, error)

type RuleDescription ¶

type RuleDescription struct {
	monitor.AlertRecordRule
}

type StateDescription ¶

type StateDescription struct {
	//Color string
	Text string
	Data string
}

SateDescription contains visual information about the alert state.

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