Initial commit

Author: jayme-github

.gitignore

@@ -0,0 +1,2 @@
+alertmanager-webhook-fcm
+serviceAccountKey.json

LICENSE

@@ -0,0 +1,2 @@
+# alertmanager-webhook-fcm
+Prometheus Alertmanager receiver that sends messages via Firebase Cloud Messaging

README.md

@@ -0,0 +1,102 @@
+package main
+
+import (
+"bytes"
+"fmt"
+"strings"
+tmpltext "text/template"
+
+"github.com/prometheus/alertmanager/template"
+"golang.org/x/net/context"
+
+firebase "firebase.google.com/go"
+"firebase.google.com/go/messaging"
+)
+
+const (
+titleTemplate = `{{- if eq .Status "resolved"}}[Resolved] {{ end -}}
+{{ .CommonLabels.job }} {{ .CommonLabels.alertname }}`
+bodyTemplate = `{{- $lastsummary := "" -}}
+{{- range $alert := .Alerts -}}
+ {{- if not (eq $lastsummary $alert.Annotations.summary) }}
+ - {{ $alert.Annotations.summary -}}
+ {{- $lastsummary = $alert.Annotations.summary -}}
+ {{- end -}}
+{{- end }}`
+)
+
+var (
+tmplTitle *tmpltext.Template
+tmplBody *tmpltext.Template
+)
+
+func init() {
+tmplTitle = tmpltext.Must(tmpltext.New("title").Option("missingkey=zero").Parse(titleTemplate))
+tmplBody = tmpltext.Must(tmpltext.New("body").Option("missingkey=zero").Parse(bodyTemplate))
+}
+
+type TemplateError struct {
+Type string
+Err error
+}
+
+func (e *TemplateError) Error() string {
+return fmt.Sprintf("%s expansion failed: %v", strings.Title(e.Type), e.Err)
+}
+
+// NewMessaging returns a messaging client
+func NewMessaging() (*messaging.Client, error) {
+ctx := context.Background()
+app, err := firebase.NewApp(context.Background(), nil)
+if err != nil {
+return nil, err
+}
+
+client, err := app.Messaging(ctx)
+if err != nil {
+return nil, err
+}
+return client, err
+}
+
+// NewMessage returns a new message struct
+func NewMessage(title, body string) *messaging.Message {
+return &messaging.Message{
+Notification: &messaging.Notification{
+Title: title,
+Body: body,
+},
+Data: map[string]string{
+"title": title,
+"body": body,
+"click_action": "FLUTTER_NOTIFICATION_CLICK",
+},
+Topic: "all",
+// https://firebase.google.com/docs/cloud-messaging/concept-options#setting-the-priority-of-a-message
+Android: &messaging.AndroidConfig{
+Priority: "high",
+},
+}
+}
+
+func NewMessageFromAlertmanagerData(m *template.Data) (*messaging.Message, error) {
+title, err := tmpltextExecuteToString(tmplTitle, m)
+if err != nil {
+return nil, &TemplateError{Type: "title", Err: err}
+}
+
+body, err := tmpltextExecuteToString(tmplBody, m)
+if err != nil {
+return nil, &TemplateError{Type: "body", Err: err}
+}
+
+return NewMessage(title, body), nil
+}
+
+func tmpltextExecuteToString(tmpl *tmpltext.Template, data interface{}) (string, error) {
+var buff bytes.Buffer
+if err := tmpl.Execute(&buff, data); err != nil {
+return "", err
+}
+return buff.String(), nil
+}

fcm.go

@@ -0,0 +1,12 @@
+module github.com/jayme-github/alertmanager-webhook-fcm
+
+go 1.14
+
+require (
+cloud.google.com/go/firestore v1.2.0 // indirect
+firebase.google.com/go v3.13.0+incompatible
+github.com/prometheus/alertmanager v0.20.0
+github.com/prometheus/client_golang v1.6.0
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9
+google.golang.org/api v0.26.0 // indirect
+)

go.mod

@@ -0,0 +1,87 @@
+package main
+
+import (
+"context"
+"encoding/json"
+"fmt"
+"log"
+"net/http"
+"strconv"
+
+"github.com/prometheus/alertmanager/template"
+)
+
+// JSONResponse is the standard response struct
+type JSONResponse struct {
+Status int
+Message string
+}
+
+func genericHandler(w http.ResponseWriter, req *http.Request) {
+// TODO: Allow to post title and message
+message := NewMessage("Test message", "A test message body")
+msg, err := fcmClient.Send(req.Context(), message)
+if err != nil {
+fcmErrors.Inc()
+sendJSONResponse(w, req, http.StatusInternalServerError, err.Error())
+return
+}
+sendJSONResponse(w, req, http.StatusOK, fmt.Sprintf("Message delivered: %s", msg))
+}
+
+func alertHandler(w http.ResponseWriter, req *http.Request) {
+templateData, err := readRequestBody(req)
+if err != nil {
+log.Printf("Error parsing request body: %v", err)
+sendJSONResponse(w, req, http.StatusBadRequest, err.Error())
+return
+}
+
+msg, err := processFcmMessage(req.Context(), templateData)
+
+if err != nil {
+log.Printf("Error sending fcm message: %v", err)
+sendJSONResponse(w, req, http.StatusInternalServerError, err.Error())
+return
+}
+
+sendJSONResponse(w, req, http.StatusOK, fmt.Sprintf("Message delivered: %s", msg))
+}
+
+func readRequestBody(req *http.Request) (*template.Data, error) {
+defer req.Body.Close()
+data := template.Data{}
+err := json.NewDecoder(req.Body).Decode(&data)
+return &data, err
+}
+
+func processFcmMessage(ctx context.Context, m *template.Data) (string, error) {
+message, err := NewMessageFromAlertmanagerData(m)
+if err != nil {
+te, _ := err.(*TemplateError)
+templateErrors.WithLabelValues(te.Type).Inc()
+return "", err
+}
+
+// Send a message to the devices subscribed to the topic.
+fcmResponse, err := fcmClient.Send(ctx, message)
+if err != nil {
+fcmErrors.Inc()
+}
+return fcmResponse, err
+}
+
+func sendJSONResponse(w http.ResponseWriter, req *http.Request, statusCode int, message string) {
+webhookRequests.WithLabelValues(req.Method, req.URL.Path, strconv.Itoa(statusCode)).Inc()
+
+response, _ := json.Marshal(JSONResponse{
+Status: statusCode,
+Message: message,
+})
+w.WriteHeader(statusCode)
+_, err := w.Write(response)
+
+if err != nil {
+log.Printf("Error sending response to client: %v", err)
+}
+}

go.sum

@@ -0,0 +1,54 @@
+package main
+
+import (
+"flag"
+"log"
+"net/http"
+
+"firebase.google.com/go/messaging"
+"github.com/prometheus/client_golang/prometheus"
+"github.com/prometheus/client_golang/prometheus/promauto"
+"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+var (
+flagListen = flag.String("listen", ":9716", "[ip]:port to listen on for HTTP")
+fcmClient *messaging.Client
+
+webhookRequests = promauto.NewCounterVec(
+prometheus.CounterOpts{
+Name: "alertmanager_webhook_requests_total",
+Help: "Total number of HTTP requests.",
+},
+[]string{"method", "handler", "status"},
+)
+templateErrors = promauto.NewCounterVec(
+prometheus.CounterOpts{
+Name: "alertmanager_webhook_template_errors_total",
+Help: "Total number of errors executing message templates.",
+},
+[]string{"type"},
+)
+fcmErrors = promauto.NewCounter(
+prometheus.CounterOpts{
+Name: "alertmanager_webhook_fcm_errors_total",
+Help: "Total number of errors talking to Firebase Cloud Messaging API.",
+},
+)
+)
+
+func main() {
+var err error
+flag.Parse()
+
+fcmClient, err = NewMessaging()
+if err != nil {
+log.Fatalf("error getting Messaging client. Do you have GOOGLE_APPLICATION_CREDENTIALS set?: %v\n", err)
+}
+
+http.HandleFunc("/alert", alertHandler)
+http.HandleFunc("/generic", genericHandler)
+http.Handle("/metrics", promhttp.Handler())
+log.Printf("Listeing on: %s\n", *flagListen)
+log.Fatal(http.ListenAndServe(*flagListen, nil))
+}