Alertmanager alarm tester. Fire a custom alert to your alertmanager: https://github.com/prometheus/alertmanager

amfirer.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"time"
)

const (
	// alertmanager alerts api path.
	amAPIPath = "api/v1/alerts"
)

var (
	// label regular expression.
	labelRgx = regexp.MustCompile("[^=]+=[^=]+")
)

// labelMap is the type to pass multiple labels as flags.
type labelMap map[string]string

// String implements flag.Value interface.
func (l *labelMap) String() string {
	return fmt.Sprintf("%v", *l)
}

// Set implements flag.Value interface.
func (l *labelMap) Set(value string) error {
	// Check label.
	if !labelRgx.Match([]byte(value)) {
		return fmt.Errorf("label %s is not in key value format of 'xxx=yyyy'", value)
	}

	// set the label.
	spl := strings.Split(value, "=")
	(*l)[spl[0]] = spl[1] // We tust our regexp

	return nil
}

// Parses a url to check if it's correct and sets the alertmanagers alerts API path.
func parseURL(checkURL string) (*url.URL, error) {
	// Check if is a valid url.
	amURL, err := url.ParseRequestURI(checkURL)
	if err != nil {
		return nil, fmt.Errorf("wrong alertmanager url: %s", checkURL)
	}
	amURL.Path = amAPIPath
	return amURL, nil
}

// amFirer fires alerts to alertmanager.
type amFirer struct {
	amURL *url.URL // amURL is the alertmanager url.
}

// fire fires an alert.
func (a *amFirer) fire(alertName string, labels map[string]string) error {
	// Add the alertname.
	labels["alertname"] = alertName

	// Create the alarm body.
	value := []struct {
		Status string            `json:"status"`
		Labels map[string]string `json:"labels"`
	}{
		{
			Status: "firing",
			Labels: labels,
		},
	}
	body, err := json.Marshal(&value)
	if err != nil {
		return fmt.Errorf("error generating alert body: %s", err)
	}

	// Send the alarm.
	if _, err := http.Post(a.amURL.String(), "application/json", bytes.NewBuffer(body)); err != nil {
		return fmt.Errorf("failed seding the alert: %v", err)
	}
	return nil
}

// main will trigger a new alarm on the desired alertmanager, this could be used with test purpouses
// or a quick & easy way of manualy triggering an alarm. (https://github.com/prometheus/alertmanager)
// build:
//	go build -o amfirer amfirer.go
// Usage examples:
// 	amfirer -l severity="warning"
// 	amfirer -l email="true" -address="http://alerts.mycompany.io"
//	amfirer -l label_team="team-marketplace" -l severity="pager" -alertname="ClusterIsOnFireOMG"
func main() {
	// flags stuff.
	var (
		amAddr    string
		labels    = labelMap{}
		alertName string
	)

	defAlertName := fmt.Sprintf("test_%d", time.Now().UTC().Unix())
	flag.StringVar(&amAddr, "address", "http://127.0.0.1:9093", "alertmanager address")
	flag.Var(&labels, "l", "label for the alert in key value format: 'xxx=yyy'")
	flag.StringVar(&alertName, "alertname", defAlertName, "the name of the alert")
	flag.Parse()

	// Set correct url.
	amURL, error := parseURL(amAddr)
	if error != nil {
		log.Fatalf("[ERROR] error parsing alertmanager url: %v", error)
	}

	f := &amFirer{amURL: amURL}

	// Fire the alert.
	if err := f.fire(alertName, map[string]string(labels)); err != nil {
		log.Fatalf("[ERROR] error firing the alert: %v", err)
	}

	log.Printf("[OK] Alert %s sent to %s", alertName, f.amURL.String())
}

Thanks for the info @till! I did this a long time ago 😅