feat(newrelic): APM application id can be looked up by name

This is intended to be a quality of life addition to allow
`ApplicationSet` resources to minimize boilerplate when dealing with
NewRelic APM resources across multiple environments.
- An application programmatically [uses the NR SDK to report to
  NewRelic](https://github.com/newrelic/go-agent/blob/master/v3/examples/server/main.go#L267-L274)
- NewRelic APM Application ID has to then be retrieved following the
  first run of an application from the NR Dashboard and added to an
  ArgoCD `Application` via the annotation, across multiple environments.
Using ArgoCD `ApplicationSet` resources, the annotation can be either
provided via app_id, or by name, e.g. `MyApp-{{ .values.env }}`
If `dest.Recipient` can be parsed to an int, then app_id is provided
and logic remains as before.
If `dest.Recipient` cannot be parsed to an integer, then it was passed
by name and we call `/v2/applications.json` to query using
`filter[name]`
If `/v2/applications.json` returns multiple application IDs then an
error is returned, as we can't determine which app_id to use to place
the deployment marker.

Signed-off-by: 3bbbeau <[email protected]>

Author: 3bbbeau

pkg/services/newrelic.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"strconv"
 	"strings"
 	texttemplate "text/template"
 
@@ -29,8 +30,10 @@ type NewrelicNotification struct {
 }
 
 var (
-	ErrMissingConfig = errors.New("config is missing")
-	ErrMissingApiKey = errors.New("apiKey is missing")
+	ErrMissingConfig        = errors.New("config is missing")
+	ErrMissingApiKey        = errors.New("apiKey is missing")
+	ErrAppIdMultipleMatches = errors.New("multiple matches found for application name")
+	ErrAppIdNoMatches       = errors.New("no matches found for application name")
 )
 
 func (n *NewrelicNotification) GetTemplater(name string, f texttemplate.FuncMap) (Templater, error) {
@@ -116,6 +119,43 @@ type newrelicService struct {
 type newrelicDeploymentMarkerRequest struct {
 	Deployment NewrelicNotification `json:"deployment"`
 }
+type newrelicApplicationsResponse struct {
+	Applications []struct {
+		ID json.Number `json:"id"`
+	} `json:"applications"`
+}
+
+func (s newrelicService) getApplicationId(client *http.Client, appName string) (string, error) {
+	applicationsApi := fmt.Sprintf("%s/v2/applications.json?filter[name]=%s", s.opts.ApiURL, appName)
+	req, err := http.NewRequest(http.MethodGet, applicationsApi, nil)
+	if err != nil {
+		return "", fmt.Errorf("Failed to create filtered application request: %s", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Api-Key", s.opts.ApiKey)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	var data newrelicApplicationsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return "", fmt.Errorf("Failed to decode applications response: %s", err)
+	}
+
+	if len(data.Applications) == 0 {
+		return "", ErrAppIdNoMatches
+	}
+
+	if len(data.Applications) > 1 {
+		return "", ErrAppIdMultipleMatches
+	}
+
+	return data.Applications[0].ID.String(), nil
+}
 
 func (s newrelicService) Send(notification Notification, dest Destination) (err error) {
 	if s.opts.ApiKey == "" {
@@ -149,7 +189,22 @@ func (s newrelicService) Send(notification Notification, dest Destination) (err
 		return err
 	}
 
-	markerApi := fmt.Sprintf(s.opts.ApiURL+"/v2/applications/%s/deployments.json", dest.Recipient)
+	var appId = dest.Recipient
+	if dest.Recipient != "" {
+		_, err := strconv.Atoi(dest.Recipient)
+		if err != nil {
+			log.Debugf(
+				"Recipient was provided by application name. Looking up the application id for %s",
+				dest.Recipient,
+			)
+			appId, err = s.getApplicationId(client, dest.Recipient)
+			if err != nil {
+				log.Errorf("Failed to lookup application %s by name: %s", dest.Recipient, err)
+				return err
+			}
+		}
+	}
+	markerApi := fmt.Sprintf(s.opts.ApiURL+"/v2/applications/%s/deployments.json", appId)
 	req, err := http.NewRequest(http.MethodPost, markerApi, bytes.NewBuffer(jsonValue))
 	if err != nil {
 		log.Errorf("Failed to create deployment marker request: %s", err)

pkg/services/newrelic_test.go

@@ -172,6 +172,59 @@ func TestSend_Newrelic(t *testing.T) {
 		require.NoError(t, err)
 	})
 
+	t.Run("recipient is application name", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/v2/applications.json" {
+				_, err := w.Write([]byte(`{
+					"applications": [
+						{"id": "123456789"}
+					]
+				}`))
+				if !assert.NoError(t, err) {
+					t.FailNow()
+				}
+				return
+			}
+
+			b, err := io.ReadAll(r.Body)
+			if !assert.NoError(t, err) {
+				t.FailNow()
+			}
+
+			assert.Equal(t, "/v2/applications/123456789/deployments.json", r.URL.Path)
+			assert.Equal(t, []string{"application/json"}, r.Header["Content-Type"])
+			assert.Equal(t, []string{"NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ"}, r.Header["X-Api-Key"])
+
+			assert.JSONEq(t, `{
+				"deployment": {
+					"revision": "2027ed5",
+					"description": "message",
+					"user": "[email protected]"
+				}
+			}`, string(b))
+		}))
+		defer ts.Close()
+
+		service := NewNewrelicService(NewrelicOptions{
+			ApiKey: "NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ",
+			ApiURL: ts.URL,
+		})
+		err := service.Send(Notification{
+			Message: "message",
+			Newrelic: &NewrelicNotification{
+				Revision: "2027ed5",
+				User:     "[email protected]",
+			},
+		}, Destination{
+			Service:   "newrelic",
+			Recipient: "myapp",
+		})
+
+		if !assert.NoError(t, err) {
+			t.FailNow()
+		}
+	})
+
 	t.Run("missing config", func(t *testing.T) {
 		service := NewNewrelicService(NewrelicOptions{
 			ApiKey: "NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ",
@@ -202,3 +255,69 @@ func TestSend_Newrelic(t *testing.T) {
 		}
 	})
 }
+
+func TestGetApplicationId(t *testing.T) {
+	t.Run("successful lookup by application name", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			assert.Equal(t, "/v2/applications.json", r.URL.Path)
+			assert.Equal(t, "GET", r.Method)
+			assert.Equal(t, "myapp", r.URL.Query().Get("filter[name]"))
+			assert.Equal(t, []string{"application/json"}, r.Header["Content-Type"])
+			assert.Equal(t, []string{"NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ"}, r.Header["X-Api-Key"])
+
+			_, err := w.Write([]byte(`{
+				"applications": [
+					{"id": "123456789"}
+				]
+			}`))
+			if !assert.NoError(t, err) {
+				t.FailNow()
+			}
+		}))
+		defer ts.Close()
+		service := NewNewrelicService(NewrelicOptions{
+			ApiKey: "NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ",
+			ApiURL: ts.URL,
+		}).(*newrelicService)
+		appId, err := service.getApplicationId(http.DefaultClient, "myapp")
+		assert.NoError(t, err)
+		assert.Equal(t, "123456789", appId)
+	})
+
+	t.Run("application not found", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_, err := w.Write([]byte(`{"applications": []}`))
+			if !assert.NoError(t, err) {
+				t.FailNow()
+			}
+		}))
+		defer ts.Close()
+		service := NewNewrelicService(NewrelicOptions{
+			ApiKey: "NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ",
+			ApiURL: ts.URL,
+		}).(*newrelicService)
+		_, err := service.getApplicationId(http.DefaultClient, "myapp")
+		assert.Equal(t, ErrAppIdNoMatches, err)
+	})
+
+	t.Run("multiple matches for application name", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_, err := w.Write([]byte(`{
+				"applications": [
+					{"id": "123456789"},
+					{"id": "987654321"}
+				]
+		  }`))
+			if !assert.NoError(t, err) {
+				t.FailNow()
+			}
+		}))
+		defer ts.Close()
+		service := NewNewrelicService(NewrelicOptions{
+			ApiKey: "NRAK-5F2FIVA5UTA4FFDD11XCXVA7WPJ",
+			ApiURL: ts.URL,
+		}).(*newrelicService)
+		_, err := service.getApplicationId(http.DefaultClient, "myapp")
+		assert.Equal(t, ErrAppIdMultipleMatches, err)
+	})
+}