Amtool implementation

.gitignore

@@ -1,5 +1,6 @@
 /data/
 /alertmanager
+/amtool
 *.yml
 *.yaml
 /.build

.promu.yml

@@ -4,6 +4,8 @@ build:
     binaries:
         - name: alertmanager
           path: ./cmd/alertmanager
+        - name: amtool
+          path: ./cmd/amtool
     flags: -a -tags netgo
     ldflags: |
         -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}}

artifacts/README.md

@@ -0,0 +1,18 @@
+# Generating amtool artifacts
+
+Amtool comes with the option to create a number of eaze-of-use artifacts that can be created.
+
+    go run generate_amtool_artifacts.go
+
+## Bash completion
+
+The bash completion file can be added to `/etc/bash_completion.d/`.
+
+## Man pages
+
+Man pages can be added to the man directory of your choice
+
+    cp artifacts/*.1 /usr/local/share/man/man1/
+    sudo mandb
+
+Then you should be able to view the man pages as expected.

artifacts/generate_amtool_artifacts.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"github.com/spf13/cobra/doc"
+
+	"github.com/prometheus/alertmanager/cli"
+)
+
+func main() {
+	cli.RootCmd.GenBashCompletionFile("amtool_completion.sh")
+	header := &doc.GenManHeader{
+		Title:   "amtool",
+		Section: "1",
+	}
+
+	doc.GenManTree(cli.RootCmd, header, ".")
+}

cli/alert.go

@@ -0,0 +1,173 @@
+package cli
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/prometheus/alertmanager/cli/format"
+	"github.com/prometheus/alertmanager/dispatch"
+	"github.com/prometheus/alertmanager/pkg/parse"
+	"github.com/prometheus/common/model"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type alertmanagerAlertResponse struct {
+	Status    string        `json:"status"`
+	Data      []*alertGroup `json:"data,omitempty"`
+	ErrorType string        `json:"errorType,omitempty"`
+	Error     string        `json:"error,omitempty"`
+}
+
+type alertGroup struct {
+	Labels   model.LabelSet `json:"labels"`
+	GroupKey uint64         `json:"groupKey"`
+	Blocks   []*alertBlock  `json:"blocks"`
+}
+
+type alertBlock struct {
+	RouteOpts interface{}          `json:"routeOpts"`
+	Alerts    []*dispatch.APIAlert `json:"alerts"`
+}
+
+// alertCmd represents the alert command
+var alertCmd = &cobra.Command{
+	Use:   "alert",
+	Short: "View and search through current alerts",
+	Long: `View and search through current alerts.
+
+  Amtool has a simplified prometheus query syntax, but contains robust support for
+  bash variable expansions. The non-option section of arguments constructs a list
+  of "Matcher Groups" that will be used to filter your query. The following
+  examples will attempt to show this behaviour in action:
+
+  amtool alert query alertname=foo node=bar
+
+  	This query will match all alerts with the alertname=foo and node=bar label
+  	value pairs set.
+
+  amtool alert query foo node=bar
+
+  	If alertname is ommited and the first argument does not contain a '=' or a
+  	'=~' then it will be assumed to be the value of the alertname pair.
+
+  amtool alert query 'alertname=~foo.*'
+
+  	As well as direct equality, regex matching is also supported. The '=~' syntax
+  	(similar to prometheus) is used to represent a regex match. Regex matching
+  	can be used in combination with a direct match.
+	`,
+	RunE: queryAlerts,
+}
+
+var alertQueryCmd = &cobra.Command{
+	Use:   "query",
+	Short: "View and search through current alerts",
+	Long:  alertCmd.Long,
+	RunE:  queryAlerts,
+}
+
+func init() {
+	RootCmd.AddCommand(alertCmd)
+	alertCmd.AddCommand(alertQueryCmd)
+	alertQueryCmd.Flags().Bool("expired", false, "Show expired alerts as well as active")
+	alertQueryCmd.Flags().BoolP("silenced", "s", false, "Show silenced alerts")
+	viper.BindPFlag("expired", alertQueryCmd.Flags().Lookup("expired"))
+	viper.BindPFlag("silenced", alertQueryCmd.Flags().Lookup("silenced"))
+}
+
+func fetchAlerts(filter string) ([]*dispatch.APIAlert, error) {
+	alertResponse := alertmanagerAlertResponse{}
+
+	u, err := GetAlertmanagerURL()
+	if err != nil {
+		return []*dispatch.APIAlert{}, err
+	}
+
+	u.Path = path.Join(u.Path, "/api/v1/alerts/groups")
+	u.RawQuery = "filter=" + url.QueryEscape(filter)
+
+	res, err := http.Get(u.String())
+	if err != nil {
+		return []*dispatch.APIAlert{}, err
+	}
+
+	defer res.Body.Close()
+
+	err = json.NewDecoder(res.Body).Decode(&alertResponse)
+	if err != nil {
+		return []*dispatch.APIAlert{}, errors.New("Unable to decode json response")
+	}
+
+	if alertResponse.Status != "success" {
+		return []*dispatch.APIAlert{}, fmt.Errorf("[%s] %s", alertResponse.ErrorType, alertResponse.Error)
+	}
+
+	return flattenAlertOverview(alertResponse.Data), nil
+}
+
+func flattenAlertOverview(overview []*alertGroup) []*dispatch.APIAlert {
+	alerts := []*dispatch.APIAlert{}
+	for _, group := range overview {
+		for _, block := range group.Blocks {
+			alerts = append(alerts, block.Alerts...)
+		}
+	}
+	return alerts
+}
+
+func queryAlerts(cmd *cobra.Command, args []string) error {
+	expired := viper.GetBool("expired")
+	showSilenced := viper.GetBool("silenced")
+
+	var filterString = ""
+	if len(args) == 1 {
+		// If we only have one argument then it's possible that the user wants me to assume alertname=<arg>
+		// Attempt to use the parser to pare the argument
+		// If the parser fails then we likely don't have a (=|=~|!=|!~) so lets prepend `alertname=` to the front
+		_, err := parse.Matcher(args[0])
+		if err != nil {
+			filterString = fmt.Sprintf("{alertname=%s}", args[0])
+		} else {
+			filterString = fmt.Sprintf("{%s}", strings.Join(args, ","))
+		}
+	} else if len(args) > 1 {
+		filterString = fmt.Sprintf("{%s}", strings.Join(args, ","))
+	}
+
+	fetchedAlerts, err := fetchAlerts(filterString)
+	if err != nil {
+		return err
+	}
+
+	displayAlerts := []*dispatch.APIAlert{}
+	for _, alert := range fetchedAlerts {
+		// If we are only returning current alerts and this one has already expired skip it
+		if !expired {
+			if !alert.EndsAt.IsZero() && alert.EndsAt.Before(time.Now()) {
+				continue
+			}
+		}
+
+		if !showSilenced {
+			// If any silence mutes this alert don't show it
+			if alert.Silenced != "" {
+				continue
+			}
+		}
+
+		displayAlerts = append(displayAlerts, alert)
+	}
+
+	formatter, found := format.Formatters[viper.GetString("output")]
+	if !found {
+		return errors.New("Unknown output formatter")
+	}
+	return formatter.FormatAlerts(displayAlerts)
+}

cli/config.go

@@ -0,0 +1,106 @@
+package cli
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+
+	"github.com/prometheus/alertmanager/cli/format"
+	"github.com/prometheus/alertmanager/config"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Config is the response type of alertmanager config endpoint
+// Duped in cli/format needs to be moved to common/model
+type Config struct {
+	Config      string                 `json:"config"`
+	ConfigJSON  config.Config          `json:configJSON`
+	MeshStatus  map[string]interface{} `json:"meshStatus"`
+	VersionInfo map[string]string      `json:"versionInfo"`
+	Uptime      time.Time              `json:"uptime"`
+}
+
+type MeshStatus struct {
+	Name     string       `json:"name"`
+	NickName string       `json:"nickName"`
+	Peers    []PeerStatus `json:"peerStatus"`
+}
+
+type PeerStatus struct {
+	Name     string `json:"name"`
+	NickName string `json:"nickName"`
+	UID      uint64 `uid`
+}
+
+type alertmanagerStatusResponse struct {
+	Status    string `json:"status"`
+	Data      Config `json:"data,omitempty"`
+	ErrorType string `json:"errorType,omitempty"`
+	Error     string `json:"error,omitempty"`
+}
+
+// alertCmd represents the alert command
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "View the running config",
+	Long: `View current config
+
+The amount of output is controlled by the output selection flag:
+	- Simple: Print just the running config
+	- Extended: Print the running config as well as uptime and all version info
+	- Json: Print entire config object as json`,
+	RunE: queryConfig,
+}
+
+func init() {
+	RootCmd.AddCommand(configCmd)
+}
+
+func fetchConfig() (Config, error) {
+	configResponse := alertmanagerStatusResponse{}
+	u, err := GetAlertmanagerURL()
+	if err != nil {
+		return Config{}, err
+	}
+
+	u.Path = path.Join(u.Path, "/api/v1/status")
+	res, err := http.Get(u.String())
+	if err != nil {
+		return Config{}, err
+	}
+
+	defer res.Body.Close()
+	decoder := json.NewDecoder(res.Body)
+
+	err = decoder.Decode(&configResponse)
+	if err != nil {
+		panic(err)
+		return Config{}, err
+	}
+
+	if configResponse.Status != "success" {
+		return Config{}, fmt.Errorf("[%s] %s", configResponse.ErrorType, configResponse.Error)
+	}
+
+	return configResponse.Data, nil
+}
+
+func queryConfig(cmd *cobra.Command, args []string) error {
+	config, err := fetchConfig()
+	if err != nil {
+		return err
+	}
+
+	formatter, found := format.Formatters[viper.GetString("output")]
+	if !found {
+		return errors.New("Unknown output formatter")
+	}
+
+	c := format.Config(config)
+
+	return formatter.FormatConfig(c)
+}

cli/format/format.go

@@ -0,0 +1,51 @@
+package format
+
+import (
+	"io"
+	"time"
+
+	"github.com/prometheus/alertmanager/config"
+	"github.com/prometheus/alertmanager/dispatch"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/spf13/viper"
+)
+
+const DefaultDateFormat = "2006-01-02 15:04:05 MST"
+
+// Config representation
+// Need to get this moved to the prometheus/common/model repo having is duplicated here is smelly
+type Config struct {
+	Config      string                 `json:"config"`
+	ConfigJSON  config.Config          `json:configJSON`
+	MeshStatus  map[string]interface{} `json:"meshStatus"`
+	VersionInfo map[string]string      `json:"versionInfo"`
+	Uptime      time.Time              `json:"uptime"`
+}
+
+type MeshStatus struct {
+	Name     string       `json:"name"`
+	NickName string       `json:"nickName"`
+	Peers    []PeerStatus `json:"peerStatus"`
+}
+
+type PeerStatus struct {
+	Name     string `json:"name"`
+	NickName string `json:"nickName"`
+	UID      uint64 `uid`
+}
+
+// Formatter needs to be implemented for each new output formatter
+type Formatter interface {
+	SetOutput(io.Writer)
+	FormatSilences([]types.Silence) error
+	FormatAlerts([]*dispatch.APIAlert) error
+	FormatConfig(Config) error
+}
+
+// Formatters is a map of cli argument name to formatter inferface object
+var Formatters map[string]Formatter = map[string]Formatter{}
+
+func FormatDate(input time.Time) string {
+	dateformat := viper.GetString("date.format")
+	return input.Format(dateformat)
+}