feat: Support list checks with alerts (#408)

* feat: Add ListCheckWithAlerts method to API client

* refactor: Move list checks to separate method

This allows having separate methods to list checks and list checks with
alerts based on the `include-alerts` flag.

* feat: Add support for check list include-alerts flag

Supports include-alerts flag for check list command which will retrieve
and output the list of checks along with their alerts.

Author: ka3de

cli/check.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	sm "github.com/grafana/synthetic-monitoring-agent/pkg/pb/synthetic_monitoring"
+	smapi "github.com/grafana/synthetic-monitoring-api-go-client"
 	"github.com/urfave/cli/v2"
 )
 
@@ -59,6 +60,14 @@ func GetCheckCommands(cc ChecksClient) cli.Commands {
 			Name:   "list",
 			Usage:  "list Synthetic Monitoring checks",
 			Action: cc.checkList,
+			Flags: []cli.Flag{
+				&cli.BoolFlag{
+					Name:     "include-alerts",
+					Usage:    "include alerts in the output",
+					Required: false,
+					Value:    false,
+				},
+			},
 		},
 		&cli.Command{
 			Name:   "get",
@@ -298,6 +307,14 @@ func (c ChecksClient) checkList(ctx *cli.Context) error {
 	}
 	defer func() { _ = cleanup(ctx.Context) }()
 
+	if includeAlerts := ctx.Bool("include-alerts"); includeAlerts {
+		return c.listAndPrintChecksWithAlerts(ctx, smClient)
+	}
+
+	return c.listAndPrintChecks(ctx, smClient)
+}
+
+func (c ChecksClient) listAndPrintChecks(ctx *cli.Context, smClient *smapi.Client) error {
 	checks, err := smClient.ListChecks(ctx.Context)
 	if err != nil {
 		return fmt.Errorf("listing checks: %w", err)
@@ -331,6 +348,46 @@ func (c ChecksClient) checkList(ctx *cli.Context) error {
 	return nil
 }
 
+func (c ChecksClient) listAndPrintChecksWithAlerts(ctx *cli.Context, smClient *smapi.Client) error {
+	checks, err := smClient.ListChecksWithAlerts(ctx.Context)
+	if err != nil {
+		return fmt.Errorf("listing checks: %w", err)
+	}
+
+	jsonWriter := c.JsonWriterBuilder(ctx)
+
+	if done, err := jsonWriter(checks, "marshaling checks"); err != nil || done {
+		return err
+	}
+
+	w := c.TabWriterBuilder(ctx)
+	fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", "id", "type", "job", "target", "enabled", "frequency", "timeout")
+	for _, check := range checks {
+		fmt.Fprintf(
+			w,
+			"%d\t%s\t%s\t%s\t%t\t%s\t%s\n",
+			check.Id,
+			check.Type(),
+			check.Job,
+			check.Target,
+			check.Enabled,
+			time.Duration(check.Frequency)*time.Millisecond,
+			time.Duration(check.Timeout)*time.Millisecond,
+		)
+		for i, alert := range check.Alerts {
+			if i == 0 {
+				fmt.Fprintf(w, "\t%s\t%s\t%s\t%s\t%s\t%s\n", "alert name", "alert threshold", "alert period", "alert runbook", "alert status", "alert error")
+			}
+			fmt.Fprintf(w, "\t%s\t%.2f\t%s\t%s\t%s\t%s\n", alert.Name, alert.Threshold, alert.Period, alert.RunbookUrl, alert.Status, alert.Error)
+		}
+	}
+	if err := w.Flush(); err != nil {
+		return fmt.Errorf("flushing output: %w", err)
+	}
+
+	return nil
+}
+
 func (c ChecksClient) checkGet(ctx *cli.Context) error {
 	smClient, cleanup, err := c.ClientBuilder(ctx)
 	if err != nil {

model/model.go

@@ -100,6 +100,11 @@ type CheckAlertWithStatus struct {
 	Error  string `json:"error,omitempty"`
 }
 
+type CheckWithAlerts struct {
+	synthetic_monitoring.Check
+	Alerts []CheckAlertWithStatus `json:"alerts"`
+}
+
 func (e *ResponseError) Error() string {
 	switch {
 	case e == nil:

smapi.go

@@ -505,6 +505,27 @@ func (h *Client) ListChecks(ctx context.Context) ([]synthetic_monitoring.Check,
 	return result, nil
 }
 
+// ListChecksWithAlerts returns the list of Synthetic Monitoring checks for the
+// authenticated tenant including check alerts.
+func (h *Client) ListChecksWithAlerts(ctx context.Context) ([]model.CheckWithAlerts, error) {
+	if err := h.requireAuthToken(); err != nil {
+		return nil, err
+	}
+
+	resp, err := h.Get(ctx, "/check/list?includeAlerts=true", true, nil)
+	if err != nil {
+		return nil, fmt.Errorf("sending check list request: %w", err)
+	}
+
+	var result []model.CheckWithAlerts
+
+	if err := ValidateResponse("check list request", resp, &result); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
 // QueryCheck returns a Synthetic Monitoring check for the
 // authenticated tenant that matches the job and target passed in.
 // Job and Target must be set to non empty strings.

smapi_test.go

@@ -1294,6 +1294,62 @@ func TestListChecks(t *testing.T) {
 	require.ElementsMatch(t, checks, actualChecks)
 }
 
+func TestListChecksWithAlerts(t *testing.T) {
+	orgs := orgs()
+	testTenant := orgs.findTenantByOrg(1000)
+	testTenantID := testTenant.id
+	checksWithAlerts := []model.CheckWithAlerts{
+		{
+			Check: synthetic_monitoring.Check{
+				Id:       42,
+				TenantId: testTenantID,
+			},
+			Alerts: []model.CheckAlertWithStatus{
+				{
+					CheckAlert: model.CheckAlert{
+						Name:       "Alert1",
+						Threshold:  100,
+						Period:     "1m",
+						RunbookUrl: "https://example.com/runbook/alert1",
+					},
+					Status: "OK",
+				},
+			},
+		},
+	}
+
+	url, mux, cleanup := newTestServer(t)
+	defer cleanup()
+	mux.Handle("/api/v1/check/list", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := requireMethod(w, r, http.MethodGet); err != nil {
+			return
+		}
+
+		if r.URL.Query().Get("includeAlerts") != "true" {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+
+		if _, err := requireAuth(orgs, w, r, testTenantID); err != nil {
+			return
+		}
+
+		resp := checksWithAlerts
+
+		writeResponse(w, http.StatusOK, &resp)
+	}))
+
+	c := NewClient(url, testTenant.token, http.DefaultClient)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	actualChecks, err := c.ListChecksWithAlerts(ctx)
+	require.NoError(t, err)
+	require.NotNil(t, actualChecks)
+	require.ElementsMatch(t, checksWithAlerts, actualChecks)
+}
+
 func TestQueryChecks(t *testing.T) {
 	orgs := orgs()
 	testTenant := orgs.findTenantByOrg(1000)