feat(analytics): enhance command tracking with success and failure events

Author: ramya18101

internal/analytics/analytics.go

@@ -12,7 +12,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/spf13/cobra"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 
@@ -46,15 +45,20 @@ func NewTracker() *Tracker {
 
 func (t *Tracker) TrackFirstLogin(id string, loginType string) {
 	eventName := fmt.Sprintf("%s - Auth0 - First Login", eventNamePrefix)
-	t.track(eventName, id)
+	t.track(eventName, id, nil)
 
 	eventName = fmt.Sprintf("%s - Auth0 - First Login - %s", eventNamePrefix, loginType)
-	t.track(eventName, id)
+	t.track(eventName, id, nil)
 }
 
-func (t *Tracker) TrackCommandRun(cmd *cobra.Command, id string) {
-	eventName := generateRunEventName(cmd.CommandPath())
-	t.track(eventName, id)
+func (t *Tracker) TrackCommandSucceeded(commandPath string, id string) {
+	eventName := generateSucceededEventName(commandPath)
+	t.track(eventName, id, map[string]string{"success": "true", "error_class": "none"})
+}
+
+func (t *Tracker) TrackCommandFailed(commandPath string, id string, properties map[string]string) {
+	eventName := generateFailedEventName(commandPath)
+	t.track(eventName, id, properties)
 }
 
 func (t *Tracker) Wait(ctx context.Context) {
@@ -73,12 +77,12 @@ func (t *Tracker) Wait(ctx context.Context) {
 	}
 }
 
-func (t *Tracker) track(eventName string, id string) {
+func (t *Tracker) track(eventName string, id string, properties map[string]string) {
 	if !shouldTrack() {
 		return
 	}
 
-	event := newEvent(eventName, id)
+	event := newEvent(eventName, id, properties)
 
 	t.wg.Add(1)
 	go t.sendEvent(event)
@@ -111,22 +115,32 @@ func (t *Tracker) sendEvent(event *event) {
 	}()
 }
 
-func newEvent(eventName string, id string) *event {
+func newEvent(eventName string, id string, properties map[string]string) *event {
+	eventProperties := map[string]string{
+		versionKey: buildinfo.Version,
+		osKey:      runtime.GOOS,
+		archKey:    runtime.GOARCH,
+	}
+
+	for k, v := range properties {
+		eventProperties[k] = v
+	}
+
 	return &event{
-		App:       appID,
-		ID:        id,
-		Event:     eventName,
-		Timestamp: timestamp(),
-		Properties: map[string]string{
-			versionKey: buildinfo.Version,
-			osKey:      runtime.GOOS,
-			archKey:    runtime.GOARCH,
-		},
+		App:        appID,
+		ID:         id,
+		Event:      eventName,
+		Timestamp:  timestamp(),
+		Properties: eventProperties,
 	}
 }
 
-func generateRunEventName(command string) string {
-	return generateEventName(command, "Run")
+func generateSucceededEventName(command string) string {
+	return generateEventName(command, "Succeeded")
+}
+
+func generateFailedEventName(command string) string {
+	return generateEventName(command, "Failed")
 }
 
 func generateEventName(command string, action string) string {

internal/analytics/analytics_test.go

@@ -34,35 +34,37 @@ func TestGenerateEventName(t *testing.T) {
 	})
 }
 
-func TestGenerateRunEventName(t *testing.T) {
-	t.Run("generates from root command run", func(t *testing.T) {
-		want := "CLI - Auth0 - Run"
-		got := generateRunEventName("auth0")
+func TestGenerateSucceededEventName(t *testing.T) {
+	t.Run("generates from root command", func(t *testing.T) {
+		want := "CLI - Auth0 - Succeeded"
+		got := generateSucceededEventName("auth0")
 		assert.Equal(t, want, got)
 	})
 
-	t.Run("generates from top-level command run", func(t *testing.T) {
-		want := "CLI - Auth0 - Apps - Run"
-		got := generateRunEventName("auth0 apps")
+	t.Run("generates from top-level command", func(t *testing.T) {
+		want := "CLI - Auth0 - Apps - Succeeded"
+		got := generateSucceededEventName("auth0 apps")
 		assert.Equal(t, want, got)
 	})
+}
 
-	t.Run("generates from subcommand run", func(t *testing.T) {
-		want := "CLI - Apps - List - Run"
-		got := generateRunEventName("auth0 apps list")
+func TestGenerateFailedEventName(t *testing.T) {
+	t.Run("generates from root command", func(t *testing.T) {
+		want := "CLI - Auth0 - Failed"
+		got := generateFailedEventName("auth0")
 		assert.Equal(t, want, got)
 	})
 
-	t.Run("generates from deep subcommand run", func(t *testing.T) {
-		want := "CLI - Apis - Scopes List - Run"
-		got := generateRunEventName("auth0 apis scopes list")
+	t.Run("generates from subcommand", func(t *testing.T) {
+		want := "CLI - Apps - List - Failed"
+		got := generateFailedEventName("auth0 apps list")
 		assert.Equal(t, want, got)
 	})
 }
 
 func TestNewEvent(t *testing.T) {
 	t.Run("creates a new event instance", func(t *testing.T) {
-		event := newEvent("event", "id")
+		event := newEvent("event", "id", nil)
 		// Assert that the interval between the event timestamp and now is within 1 second.
 		assert.WithinDuration(t, time.Now(), time.Unix(0, event.Timestamp*int64(1000000)), 1*time.Second)
 		assert.Equal(t, event.App, appID)
@@ -71,4 +73,11 @@ func TestNewEvent(t *testing.T) {
 		assert.Equal(t, event.Properties[osKey], runtime.GOOS)
 		assert.Equal(t, event.Properties[archKey], runtime.GOARCH)
 	})
+
+	t.Run("merges extra properties", func(t *testing.T) {
+		event := newEvent("event", "id", map[string]string{"success": "false", "error_class": "auth"})
+		assert.Equal(t, "false", event.Properties["success"])
+		assert.Equal(t, "auth", event.Properties["error_class"])
+		assert.Equal(t, runtime.GOOS, event.Properties[osKey])
+	})
 }

internal/cli/cli.go

@@ -40,14 +40,15 @@ type cli struct {
 	tracker  *analytics.Tracker
 
 	// Set of flags which are user specified.
-	debug       bool
-	tenant      string
-	json        bool
-	jsonCompact bool
-	csv         bool
-	force       bool
-	noInput     bool
-	noColor     bool
+	debug               bool
+	tenant              string
+	json                bool
+	jsonCompact         bool
+	csv                 bool
+	force               bool
+	noInput             bool
+	noColor             bool
+	executedCommandPath string
 
 	Config config.Config
 }

internal/cli/login.go

@@ -223,8 +223,6 @@ func loginCmd(cli *cli) *cobra.Command {
 				}
 			}
 
-			cli.tracker.TrackCommandRun(cmd, cli.Config.InstallID)
-
 			if len(cli.Config.Tenants) > 1 {
 				cli.renderer.Infof("%s Switch between authenticated tenants with `auth0 tenants use <tenant>`",
 					ansi.Faint("Hint:"),

internal/cli/root.go

@@ -2,17 +2,20 @@ package cli
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/signal"
 	"time"
 	"unicode"
 
+	"github.com/auth0/go-auth0/management"
 	"github.com/spf13/cobra"
 
 	"github.com/auth0/auth0-cli/internal/analytics"
 	"github.com/auth0/auth0-cli/internal/ansi"
 	"github.com/auth0/auth0-cli/internal/buildinfo"
+	"github.com/auth0/auth0-cli/internal/config"
 	"github.com/auth0/auth0-cli/internal/display"
 	"github.com/auth0/auth0-cli/internal/instrumentation"
 )
@@ -62,17 +65,19 @@ func Execute() {
 	ansi.InitConsole()
 
 	cancelCtx := contextWithCancel()
-	if err := rootCmd.ExecuteContext(cancelCtx); err != nil {
+	err := rootCmd.ExecuteContext(cancelCtx)
+	trackCommandOutcome(cli, err)
+
+	timeoutCtx, cancel := context.WithTimeout(cancelCtx, 3*time.Second)
+	defer cancel()
+	cli.tracker.Wait(timeoutCtx) // No event should be tracked after this has run.
+
+	if err != nil {
 		renderErrorMessage(cli.renderer, err.Error())
 
 		instrumentation.ReportException(err)
 		os.Exit(1) // nolint:gocritic
 	}
-
-	timeoutCtx, cancel := context.WithTimeout(cancelCtx, 3*time.Second)
-	// Defers are executed in LIFO order.
-	defer cancel()
-	defer cli.tracker.Wait(timeoutCtx) // No event should be tracked after this has run, or it will panic e.g. in earlier deferred functions.
 }
 
 func buildRootCmd(cli *cli) *cobra.Command {
@@ -84,6 +89,8 @@ func buildRootCmd(cli *cli) *cobra.Command {
 		Long:          rootShort + "\n" + getLogin(cli),
 		Version:       buildinfo.GetVersionWithCommit(),
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			cli.executedCommandPath = cmd.CommandPath()
+
 			ansi.Initialize(cli.noColor)
 			prepareInteractivity(cmd)
 			cli.configureRenderer()
@@ -92,16 +99,6 @@ func buildRootCmd(cli *cli) *cobra.Command {
 				return nil
 			}
 
-			// We're tracking the login command in its Run method, so
-			// we'll only add this defer if the command is not login.
-			defer func() {
-				if cli.tracker != nil &&
-					cmd.CommandPath() != "auth0 login" &&
-					cli.Config.IsLoggedInWithTenant(cli.tenant) {
-					cli.tracker.TrackCommandRun(cmd, cli.Config.InstallID)
-				}
-			}()
-
 			if err := cli.setupWithAuthentication(cmd.Context()); err != nil {
 				return err
 			}
@@ -225,3 +222,77 @@ func renderErrorMessage(display *display.Renderer, errorMessage string) {
 	display.Errorf(humanReadableErrorMessage)
 	display.Newline()
 }
+
+func trackCommandOutcome(cli *cli, executionErr error) {
+	if cli.tracker == nil {
+		return
+	}
+
+	installID := resolveInstallIDForTracking(cli)
+	if installID == "" {
+		return
+	}
+
+	if cli.executedCommandPath == "" {
+		cli.executedCommandPath = "auth0"
+	}
+
+	if executionErr != nil {
+		cli.tracker.TrackCommandFailed(cli.executedCommandPath, installID, classifyCommandFailure(executionErr))
+		return
+	}
+
+	cli.tracker.TrackCommandSucceeded(cli.executedCommandPath, installID)
+}
+
+func resolveInstallIDForTracking(cli *cli) string {
+	if cli.Config.InstallID != "" {
+		return cli.Config.InstallID
+	}
+
+	if err := cli.Config.Initialize(); err != nil {
+		if errors.Is(err, config.ErrConfigFileMissing) {
+			return ""
+		}
+		return ""
+	}
+
+	return cli.Config.InstallID
+}
+
+func classifyCommandFailure(err error) map[string]string {
+	properties := map[string]string{
+		"success":     "false",
+		"error_class": "unknown",
+	}
+
+	if errors.Is(err, config.ErrInvalidToken) || errors.Is(err, config.ErrMalformedToken) {
+		properties["error_class"] = "auth"
+		return properties
+	}
+
+	var missingScopesErr config.ErrTokenMissingRequiredScopes
+	if errors.As(err, &missingScopesErr) {
+		properties["error_class"] = "auth"
+		return properties
+	}
+
+	var managementErr management.Error
+	if errors.As(err, &managementErr) {
+		status := managementErr.Status()
+		switch {
+		case status == 401 || status == 403:
+			properties["error_class"] = "auth"
+		case status == 400 || status == 422:
+			properties["error_class"] = "validation"
+		case status == 404:
+			properties["error_class"] = "not_found"
+		case status == 429:
+			properties["error_class"] = "rate_limit"
+		case status >= 500:
+			properties["error_class"] = "api"
+		}
+	}
+
+	return properties
+}