Add support for updating tags on Alerts and Dashboards

[nathmclean]

Tags can be created on Alerts and Dashboards, but cannot be updated (you can change the values in the struct, but the API won't apply them)

There are additional endpoints for managing tags after Alerts and Dashboards have been created

POST /api/v2/{resource}/{id}/tag Set all tags associated with a specific dashboard
DELETE /api/v2/{resource}/{id}/tag/{tagValue} Remove a tag from a specific dashboard
PUT /api/v2/{resource}/{id}/tag/{tagValue}

[asobti]

I don't think this is an issue. I verified this with alerts and it works correctly.

Verification script:

package main

import (
	"fmt"
	"github.com/spaceapegames/go-wavefront"
	"time"
)

func create(alertClient *wavefront.Alerts) (*wavefront.Alert, error) {
	a := &wavefront.Alert{
		Name: "test alert",
		Target: "ayush@example.com",
		Condition: "ts(proc.stat.cpu, dc=local) > 100",
		DisplayExpression: "ts(proc.stat.cpu, dc=local)",
		Minutes: 2,
		Tags: []string{"test", "go-wavefront"},
		Severity: "INFO",
	}

	err := alertClient.Create(a)
	if err != nil {
		return nil, err
	}

	return a, nil
}

func get(alertClient *wavefront.Alerts, id string) (*wavefront.Alert, error) {
	a := &wavefront.Alert{
		ID: &id,
	}

	err := alertClient.Get(a)
	if err != nil {
		return nil, err
	}

	return a, nil
}

func update(alertClient *wavefront.Alerts, alert *wavefront.Alert) error {
	err := alertClient.Update(alert)
	if err != nil {
		return err
	}

	return nil
}

func main() {
	config := &wavefront.Config{
		Address: "test.wavefront.com",
		Token: "xxx-xxx-xxx-xxx",
	}

	client, err := wavefront.NewClient(config)
	if err != nil {
		panic(err)
	}

	alerts := client.Alerts()

	// Begin by creating a new alert with 2 tags
	a, err := create(alerts)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Created alert with id %s\n", *a.ID)

	if len(a.Tags) != 2 {
		panic(
			fmt.Sprintf("Expected 2 tags but found %d. Tags: %v.\n",
				len(a.Tags), a.Tags))
	}

	// Append a tag
	a.Tags = append(a.Tags, "appended-tag")

	err = update(alerts, a)
	if err != nil {
		panic(err)
	}

	fmt.Println("Updated alert")

	// Sleep for a little bit so WF can index the new alert
	// If we try to fetch too soon after creating, we can
	// get a 404
	fmt.Println("Waiting for 30s now...")
	time.Sleep(30 * time.Second)

	// fetch the alert again and check tags
	finalAlert, err := get(alerts, *a.ID)
	if err != nil {
		panic(err)
	}

	if len(finalAlert.Tags) != 3 {
		panic(
			fmt.Sprintf("Expected 3 tags but found %d. Tags: %v.\n",
				len(finalAlert.Tags), finalAlert.Tags))
	}

	fmt.Printf("Found tags: %v\n", finalAlert.Tags)
}

Output

$ ./test-update-tags          
Created alert with id 1543955757847
Updated alert
Waiting for 30s now...
Found tags: [appended-tag go-wavefront test]