Script to cleanup ec2 instances from newrelic

newrelic.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"sort"
	"strings"
	"time"

	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ec2"
)

type ServerEntry struct {
	ID             int64      `json:"id"`
	Host           string     `json:"host"`
	Reporting      bool       `json:"reporting"`
	LastReportedAt *time.Time `json:"last_reported_at"`
	Seen           bool
}

type byLastReported []*ServerEntry

func (a byLastReported) Len() int           { return len(a) }
func (a byLastReported) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byLastReported) Less(i, j int) bool { return a[i].LastReportedAt.Before(*a[j].LastReportedAt) }

type ServerList struct {
	Servers []*ServerEntry `json:"servers"`
}

func failOnError(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

func getDeadServers() (byLastReported, error) {
	req, err := http.NewRequest("GET", "https://api.newrelic.com/v2/servers.json", nil)
	if err != nil {
		return nil, err
	}

	req.Header.Set("X-Api-Key", os.Getenv("APIKEY"))

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}

	defer resp.Body.Close()

	servers := &ServerList{}
	if err := json.NewDecoder(resp.Body).Decode(servers); err != nil {
		return nil, err
	}

	dead := make([]*ServerEntry, 0, len(servers.Servers))
	for _, server := range servers.Servers {
		if server.Reporting {
			continue
		}
		server.Seen = false
		dead = append(dead, server)
	}

	sort.Sort(byLastReported(dead))
	return dead, nil
}

func main() {
	seen := make(map[string]bool)
	ec2client := ec2.New(session.New())
	err := ec2client.DescribeInstancesPages(nil, func(page *ec2.DescribeInstancesOutput, lastPage bool) bool {
		for _, reservation := range page.Reservations {
			for _, instance := range reservation.Instances {
				if instance.PrivateDnsName != nil {
					parts := strings.Split(*instance.PrivateDnsName, ".")
					seen[parts[0]] = true
				}
			}
		}

		return !lastPage
	})
	failOnError(err)

	now := time.Now()
	dead, err := getDeadServers()
	failOnError(err)

	for _, server := range dead {
		if _, ok := seen[server.Host]; ok {
			log.Printf("problem with %s\n", server.Host)
			continue
		}

		log.Printf("removing: %d - %s : %v\n", server.ID, server.Host, now.Sub(*server.LastReportedAt))

		req, err := http.NewRequest("DELETE", fmt.Sprintf("https://api.newrelic.com/v2/servers/%d.json", server.ID), nil)
		failOnError(err)

		req.Header.Set("X-Api-Key", os.Getenv("APIKEY"))

		resp, err := http.DefaultClient.Do(req)
		failOnError(err)
		resp.Body.Close()
	}

}