chore: Set up go agent to instrument go app (#24)

* chore: Initial test

Co-Authored-By: Claude <noreply@anthropic.com>

* chore: Add log forwarding

* chore: Handle logging a different way

* fix: Fixing broken test

* chore: Using staging host

* chore: Cleanup

* chore: Cleanup

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: mvicknr

action.yml

@@ -23,6 +23,10 @@ inputs:
     description: 'Enable Go build cache'
     required: false
     default: 'true'
+  apm-control-nr-license-key:
+    description: 'New Relic APM license key for instrumentation of this action (optional, pass from secrets)'
+    required: false
+    default: ''
 runs:
   using: 'composite'
   steps:
@@ -157,6 +161,7 @@ runs:
         INPUT_AGENT_TYPE: ${{ inputs.agent-type }}
         INPUT_VERSION: ${{ inputs.version }}
         NEWRELIC_TOKEN: ${{ steps.newrelic-auth.outputs.token }}
+        APM_CONTROL_NR_LICENSE_KEY: ${{ inputs.apm-control-nr-license-key }}
       run: |
         set -e
         cd ${{ github.action_path }}

cmd/agent-metadata-action/main.go

@@ -6,11 +6,15 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"time"
 
 	"agent-metadata-action/internal/client"
 	"agent-metadata-action/internal/config"
 	"agent-metadata-action/internal/loader"
+	"agent-metadata-action/internal/logging"
 	"agent-metadata-action/internal/models"
+
+	"github.com/newrelic/go-agent/v3/newrelic"
 )
 
 // metadataClient interface for testing
@@ -24,22 +28,89 @@ var createMetadataClientFunc = func(baseURL, token string) metadataClient {
 	return client.NewInstrumentationClient(baseURL, token)
 }
 
+// initNewRelic initializes the New Relic application
+// Returns nil if APM_CONTROL_NR_LICENSE_KEY is not set (silent no-op mode)
+func initNewRelic() *newrelic.Application {
+	licenseKey := config.GetNRAgentLicenseKey()
+	if licenseKey == "" {
+		_, _ = fmt.Fprintln(os.Stderr, "::warn::Failed to init New Relic - missing license key")
+		return nil
+	}
+
+	// Hardcode staging environment
+	err := config.SetNRAgentHost()
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "::warn::Failed to init New Relic, missing host: %v\n", err)
+		return nil
+	}
+	fmt.Println("::notice::Using New Relic staging environment")
+
+	app, err := newrelic.NewApplication(
+		newrelic.ConfigAppName("agent-metadata-action"),
+		newrelic.ConfigLicense(licenseKey),
+		newrelic.ConfigDebugLogger(os.Stdout),
+		newrelic.ConfigDistributedTracerEnabled(true),
+		newrelic.ConfigAppLogForwardingEnabled(true),
+		newrelic.ConfigFromEnvironment(), // This reads NEW_RELIC_HOST
+		newrelic.ConfigLabels(map[string]string{
+			"team": "APM Control Team",
+		}),
+	)
+
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "::warn::Failed to init New Relic: %v\n", err)
+		return nil
+	}
+
+	fmt.Println("::notice::New Relic APM enabled - waiting for connection...")
+
+	// Wait for the app to connect (max 10 seconds)
+	if err := app.WaitForConnection(10 * time.Second); err != nil {
+		fmt.Printf("::warn::New Relic connection timeout: %v - will try to send data anyway\n", err)
+	} else {
+		fmt.Println("::notice::New Relic connected successfully")
+	}
+
+	return app
+}
+
 func main() {
-	if err := run(); err != nil {
+	nrApp := initNewRelic()
+
+	if err := run(nrApp); err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "::error::%v\n", err)
 		os.Exit(1)
 	}
+
+	if nrApp != nil {
+		fmt.Println("::notice::Shutting down New Relic - waiting up to 15 seconds to send data...")
+		nrApp.Shutdown(15 * time.Second)
+		fmt.Println("::notice::New Relic shutdown complete")
+	}
 }
 
-func run() error {
+func run(nrApp *newrelic.Application) error {
+	// Create context
+	ctx := context.Background()
+
+	// Start transaction if New Relic is enabled
+	if nrApp != nil {
+		txn := nrApp.StartTransaction("agent-metadata-action")
+		defer txn.End()
+
+		// Add transaction to context for logging
+		ctx = newrelic.NewContext(ctx, txn)
+		logging.Debug(ctx, "New Relic transaction started")
+		defer logging.Debug(ctx, "New Relic transaction ended")
+	}
+
 	// Validate required environment and setup
-	workspace, token, err := validateEnvironment()
+	workspace, token, err := validateEnvironment(ctx)
 	if err != nil {
 		return err
 	}
 
 	// Create metadataClient
-	ctx := context.Background()
 	metadataClient := createMetadataClientFunc(config.GetMetadataURL(), token)
 
 	// Determine which flow to execute
@@ -54,7 +125,7 @@ func run() error {
 }
 
 // validateEnvironment checks required environment variables and workspace
-func validateEnvironment() (workspace string, token string, err error) {
+func validateEnvironment(ctx context.Context) (workspace string, token string, err error) {
 	workspace = config.GetWorkspace()
 	if workspace == "" {
 		return "", "", fmt.Errorf("GITHUB_WORKSPACE is required but not set")
@@ -69,13 +140,13 @@ func validateEnvironment() (workspace string, token string, err error) {
 		return "", "", fmt.Errorf("NEWRELIC_TOKEN is required but not set")
 	}
 
-	fmt.Println("::notice::Environment validated successfully")
+	logging.Notice(ctx, "Environment validated successfully")
 	return workspace, token, nil
 }
 
 // runAgentFlow handles the agent repository workflow
 func runAgentFlow(ctx context.Context, client metadataClient, workspace, agentType, agentVersion string) error {
-	fmt.Println("::debug::Running agent repository flow")
+	logging.Debug(ctx, "Running agent repository flow")
 
 	// Check for .fleetControl directory
 	fleetControlPath := filepath.Join(workspace, config.GetRootFolderForAgentRepo())
@@ -88,15 +159,15 @@ func runAgentFlow(ctx context.Context, client metadataClient, workspace, agentTy
 	if err != nil {
 		return fmt.Errorf("failed to read configuration definitions: %w", err)
 	}
-	fmt.Printf("::notice::Loaded %d configuration definitions\n", len(configs))
+	logging.Noticef(ctx, "Loaded %d configuration definitions", len(configs))
 
 	// Load agent control definitions (optional)
 	agentControl, err := loader.ReadAgentControlDefinitions(workspace)
 	if err != nil {
-		fmt.Printf("::warn::Unable to load agent control definitions: %v - continuing without them\n", err)
+		logging.Warnf(ctx, "Unable to load agent control definitions: %v - continuing without them", err)
 		agentControl = nil
 	} else {
-		fmt.Printf("::notice::Loaded %d agent control definitions\n", len(agentControl))
+		logging.Noticef(ctx, "Loaded %d agent control definitions", len(agentControl))
 	}
 
 	// Build metadata
@@ -113,13 +184,13 @@ func runAgentFlow(ctx context.Context, client metadataClient, workspace, agentTy
 		return fmt.Errorf("failed to send metadata for %s: %w", agentType, err)
 	}
 
-	fmt.Printf("::notice::Successfully sent metadata for %s version %s\n", agentType, agentVersion)
+	logging.Noticef(ctx, "Successfully sent metadata for %s version %s", agentType, agentVersion)
 	return nil
 }
 
 // runDocsFlow handles the documentation repository workflow
 func runDocsFlow(ctx context.Context, client metadataClient) error {
-	fmt.Println("::debug::Running documentation flow")
+	logging.Debug(ctx, "Running documentation flow")
 
 	// Load metadata from changed MDX files
 	metadataList, err := loader.LoadMetadataForDocs()
@@ -128,23 +199,23 @@ func runDocsFlow(ctx context.Context, client metadataClient) error {
 	}
 
 	if len(metadataList) == 0 {
-		fmt.Println("::notice::No metadata changes detected")
+		logging.Notice(ctx, "No metadata changes detected")
 		return nil
 	}
 
-	fmt.Printf("::notice::Processing %d metadata entries\n", len(metadataList))
+	logging.Noticef(ctx, "Processing %d metadata entries", len(metadataList))
 
 	// Send each metadata entry separately
 	successCount := 0
 	for _, entry := range metadataList {
 		if err := sendDocsMetadata(ctx, client, entry); err != nil {
-			fmt.Printf("::warn::Failed to send metadata for %s: %v\n", entry.AgentType, err)
+			logging.Warnf(ctx, "Failed to send metadata for %s: %v", entry.AgentType, err)
 			continue
 		}
 		successCount++
 	}
 
-	fmt.Printf("::notice::Successfully sent %d of %d metadata entries\n", successCount, len(metadataList))
+	logging.Noticef(ctx, "Successfully sent %d of %d metadata entries", successCount, len(metadataList))
 	return nil
 }
 
@@ -162,7 +233,7 @@ func sendDocsMetadata(ctx context.Context, client metadataClient, entry loader.M
 		return err
 	}
 
-	fmt.Printf("::notice::Sent metadata for %s version %s\n", entry.AgentType, version)
+	logging.Noticef(ctx, "Sent metadata for %s version %s", entry.AgentType, version)
 	return nil
 }
 

cmd/agent-metadata-action/main_test.go

@@ -168,7 +168,7 @@ func TestRun_InvalidEnvironment(t *testing.T) {
 	t.Setenv("NEWRELIC_TOKEN", "mock-token-for-testing")
 
 	// Method under test
-	err := run()
+	err := run(nil)
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "workspace directory does not exist")
@@ -230,7 +230,7 @@ func TestValidateEnvironment(t *testing.T) {
 			t.Setenv("NEWRELIC_TOKEN", tt.token)
 
 			// Method under test
-			gotWorkspace, gotToken, err := validateEnvironment()
+			gotWorkspace, gotToken, err := validateEnvironment(context.Background())
 
 			if tt.wantErr {
 				assert.Error(t, err)

go.mod

@@ -9,5 +9,12 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/newrelic/go-agent/v3 v3.42.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157 // indirect
+	google.golang.org/grpc v1.65.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
 )

go.sum

@@ -1,9 +1,23 @@
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/newrelic/go-agent/v3 v3.42.0 h1:aA2Ea1RT5eD59LtOS1KGFXSmaDs6kM3Jeqo7PpuQoFQ=
+github.com/newrelic/go-agent/v3 v3.42.0/go.mod h1:sCgxDCVydoKD/C4S8BFxDtmFHvdWHtaIz/a3kiyNB/k=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157 h1:Zy9XzmMEflZ/MAaA7vNcoebnRAld7FsPW1EeBB7V0m8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
+google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
+google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/config/env.go

@@ -29,6 +29,21 @@ func GetEventPath() string {
 	return os.Getenv("GITHUB_EVENT_PATH")
 }
 
+// GetToken loads the newrelic token from the environment variables
 func GetToken() string {
 	return os.Getenv("NEWRELIC_TOKEN")
 }
+
+// GetNRAgentLicenseKey gets the license key to use the go agent and monitor this app
+func GetNRAgentLicenseKey() string {
+	return os.Getenv("APM_CONTROL_NR_LICENSE_KEY")
+}
+
+// SetNRAgentHost sets the host to use for the go agent that will be used to monitor this app
+func SetNRAgentHost() error {
+	err := os.Setenv("NEW_RELIC_HOST", "staging-collector.newrelic.com")
+	if err != nil {
+		return err
+	}
+	return nil
+}

internal/logging/logging.go

@@ -0,0 +1,62 @@
+package logging
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/newrelic/go-agent/v3/newrelic"
+)
+
+// Log logs to both console (GitHub Actions format) and New Relic
+// Extracts the New Relic transaction from context if available
+func Log(ctx context.Context, level, message string) {
+	// Always log to console for GitHub Actions
+	fmt.Printf("::%s::%s\n", level, message)
+
+	// Also send to New Relic if transaction exists in context
+	if txn := newrelic.FromContext(ctx); txn != nil {
+		txn.RecordLog(newrelic.LogData{
+			Message:  message,
+			Severity: level,
+		})
+	}
+}
+
+// Logf is like Log but supports formatting
+func Logf(ctx context.Context, level, format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	Log(ctx, level, message)
+}
+
+// Convenience functions for common log levels
+func Notice(ctx context.Context, message string) {
+	Log(ctx, "notice", message)
+}
+
+func Noticef(ctx context.Context, format string, args ...interface{}) {
+	Logf(ctx, "notice", format, args...)
+}
+
+func Debug(ctx context.Context, message string) {
+	Log(ctx, "debug", message)
+}
+
+func Debugf(ctx context.Context, format string, args ...interface{}) {
+	Logf(ctx, "debug", format, args...)
+}
+
+func Error(ctx context.Context, message string) {
+	Log(ctx, "error", message)
+}
+
+func Errorf(ctx context.Context, format string, args ...interface{}) {
+	Logf(ctx, "error", format, args...)
+}
+
+func Warn(ctx context.Context, message string) {
+	Log(ctx, "warn", message)
+}
+
+func Warnf(ctx context.Context, format string, args ...interface{}) {
+	Logf(ctx, "warn", format, args...)
+}