func (smsSender *twilioSenderSms) SendEvents(events notifier.EventsData, contact notifier.ContactData, trigger notifier.TriggerData, throttled bool) error {
var message bytes.Buffer
state := events.GetSubjectState()
tags := trigger.GetTags()
message.WriteString(fmt.Sprintf("%s %s %s (%d)\n\n", state, trigger.Name, tags, len(events)))
for _, event := range events {
value := strconv.FormatFloat(event.Value, 'f', -1, 64)
message.WriteString(fmt.Sprintf("%s: %s = %s (%s to %s)\n", time.Unix(event.Timestamp, 0).Format("15:04"), event.Metric, value, event.OldState, event.State))
}
if len(events) > 5 {
message.WriteString(fmt.Sprintf("\n...and %d more events.", len(events)-5))
}
if throttled {
message.WriteString("\nPlease, fix your system or tune this trigger to generate less events.")
}
smsSender.log.Debug("Calling twilio sms api to phone %s and message body %s", contact.Value, message.String())
twilioMessage, err := twilio.NewMessage(smsSender.client, smsSender.APIFromPhone, contact.Value, twilio.Body(message.String()))
if err != nil {
return fmt.Errorf("Failed to send message to contact %s: %s", contact.Value, err)
}
smsSender.log.Debug(fmt.Sprintf("message send to twilio with status: %s", twilioMessage.Status))
return nil
}
//SendEvents implements Sender interface Send
func (sender *Sender) SendEvents(events notifier.EventsData, contact notifier.ContactData, trigger notifier.TriggerData, throttled bool) error {
api := pushover.New(sender.APIToken)
recipient := pushover.NewRecipient(contact.Value)
subjectState := events.GetSubjectState()
title := fmt.Sprintf("%s %s %s (%d)", subjectState, trigger.Name, trigger.GetTags(), len(events))
timestamp := events[len(events)-1].Timestamp
var message string
priority := pushover.PriorityNormal
for i, event := range events {
if i > 4 {
break
}
if event.State == "ERROR" || event.State == "EXCEPTION" {
priority = pushover.PriorityEmergency
}
if priority != pushover.PriorityEmergency && (event.State == "WARN" || event.State == "NODATA") {
priority = pushover.PriorityHigh
}
value := strconv.FormatFloat(event.Value, 'f', -1, 64)
message += fmt.Sprintf("%s: %s = %s (%s to %s)\n", time.Unix(event.Timestamp, 0).Format("15:04"), event.Metric, value, event.OldState, event.State)
}
if len(events) > 5 {
message += fmt.Sprintf("\n...and %d more events.", len(events)-5)
}
if throttled {
message += "\nPlease, fix your system or tune this trigger to generate less events."
}
log.Debug("Calling pushover with message title %s, body %s", title, message)
pushoverMessage := &pushover.Message{
Message: message,
Title: title,
Priority: priority,
Retry: 5 * time.Minute,
Expire: time.Hour,
Timestamp: timestamp,
URL: fmt.Sprintf("%s/#/events/%s", sender.FrontURI, events[0].TriggerID),
}
_, err := api.SendMessage(pushoverMessage, recipient)
if err != nil {
return fmt.Errorf("Failed to send message to pushover user %s: %s", contact.Value, err.Error())
}
return nil
}
//SendEvents implements Sender interface Send
func (sender *Sender) SendEvents(events notifier.EventsData, contact notifier.ContactData, trigger notifier.TriggerData, throttled bool) error {
bot, err := tgbotapi.NewBotAPI(sender.APIToken)
if err != nil {
return fmt.Errorf("Failed to init telegram api: %s", err.Error())
}
var message bytes.Buffer
state := events.GetSubjectState()
tags := trigger.GetTags()
message.WriteString(fmt.Sprintf("%s %s %s (%d)\n\n", state, trigger.Name, tags, len(events)))
for _, event := range events {
value := strconv.FormatFloat(event.Value, 'f', -1, 64)
message.WriteString(fmt.Sprintf("%s: %s = %s (%s to %s)\n", time.Unix(event.Timestamp, 0).Format("15:04"), event.Metric, value, event.OldState, event.State))
}
if len(events) > 5 {
message.WriteString(fmt.Sprintf("\n...and %d more events.", len(events)-5))
}
if throttled {
message.WriteString("\nPlease, fix your system or tune this trigger to generate less events.")
}
log.Debug("Calling telegram api with chat_id %s and message body %s", contact.Value, message)
telegramParams := url.Values{}
telegramParams.Set("chat_id", contact.Value)
telegramParams.Set("text", message.String())
telegramParams.Set("disable_web_page_preview", "true")
_, err = bot.MakeRequest("sendMessage", telegramParams)
if err != nil {
return fmt.Errorf("Failed to send message to telegram contact %s: %s", contact.Value, err.Error())
}
return nil
}
// MakeMessage prepare message to send
func (sender *Sender) MakeMessage(events notifier.EventsData, contact notifier.ContactData, trigger notifier.TriggerData, throttled bool) *gomail.Message {
state := events.GetSubjectState()
tags := trigger.GetTags()
subject := fmt.Sprintf("%s %s %s (%d)", state, trigger.Name, tags, len(events))
templateData := struct {
Link string
Throttled bool
Items []*templateRow
}{
Link: fmt.Sprintf("%s/#/events/%s", sender.FrontURI, events[0].TriggerID),
Throttled: throttled,
Items: make([]*templateRow, 0, len(events)),
}
for _, event := range events {
templateData.Items = append(templateData.Items, &templateRow{
Metric: event.Metric,
Timestamp: time.Unix(event.Timestamp, 0).Format("15:04 02.01.2006"),
Oldstate: event.OldState,
State: event.State,
Value: strconv.FormatFloat(event.Value, 'f', -1, 64),
WarnValue: strconv.FormatFloat(trigger.WarnValue, 'f', -1, 64),
ErrorValue: strconv.FormatFloat(trigger.ErrorValue, 'f', -1, 64),
})
}
m := gomail.NewMessage()
m.SetHeader("From", sender.From)
m.SetHeader("To", contact.Value)
m.SetHeader("Subject", subject)
m.AddAlternativeWriter("text/html", func(w io.Writer) error {
return tpl.Execute(w, templateData)
})
return m
}
//SendEvents implements Sender interface Send
func (sender *Sender) SendEvents(events notifier.EventsData, contact notifier.ContactData, trigger notifier.TriggerData, throttled bool) error {
api := slack.New(sender.APIToken)
var message bytes.Buffer
state := events.GetSubjectState()
tags := trigger.GetTags()
message.WriteString(fmt.Sprintf("*%s* %s <%s/#/events/%s|%s>\n```", state, tags, sender.FrontURI, events[0].TriggerID, trigger.Name))
icon := fmt.Sprintf("%s/public/fav72_ok.png", sender.FrontURI)
for _, event := range events {
if event.State != "OK" {
icon = fmt.Sprintf("%s/public/fav72_error.png", sender.FrontURI)
}
value := strconv.FormatFloat(event.Value, 'f', -1, 64)
message.WriteString(fmt.Sprintf("\n%s: %s = %s (%s to %s)", time.Unix(event.Timestamp, 0).Format("15:04"), event.Metric, value, event.OldState, event.State))
}
message.WriteString("```")
if throttled {
message.WriteString("\nPlease, *fix your system or tune this trigger* to generate less events.")
}
log.Debug("Calling slack with message body %s", message)
params := slack.PostMessageParameters{
Username: "******",
IconURL: icon,
}
channelID, _, err := api.PostMessage(contact.Value, message.String(), params)
if err != nil {
return fmt.Errorf("Failed to send message to slack channel %s: %s", channelID, err.Error())
}
return nil
}