feat: add CLI telemetry for command execution tracking (#652)

* feat: add CLI telemetry for command execution tracking

- Add telemetry package to capture command execution data
- Generate UUID for each command execution
- Track command name, duration, exit code, and environment (CI detection)
- Send telemetry to /vendor/v3/cli/telemetry/event endpoint
- Send error details to /vendor/v3/cli/telemetry/error endpoint for failed commands
- Fire-and-forget pattern ensures telemetry never blocks CLI execution
- Silent operation with opt-out via REPLICATED_TELEMETRY_DISABLED env var
- Tested with production backend endpoints

Author: bennyyang11

cli/cmd/lint.go

@@ -12,6 +12,7 @@ import (
 	"github.com/replicatedhq/replicated/cli/print"
 	"github.com/replicatedhq/replicated/pkg/imageextract"
 	"github.com/replicatedhq/replicated/pkg/lint2"
+	"github.com/replicatedhq/replicated/pkg/telemetry"
 	"github.com/replicatedhq/replicated/pkg/tools"
 	"github.com/replicatedhq/replicated/pkg/version"
 	"github.com/spf13/cobra"
@@ -505,6 +506,34 @@ func (r *runners) runLint(cmd *cobra.Command, args []string) error {
 		output.Metadata.EmbeddedClusterVersion = extracted.ECVersion
 	}
 
+	// Collect resource statistics for telemetry
+	stats := telemetry.ResourceStats{
+		HelmChartsCount:     len(extracted.ChartPaths),
+		PreflightsCount:     len(extracted.Preflights),
+		SupportBundlesCount: len(extracted.SupportBundles),
+		ManifestsCount:      len(extracted.HelmChartManifests),
+		ToolVersions: map[string]string{
+			"helm":                extracted.HelmVersion,
+			"preflight-check":     extracted.PreflightVersion,
+			"support-bundle-lint": extracted.SBVersion,
+		},
+	}
+	
+	// Add EC version if used
+	if extracted.ECVersion != "" && len(extracted.EmbeddedClusterPaths) > 0 {
+		stats.ToolVersions["embedded-cluster"] = extracted.ECVersion
+	}
+	
+	// Add KOTS version if used
+	if extracted.KotsVersion != "" && len(extracted.KotsPaths) > 0 {
+		stats.ToolVersions["kots"] = extracted.KotsVersion
+	}
+	
+	// Record stats for telemetry (will be sent when command completes)
+	if r.telemetry != nil {
+		r.telemetry.RecordStats(stats)
+	}
+
 	// Check tool versions (only for enabled linters with pinned versions)
 	// This displays warnings if configured versions are outdated by minor/major version
 	toolVersionWarnings := r.checkToolVersions(config, extracted)

cli/cmd/release_lint.go

@@ -4,10 +4,12 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/mholt/archiver/v3"
 	"github.com/pkg/errors"
 	"github.com/replicatedhq/replicated/cli/print"
+	"github.com/replicatedhq/replicated/pkg/telemetry"
 	"github.com/replicatedhq/replicated/pkg/types"
 	"github.com/spf13/cobra"
 	"helm.sh/helm/v3/pkg/chart/loader"
@@ -90,6 +92,10 @@ func (r *runners) releaseLintV1(_ *cobra.Command, _ []string) error {
 		return errors.New("no app specified")
 	}
 
+	// Collect stats for telemetry before sending to remote API
+	// We'll count resources in the directory/chart being linted
+	var stats *telemetry.ResourceStats
+
 	var isBuildersRelease bool
 	var lintReleaseData []byte
 	var contentType string
@@ -98,6 +104,13 @@ func (r *runners) releaseLintV1(_ *cobra.Command, _ []string) error {
 		if err != nil {
 			return errors.Wrap(err, "failed to check if yaml dir is helm charts only")
 		}
+		
+		// Count resources in the directory for stats
+		if r.telemetry != nil {
+			resourceStats := countResourcesInDirectory(r.args.lintReleaseYamlDir)
+			stats = &resourceStats
+		}
+		
 		data, err := tarYAMLDir(r.args.lintReleaseYamlDir)
 		if err != nil {
 			return errors.Wrap(err, "failed to read yaml dir")
@@ -130,6 +143,11 @@ func (r *runners) releaseLintV1(_ *cobra.Command, _ []string) error {
 		return errors.Wrap(err, "failed to print lint errors")
 	}
 
+	// Record stats for telemetry if collected
+	if r.telemetry != nil && stats != nil {
+		r.telemetry.RecordStats(*stats)
+	}
+
 	if hasError := shouldFail(lintResult, r.args.lintReleaseFailOn); hasError {
 		return errors.Errorf("One or more errors of severity %q or higher were found", r.args.lintReleaseFailOn)
 	}
@@ -186,6 +204,51 @@ func tarYAMLDir(yamlDir string) ([]byte, error) {
 	return data, nil
 }
 
+// countResourcesInDirectory counts resources in a directory for telemetry stats
+// This is a basic implementation for the old lint path
+func countResourcesInDirectory(yamlDir string) telemetry.ResourceStats {
+	stats := telemetry.ResourceStats{
+		ToolVersions: make(map[string]string),
+	}
+	
+	// Walk the directory and count YAML files by type
+	// This is a best-effort count - may not be 100% accurate but better than nothing
+	filepath.Walk(yamlDir, func(path string, info fs.FileInfo, err error) error {
+		if err != nil || info.IsDir() {
+			return nil
+		}
+		
+		// Only process YAML files
+		ext := strings.ToLower(filepath.Ext(path))
+		if ext != ".yaml" && ext != ".yml" {
+			return nil
+		}
+		
+		// Read file to determine type
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return nil
+		}
+		
+		content := string(data)
+		
+		// Simple heuristic based on kind field
+		if strings.Contains(content, "kind: Chart") || strings.Contains(content, "apiVersion: v2") {
+			stats.HelmChartsCount++
+		} else if strings.Contains(content, "kind: Preflight") {
+			stats.PreflightsCount++
+		} else if strings.Contains(content, "kind: SupportBundle") {
+			stats.SupportBundlesCount++
+		} else if strings.Contains(content, "kind: HelmChart") {
+			stats.ManifestsCount++
+		}
+		
+		return nil
+	})
+	
+	return stats
+}
+
 func isHelmChartsOnly(yamlDir string) (bool, error) {
 	helmError := errors.New("helm error")
 	err := filepath.Walk(yamlDir, func(path string, info fs.FileInfo, err error) error {

cli/cmd/root.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"strings"
 	"text/tabwriter"
+	"time"
 
 	"github.com/Masterminds/sprig/v3"
 	"github.com/pkg/errors"
@@ -15,6 +16,7 @@ import (
 	"github.com/replicatedhq/replicated/pkg/credentials"
 	"github.com/replicatedhq/replicated/pkg/kotsclient"
 	"github.com/replicatedhq/replicated/pkg/platformclient"
+	"github.com/replicatedhq/replicated/pkg/telemetry"
 	"github.com/replicatedhq/replicated/pkg/types"
 	"github.com/replicatedhq/replicated/pkg/version"
 	"github.com/spf13/cobra"
@@ -110,6 +112,12 @@ func Execute(rootCmd *cobra.Command, stdin io.Reader, stdout io.Writer, stderr i
 		stdin:   stdin,
 		w:       w,
 	}
+
+	// Telemetry for tracking CLI command execution
+	var tel *telemetry.Telemetry
+	var executedCmd *cobra.Command // Track the actual executed command
+	var telemetryConsented bool    // Track if user consented to telemetry
+
 	if runCmds.rootCmd == nil {
 		runCmds.rootCmd = GetRootCmd()
 	}
@@ -406,7 +414,26 @@ func Execute(rootCmd *cobra.Command, stdin io.Reader, stdout io.Writer, stderr i
 		commonAPI := client.NewClient(platformOrigin, apiToken, kurlDotSHOrigin)
 		runCmds.api = commonAPI
 
-		// Print update info from cache, then start background update for next time
+		// Check telemetry consent FIRST (before any background tasks) for clean prompt
+		// Only check once per Execute() call
+		if apiToken != "" && !telemetryConsented {
+			// This may prompt user on first run - do it synchronously before background tasks
+			telemetryConsented = telemetry.CheckAndPromptConsent()
+		}
+
+		// Initialize telemetry if consented
+		if apiToken != "" && telemetryConsented {
+			tel = telemetry.New(apiToken, platformOrigin)
+			if tel != nil {
+				// Capture the actual executed command for telemetry
+				executedCmd = cmd
+				tel.RecordCommandStart(cmd)
+				// Store telemetry in runners so commands can access it
+				runCmds.telemetry = tel
+			}
+		}
+
+		// Start background tasks AFTER consent prompt completes
 		version.PrintIfUpgradeAvailable()
 		version.CheckForUpdatesInBackground(version.Version(), "replicatedhq/replicated/cli")
 
@@ -495,7 +522,33 @@ func Execute(rootCmd *cobra.Command, stdin io.Reader, stdout io.Writer, stderr i
 
 	runCmds.rootCmd.AddCommand(Version())
 
-	return runCmds.rootCmd.Execute()
+	// Execute the command and capture any error
+	executeErr := runCmds.rootCmd.Execute()
+
+	// Always send telemetry after command completes (even if it errored)
+	// This ensures telemetry is sent regardless of PreRunE/RunE/PostRunE failures
+	if tel != nil {
+		// Use the actual executed command if captured, otherwise fall back to root
+		cmdToRecord := executedCmd
+		if cmdToRecord == nil {
+			cmdToRecord = runCmds.rootCmd
+		}
+
+		tel.RecordCommandComplete(cmdToRecord, executeErr)
+
+		// In debug mode, wait briefly for goroutine to complete so we can see telemetry output
+		// Use shorter wait in CI to avoid unnecessary delays in automated environments
+		if debugFlag {
+			waitTime := 2 * time.Second
+			// Check if we're in CI - if so, use shorter wait
+			if os.Getenv("CI") == "true" || os.Getenv("GITHUB_ACTIONS") == "true" {
+				waitTime = 500 * time.Millisecond
+			}
+			time.Sleep(waitTime)
+		}
+	}
+
+	return executeErr
 }
 
 func printIfError(cmd *cobra.Command, err error) {

cli/cmd/runner.go

@@ -8,6 +8,7 @@ import (
 	"github.com/replicatedhq/replicated/client"
 	"github.com/replicatedhq/replicated/pkg/kotsclient"
 	"github.com/replicatedhq/replicated/pkg/platformclient"
+	"github.com/replicatedhq/replicated/pkg/telemetry"
 	"github.com/spf13/cobra"
 	"helm.sh/helm/v3/pkg/cli/values"
 )
@@ -25,8 +26,9 @@ type runners struct {
 	outputFormat string
 	w            *tabwriter.Writer
 
-	rootCmd *cobra.Command
-	args    runnerArgs
+	rootCmd   *cobra.Command
+	args      runnerArgs
+	telemetry *telemetry.Telemetry // Telemetry for tracking command execution
 }
 
 func (r *runners) hasApp() bool {