mirror of
https://github.com/grafana/grafana.git
synced 2025-02-16 18:34:52 -06:00
129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
package alerting
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/grafana/grafana/pkg/bus"
|
|
"github.com/grafana/grafana/pkg/log"
|
|
m "github.com/grafana/grafana/pkg/models"
|
|
)
|
|
|
|
type RootNotifier struct {
|
|
log log.Logger
|
|
}
|
|
|
|
func NewRootNotifier() *RootNotifier {
|
|
return &RootNotifier{
|
|
log: log.New("alerting.notifier"),
|
|
}
|
|
}
|
|
|
|
func (n *RootNotifier) GetType() string {
|
|
return "root"
|
|
}
|
|
|
|
func (n *RootNotifier) Notify(context *AlertResultContext) {
|
|
n.log.Info("Sending notifications for", "ruleId", context.Rule.Id)
|
|
|
|
notifiers, err := n.getNotifiers(context.Rule.OrgId, context.Rule.Notifications)
|
|
if err != nil {
|
|
n.log.Error("Failed to read notifications", "error", err)
|
|
return
|
|
}
|
|
|
|
for _, notifier := range notifiers {
|
|
n.log.Info("Sending notification", "firing", context.Firing, "type", notifier.GetType())
|
|
go notifier.Notify(context)
|
|
}
|
|
}
|
|
|
|
func (n *RootNotifier) getNotifiers(orgId int64, notificationIds []int64) ([]Notifier, error) {
|
|
query := &m.GetAlertNotificationsQuery{OrgId: orgId, Ids: notificationIds}
|
|
|
|
if err := bus.Dispatch(query); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result []Notifier
|
|
for _, notification := range query.Result {
|
|
if not, err := n.getNotifierFor(notification); err != nil {
|
|
return nil, err
|
|
} else {
|
|
result = append(result, not)
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (n *RootNotifier) getNotifierFor(model *m.AlertNotification) (Notifier, error) {
|
|
factory, found := notifierFactories[model.Type]
|
|
if !found {
|
|
return nil, errors.New("Unsupported notification type")
|
|
}
|
|
|
|
return factory(model)
|
|
// if model.Type == "email" {
|
|
// addressesString := model.Settings.Get("addresses").MustString()
|
|
//
|
|
// if addressesString == "" {
|
|
// return nil, fmt.Errorf("Could not find addresses in settings")
|
|
// }
|
|
//
|
|
// NotifierBase: NotifierBase{
|
|
// Name: model.Name,
|
|
// Type: model.Type,
|
|
// },
|
|
// Addresses: strings.Split(addressesString, "\n"),
|
|
// log: log.New("alerting.notification.email"),
|
|
// }, nil
|
|
// }
|
|
|
|
// url := settings.Get("url").MustString()
|
|
// if url == "" {
|
|
// return nil, fmt.Errorf("Could not find url propertie in settings")
|
|
// }
|
|
//
|
|
// return &WebhookNotifier{
|
|
// Url: url,
|
|
// User: settings.Get("user").MustString(),
|
|
// Password: settings.Get("password").MustString(),
|
|
// log: log.New("alerting.notification.webhook"),
|
|
// }, nil
|
|
}
|
|
|
|
// type WebhookNotifier struct {
|
|
// Url string
|
|
// User string
|
|
// Password string
|
|
// log log.Logger
|
|
// }
|
|
//
|
|
// func (this *WebhookNotifier) Dispatch(context *AlertResultContext) {
|
|
// this.log.Info("Sending webhook")
|
|
//
|
|
// bodyJSON := simplejson.New()
|
|
// bodyJSON.Set("name", context.AlertJob.Rule.Name)
|
|
// bodyJSON.Set("state", context.State)
|
|
// bodyJSON.Set("trigged", context.TriggeredAlerts)
|
|
//
|
|
// body, _ := bodyJSON.MarshalJSON()
|
|
//
|
|
// cmd := &m.SendWebhook{
|
|
// Url: this.Url,
|
|
// User: this.User,
|
|
// Password: this.Password,
|
|
// Body: string(body),
|
|
// }
|
|
//
|
|
// bus.Dispatch(cmd)
|
|
// }
|
|
|
|
type NotifierFactory func(notification *m.AlertNotification) (Notifier, error)
|
|
|
|
var notifierFactories map[string]NotifierFactory = make(map[string]NotifierFactory)
|
|
|
|
func RegisterNotifier(typeName string, factory NotifierFactory) {
|
|
notifierFactories[typeName] = factory
|
|
}
|