feat: add X-CLI-Event header for analytics tracking

commands/root.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"slices"
+	"strconv"
 	"strings"
 
 	"github.com/fatih/color"
@@ -19,6 +20,7 @@ import (
 	"github.com/spf13/viper"
 
 	"github.com/upsun/cli/internal"
+	"github.com/upsun/cli/internal/auth"
 	"github.com/upsun/cli/internal/config"
 	"github.com/upsun/cli/internal/config/alt"
 	"github.com/upsun/cli/internal/legacy"
@@ -36,6 +38,26 @@ func Execute(cnf *config.Config) error {
 	}
 
 	ctx := vendorization.WithVendorAssets(config.ToContext(context.Background(), cnf), assets)
+
+	// Extract the event name (command name) for analytics tracking.
+	// Respect user opt-out via DO_NOT_TRACK or {PREFIX}DISABLE_TELEMETRY.
+	dnt, _ := strconv.ParseBool(os.Getenv("DO_NOT_TRACK"))
+	telemetryDisabled := dnt || os.Getenv(cnf.Application.EnvPrefix+"DISABLE_TELEMETRY") == "1"
+
+	if !telemetryDisabled {
+		var eventName string
+		if len(os.Args) > 1 && !strings.HasPrefix(os.Args[1], "-") {
+			eventName = os.Args[1]
+		}
+		ctx = auth.WithEventName(ctx, eventName)
+
+		// Determine if running in interactive mode.
+		// Check environment variable first (available before flag parsing).
+		// The --no-interaction flag is handled later by Cobra, but env var is checked here.
+		interactive := os.Getenv(cnf.Application.EnvPrefix+"NO_INTERACTION") != "1"
+		ctx = auth.WithInteractive(ctx, interactive)
+	}
+
 	return newRootCommand(cnf, assets).ExecuteContext(ctx)
 }
 

internal/auth/client.go

@@ -7,6 +7,7 @@ import (
 
 	"golang.org/x/oauth2"
 
+	"github.com/upsun/cli/internal/config"
 	"github.com/upsun/cli/internal/legacy"
 )
 
@@ -37,13 +38,30 @@ func NewLegacyCLIClient(ctx context.Context, wrapper *legacy.CLIWrapper) (*Legac
 		baseRT = rt
 	}
 
+	// Build the transport chain:
+	// EventTransport (adds X-CLI-Event + User-Agent)
+	//   -> Transport (handles 401 retry)
+	//     -> oauth2.Transport (adds Authorization)
+	//       -> baseRT (http.DefaultTransport or custom)
+	authTransport := &Transport{
+		refresher: refresher,
+		base: &oauth2.Transport{
+			Source: ts,
+			Base:   baseRT,
+		},
+	}
+
+	var userAgent string
+	if cnf := config.FromContext(ctx); cnf != nil {
+		userAgent = cnf.UserAgent()
+	}
+
 	httpClient := &http.Client{
-		Transport: &Transport{
-			refresher: refresher,
-			base: &oauth2.Transport{
-				Source: ts,
-				Base:   baseRT,
-			},
+		Transport: &EventTransport{
+			Base:        authTransport,
+			EventName:   EventNameFromContext(ctx),
+			Interactive: InteractiveFromContext(ctx),
+			UserAgent:   userAgent,
 		},
 	}
 

internal/auth/event_transport.go

@@ -0,0 +1,70 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+// eventCtxKey is the context key for storing the event name.
+type eventCtxKey struct{}
+
+// interactiveCtxKey is the context key for storing the interactive mode flag.
+type interactiveCtxKey struct{}
+
+// WithEventName returns a new context that carries the provided event name.
+func WithEventName(ctx context.Context, name string) context.Context {
+	return context.WithValue(ctx, eventCtxKey{}, name)
+}
+
+// EventNameFromContext retrieves an event name previously stored with WithEventName.
+// It returns an empty string if none is set.
+func EventNameFromContext(ctx context.Context) string {
+	v, _ := ctx.Value(eventCtxKey{}).(string)
+	return v
+}
+
+// WithInteractive returns a new context that carries the interactive mode flag.
+func WithInteractive(ctx context.Context, interactive bool) context.Context {
+	return context.WithValue(ctx, interactiveCtxKey{}, interactive)
+}
+
+// InteractiveFromContext retrieves the interactive flag previously stored with WithInteractive.
+// It returns true (the default) if none is set.
+func InteractiveFromContext(ctx context.Context) bool {
+	v, ok := ctx.Value(interactiveCtxKey{}).(bool)
+	if !ok {
+		return true // default to interactive
+	}
+	return v
+}
+
+// EventTransport wraps an http.RoundTripper to add event tracking headers.
+type EventTransport struct {
+	// Base is the underlying RoundTripper to use for requests.
+	Base http.RoundTripper
+
+	// EventName is the command name for the X-CLI-Event header.
+	// If empty, no header is added.
+	EventName string
+
+	// Interactive indicates whether the CLI is running in interactive mode.
+	Interactive bool
+
+	// UserAgent is the User-Agent string to send.
+	// If empty, or a User-Agent is already set on the request, no header is added.
+	UserAgent string
+}
+
+// RoundTrip adds the X-CLI-Event and User-Agent headers to the request.
+func (t *EventTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if t.EventName != "" {
+		// Format: command=<name>; interactive=<bool>
+		headerValue := fmt.Sprintf("command=%s; interactive=%t", t.EventName, t.Interactive)
+		req.Header.Set("X-CLI-Event", headerValue)
+	}
+	if t.UserAgent != "" && req.Header.Get("User-Agent") == "" {
+		req.Header.Set("User-Agent", t.UserAgent)
+	}
+	return t.Base.RoundTrip(req)
+}

internal/auth/event_transport_test.go

@@ -0,0 +1,178 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEventTransport_RoundTrip(t *testing.T) {
+	cases := []struct {
+		name              string
+		eventName         string
+		interactive       bool
+		userAgent         string
+		existingUserAgent string
+		wantEventHeader   string
+		wantUserAgent     string
+	}{
+		{
+			name:            "sets headers with interactive true",
+			eventName:       "backup:restore",
+			interactive:     true,
+			userAgent:       "Upsun-CLI/1.0.0",
+			wantEventHeader: "command=backup:restore; interactive=true",
+			wantUserAgent:   "Upsun-CLI/1.0.0",
+		},
+		{
+			name:            "sets headers with interactive false",
+			eventName:       "backup:restore",
+			interactive:     false,
+			userAgent:       "Upsun-CLI/1.0.0",
+			wantEventHeader: "command=backup:restore; interactive=false",
+			wantUserAgent:   "Upsun-CLI/1.0.0",
+		},
+		{
+			name:            "sets only event header when user agent is empty",
+			eventName:       "project:info",
+			interactive:     true,
+			userAgent:       "",
+			wantEventHeader: "command=project:info; interactive=true",
+			wantUserAgent:   "Go-http-client/1.1", // Go's default User-Agent
+		},
+		{
+			name:            "sets only user agent when event name is empty",
+			eventName:       "",
+			interactive:     true,
+			userAgent:       "Upsun-CLI/1.0.0",
+			wantEventHeader: "",
+			wantUserAgent:   "Upsun-CLI/1.0.0",
+		},
+		{
+			name:            "does not set event header when event name is empty",
+			eventName:       "",
+			interactive:     false,
+			userAgent:       "",
+			wantEventHeader: "",
+			wantUserAgent:   "Go-http-client/1.1", // Go's default User-Agent
+		},
+		{
+			name:              "does not override existing user agent",
+			eventName:         "init",
+			interactive:       true,
+			userAgent:         "Upsun-CLI/1.0.0",
+			existingUserAgent: "Custom-Agent/2.0",
+			wantEventHeader:   "command=init; interactive=true",
+			wantUserAgent:     "Custom-Agent/2.0",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var receivedEventHeader, receivedUserAgent string
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				receivedEventHeader = r.Header.Get("X-CLI-Event")
+				receivedUserAgent = r.Header.Get("User-Agent")
+				w.WriteHeader(http.StatusOK)
+			}))
+			defer server.Close()
+
+			transport := &EventTransport{
+				Base:        http.DefaultTransport,
+				EventName:   tc.eventName,
+				Interactive: tc.interactive,
+				UserAgent:   tc.userAgent,
+			}
+
+			client := &http.Client{Transport: transport}
+
+			req, err := http.NewRequest(http.MethodGet, server.URL, http.NoBody)
+			require.NoError(t, err)
+
+			if tc.existingUserAgent != "" {
+				req.Header.Set("User-Agent", tc.existingUserAgent)
+			}
+
+			resp, err := client.Do(req)
+			require.NoError(t, err)
+			defer resp.Body.Close()
+
+			assert.Equal(t, http.StatusOK, resp.StatusCode)
+			assert.Equal(t, tc.wantEventHeader, receivedEventHeader)
+			assert.Equal(t, tc.wantUserAgent, receivedUserAgent)
+		})
+	}
+}
+
+func TestWithEventName(t *testing.T) {
+	cases := []struct {
+		name      string
+		eventName string
+	}{
+		{
+			name:      "stores and retrieves event name",
+			eventName: "backup:restore",
+		},
+		{
+			name:      "handles empty event name",
+			eventName: "",
+		},
+		{
+			name:      "handles command with namespace",
+			eventName: "project:info",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()
+			ctx = WithEventName(ctx, tc.eventName)
+
+			got := EventNameFromContext(ctx)
+			assert.Equal(t, tc.eventName, got)
+		})
+	}
+}
+
+func TestEventNameFromContext_EmptyContext(t *testing.T) {
+	ctx := context.Background()
+	got := EventNameFromContext(ctx)
+	assert.Equal(t, "", got)
+}
+
+func TestWithInteractive(t *testing.T) {
+	cases := []struct {
+		name        string
+		interactive bool
+	}{
+		{
+			name:        "stores interactive true",
+			interactive: true,
+		},
+		{
+			name:        "stores interactive false",
+			interactive: false,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()
+			ctx = WithInteractive(ctx, tc.interactive)
+
+			got := InteractiveFromContext(ctx)
+			assert.Equal(t, tc.interactive, got)
+		})
+	}
+}
+
+func TestInteractiveFromContext_EmptyContext(t *testing.T) {
+	ctx := context.Background()
+	got := InteractiveFromContext(ctx)
+	assert.True(t, got, "default should be interactive=true")
+}

internal/legacy/legacy.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"sync"
 	"time"
 
@@ -158,6 +159,10 @@ func (c *CLIWrapper) Exec(ctx context.Context, args ...string) error {
 		PHPVersion,
 		c.Version,
 	))
+	// Pass the event name (command name) to the legacy CLI for analytics tracking.
+	if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
+		cmd.Env = append(cmd.Env, envPrefix+"EVENT_NAME="+args[0])
+	}
 	if err := cmd.Run(); err != nil {
 		return fmt.Errorf("could not run PHP CLI command: %w", err)
 	}