@automattic/vip 4.1.3 → 4.1.5

package/cmd/vip-next/commands/devenv_lifecycle.go

@@ -152,16 +152,24 @@ const devEnvWizardIntro = "This is a wizard to help you set up your local dev en
 	"matching flags (or --non-interactive) to skip the wizard, and use --slug to\n" +
 	"create multiple environments with different settings.\n\n"
 
-// devEnvPHPChoices are the offered PHP versions with Node's labels
+// devEnvPHPChoices are the offered PHP versions with Node's base labels
 // (DEV_ENVIRONMENT_PHP_VERSIONS); the value is the bare version, which NewView
-// resolves to the php-fpm image. The first entry is the recommended default.
+// resolves to the php-fpm image. phpChoiceLabel marks the configured default as
+// recommended without depending on list order.
 var devEnvPHPChoices = []struct{ Label, Version string }{
-	{"8.2 (recommended)", "8.2"},
+	{"8.2", "8.2"},
 	{"8.3", "8.3"},
 	{"8.4", "8.4"},
 	{"8.5 (experimental)", "8.5"},
 }
 
+func phpChoiceLabel(label, version string) string {
+	if version == compose.DefaultPHPVersion {
+		return label + " (recommended)"
+	}
+	return label
+}
+
 // validatePHPVersion ports resolvePhpVersion's rejection
 // (dev-environment-cli.ts:778-782): an unsupported version must fail BEFORE the
 // environment is written, otherwise a typo only surfaces later as an opaque
@@ -188,7 +196,7 @@ func validatePHPVersion(php string) error {
 func phpLabels() []string {
 	labels := make([]string, len(devEnvPHPChoices))
 	for i, c := range devEnvPHPChoices {
-		labels[i] = c.Label
+		labels[i] = phpChoiceLabel(c.Label, c.Version)
 	}
 	return labels
 }
@@ -196,7 +204,7 @@ func phpLabels() []string {
 // phpVersionForLabel maps a wizard PHP label back to its bare version.
 func phpVersionForLabel(label string) string {
 	for _, c := range devEnvPHPChoices {
-		if c.Label == label {
+		if phpChoiceLabel(c.Label, c.Version) == label {
 			return c.Version
 		}
 	}
@@ -208,12 +216,19 @@ func phpVersionForLabel(label string) string {
 func phpLabelForVersion(version string) string {
 	for _, c := range devEnvPHPChoices {
 		if c.Version == version {
-			return c.Label
+			return phpChoiceLabel(c.Label, c.Version)
 		}
 	}
 	return ""
 }
 
+func phpDefaultLabel(version string) string {
+	if version == "" {
+		version = compose.DefaultPHPVersion
+	}
+	return phpLabelForVersion(version)
+}
+
 // selectWithDefault prompts with options, moving dflt to the front so it is the
 // pre-selected default when present; otherwise the first option is the default.
 func selectWithDefault(cmd *cobra.Command, message string, options []string, dflt string) (string, error) {
@@ -309,6 +324,7 @@ func runDevEnvCreate(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return err
 	}
+	devEnvTrackingCreate(cmd, cfg.Slug)
 	ctx, finish := openDevEnvLog(cmd, cfg.Slug, true)
 	defer finish()
 	if err := devenv.Create(ctx, cfg); err != nil {
@@ -441,22 +457,26 @@ func resolveCreateConfig(cmd *cobra.Command, defaults *createDefaults) (devenv.C
 		cfg.MultisiteMode = normalizeMultisite(msDefaultChoice)
 	}
 
-	// php (default from the app env, else recommended; empty => NewView resolves
-	// to php-fpm:8.2). The wizard lists the versions with Node's
-	// recommended/experimental labels, pre-selecting the app's version.
+	// php (default from the app env, else recommended). The wizard lists the
+	// versions with Node's recommended/experimental labels, pre-selecting the
+	// app's version.
+	phpDefaultVersion := d.PHP
+	if phpDefaultVersion == "" {
+		phpDefaultVersion = compose.DefaultPHPVersion
+	}
 	if f.Changed("php") {
 		cfg.PHP, _ = f.GetString("php")
 		if err := validatePHPVersion(cfg.PHP); err != nil {
 			return cfg, err
 		}
 	} else if interactive {
-		sel, err := selectWithDefault(cmd, "PHP version", phpLabels(), phpLabelForVersion(d.PHP))
+		sel, err := selectWithDefault(cmd, "PHP version", phpLabels(), phpDefaultLabel(d.PHP))
 		if err != nil {
 			return cfg, err
 		}
 		cfg.PHP = phpVersionForLabel(sel)
 	} else {
-		cfg.PHP = d.PHP
+		cfg.PHP = phpDefaultVersion
 	}
 
 	// wordpress (default from the app env, else trunk; empty => NewView resolves
@@ -593,6 +613,7 @@ func devEnvStartCmd() *cobra.Command {
 					msg := fmt.Sprintf("Found an existing Lando environment %q. vip-next will take it over — reusing its database and removing the old Lando containers (your data volume is kept). This process is irreversible. Continue?", slug)
 					confirmed, cerr := appctx.Confirm(cmd, msg, false)
 					if cerr == appctx.ErrNonInteractive || (!confirmed && cerr == nil) {
+						devEnvTrackingCancelled(cmd)
 						fmt.Fprintln(cmd.OutOrStdout(), "Command cancelled")
 						return nil
 					}
@@ -671,6 +692,7 @@ func devEnvDestroyCmd() *cobra.Command {
 					return err
 				}
 				if !ok {
+					devEnvTrackingCancelled(cmd)
 					return nil
 				}
 			}
@@ -747,9 +769,13 @@ func devEnvPurgeCmd() *cobra.Command {
 					return err
 				}
 				if !ok {
+					devEnvTrackingCancelled(cmd)
 					return nil
 				}
 			}
+			if len(instancedata.AllNames()) > 0 {
+				devEnvTrackingBegin(cmd, map[string]any{"all": true})
+			}
 			return devenv.Purge(cmd.Context(), soft)
 		}}
 	c.Flags().BoolVar(&yes, "yes", false, "Skip the confirmation prompt.")

package/cmd/vip-next/commands/devenv_resolve.go

@@ -31,7 +31,9 @@ import (
 // environment found" error / DEFAULT_SLUG fallback.
 func ResolveSlug(cmd *cobra.Command) (string, error) {
 	if s, _ := cmd.Flags().GetString("slug"); s != "" {
-		return nodeflags.ProcessSlug(s), nil
+		slug := nodeflags.ProcessSlug(s)
+		devEnvTrackingResolved(cmd, slug)
+		return slug, nil
 	}
 	if err := rejectAppEnvAlias(cmd); err != nil {
 		return "", err
@@ -46,10 +48,15 @@ func ResolveSlug(cmd *cobra.Command) (string, error) {
 // options before calling getEnvironmentName (vip-dev-env-sync-sql.js:98).
 func ResolveLocalSlug(cmd *cobra.Command) (string, error) {
 	if s, _ := cmd.Flags().GetString("slug"); s != "" {
-		return nodeflags.ProcessSlug(s), nil
+		slug := nodeflags.ProcessSlug(s)
+		devEnvTrackingResolved(cmd, slug)
+		return slug, nil
 	}
 	slug, err := configFileSlug(cmd)
 	if err != nil || slug != "" {
+		if err == nil {
+			devEnvTrackingResolved(cmd, slug)
+		}
 		return slug, err
 	}
 	names := instancedata.AllNames()
@@ -57,10 +64,15 @@ func ResolveLocalSlug(cmd *cobra.Command) (string, error) {
 	case 0:
 		return "", errors.New("no dev environments found; create one with `vip dev-env create`")
 	case 1:
+		devEnvTrackingResolved(cmd, names[0])
 		return names[0], nil
 	}
 	if appctx.IsInteractive(cmd) {
-		return appctx.Select(cmd, "Which environment?", names)
+		slug, err := appctx.Select(cmd, "Which environment?", names)
+		if err == nil {
+			devEnvTrackingResolved(cmd, slug)
+		}
+		return slug, err
 	}
 	return "", fmt.Errorf("multiple environments found; specify --slug: %w", appctx.ErrNonInteractive)
 }

package/cmd/vip-next/commands/devenv_telemetry.go

@@ -0,0 +1,265 @@
+package commands
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/Automattic/vip/internal/appctx"
+	"github.com/Automattic/vip/internal/devenv"
+	"github.com/Automattic/vip/internal/devenv/dockercli"
+	"github.com/Automattic/vip/internal/devenv/paths"
+	"github.com/Automattic/vip/internal/searchreplace"
+	"github.com/Automattic/vip/internal/telemetry"
+	"github.com/spf13/cobra"
+)
+
+type devEnvTelemetryKey struct{}
+
+type devEnvTelemetryState struct {
+	name     string
+	args     []string
+	info     map[string]any
+	started  time.Time
+	canceled bool
+}
+
+var devEnvEventNames = map[string]string{
+	"create": "dev_env_create_command_", "start": "dev_env_start_command_",
+	"stop": "dev_env_stop_command_", "destroy": "dev_env_destroy_command_",
+	"info": "dev_env_info_command_", "list": "dev_env_list_command_",
+	"purge": "dev_env_purge_command_", "update": "dev_env_update_command_",
+	"exec": "dev_env_exec_command_", "shell": "dev_env_shell_command_",
+	"logs": "dev_env_logs_command_", "import sql": "dev_env_import_sql_command_",
+	"import media": "dev_env_import_media_command_", "sync sql": "dev_env_sync_sql_command_",
+	"envvar get": "dev_env_envvar_get_command_", "envvar get-all": "dev_env_envvar_get_all_command_",
+	"envvar list": "dev_env_envvar_list_command_", "envvar set": "dev_env_envvar_set_command_",
+	"envvar delete": "dev_env_envvar_delete_command_",
+}
+
+// installDevEnvTelemetry wraps leaves after their middleware is built. Slug
+// commands emit execute from ResolveSlug, after resolution as Node does.
+func installDevEnvTelemetry(root *cobra.Command) {
+	var visit func(*cobra.Command, string)
+	visit = func(parent *cobra.Command, prefix string) {
+		for _, child := range parent.Commands() {
+			path := strings.TrimSpace(prefix + " " + child.Name())
+			if child.RunE != nil {
+				if name, ok := devEnvEventNames[path]; ok {
+					original := child.RunE
+					child.RunE = func(cmd *cobra.Command, args []string) error {
+						state := &devEnvTelemetryState{name: name, args: args}
+						ctx := cmd.Context()
+						if ctx == nil {
+							ctx = context.Background()
+						}
+						cmd.SetContext(context.WithValue(ctx, devEnvTelemetryKey{}, state))
+						if path == "list" || ((path == "info" || path == "stop") && devEnvAllFlag(cmd)) {
+							devEnvTrackingBegin(cmd, map[string]any{"all": true})
+						}
+						err := original(cmd, args)
+						if state.started.IsZero() || state.canceled {
+							return err
+						}
+						if err != nil {
+							if path == "sync sql" && errors.Is(err, devenv.ErrEnvironmentNotStarted) {
+								props := devEnvTrackingCopy(state.info)
+								props["errorMessage"] = "Environment was not running"
+								trackEvent(name+"env_not_running_error", props)
+								return err
+							}
+							props := devEnvTrackingCopy(state.info)
+							props["failure"] = telemetry.ScrubErrorText(err.Error())
+							trackEvent(name+"error", props)
+							return err
+						}
+						props := devEnvTrackingCopy(state.info)
+						if path == "start" {
+							props["processing_time"] = int64(math.Ceil(time.Since(state.started).Seconds()))
+						}
+						trackEvent(name+"success", props)
+						return nil
+					}
+				}
+			}
+			visit(child, path)
+		}
+	}
+	visit(root, "")
+}
+
+func devEnvAllFlag(cmd *cobra.Command) bool {
+	if cmd.Flags().Lookup("all") == nil {
+		return false
+	}
+	all, _ := cmd.Flags().GetBool("all")
+	return all
+}
+
+func devEnvTrackingCopy(info map[string]any) map[string]any {
+	copyInfo := make(map[string]any, len(info))
+	for k, v := range info {
+		copyInfo[k] = v
+	}
+	return copyInfo
+}
+
+func devEnvTrackingState(cmd *cobra.Command) *devEnvTelemetryState {
+	ctx := cmd.Context()
+	if ctx == nil {
+		return nil
+	}
+	state, _ := ctx.Value(devEnvTelemetryKey{}).(*devEnvTelemetryState)
+	return state
+}
+
+func devEnvTrackingBegin(cmd *cobra.Command, info map[string]any) {
+	state := devEnvTrackingState(cmd)
+	if state == nil || !state.started.IsZero() {
+		return
+	}
+	state.info = devEnvTrackingCopy(info)
+	state.started = time.Now()
+	trackEvent(state.name+"execute", devEnvTrackingCopy(state.info))
+}
+
+func devEnvTrackingResolved(cmd *cobra.Command, slug string) {
+	state := devEnvTrackingState(cmd)
+	if state == nil {
+		return
+	}
+	info := devEnvTrackingInfo(slug)
+	if cmd.Name() == "sql" && cmd.Parent() != nil && cmd.Parent().Name() == "import" {
+		if len(state.args) > 0 {
+			details, err := searchreplace.GetSqlDumpDetails(state.args[0])
+			if err != nil {
+				return // Node determines dump type before its execute event.
+			}
+			info["sqldump_type"] = string(details.Type)
+		}
+	}
+	if cmd.Name() == "sql" && cmd.Parent() != nil && cmd.Parent().Name() == "sync" {
+		if ae := appctx.FromContext(cmd.Context()); ae != nil {
+			info = map[string]any{
+				"app": ae.App.ID, "env": ae.Env.UniqueLabel,
+				"slug": slug, "multisite": ae.Env.IsMultisite,
+			}
+		}
+	}
+	if cmd.Name() == "start" {
+		editor, _ := cmd.Flags().GetString("editor")
+		vscode, _ := cmd.Flags().GetBool("vscode")
+		if editor == "" && vscode {
+			editor = "vscode"
+		}
+		if editor != "" {
+			info["editor"] = editor
+		}
+		info["vscode"] = vscode
+		versions := (&dockercli.Runner{}).Versions(cmd.Context())
+		info["docker"] = versions.Engine
+		info["docker_compose"] = versions.Compose
+		info["compose_plugin"] = versions.ComposePlugin
+	}
+	devEnvTrackingBegin(cmd, info)
+}
+
+func devEnvTrackingCreate(cmd *cobra.Command, slug string) {
+	info := map[string]any{"slug": slug}
+	if app, _ := cmd.Flags().GetString("app"); app != "" {
+		info["app"] = app
+	}
+	if env, _ := cmd.Flags().GetString("env"); env != "" {
+		info["env"] = env
+	}
+	devEnvTrackingBegin(cmd, info)
+}
+
+func devEnvTrackingCancelled(cmd *cobra.Command) {
+	state := devEnvTrackingState(cmd)
+	if state != nil {
+		state.canceled = true
+	}
+}
+
+func devEnvTrackingSpecial(cmd *cobra.Command, name string) {
+	state := devEnvTrackingState(cmd)
+	if state != nil && !state.started.IsZero() {
+		trackEvent(name, devEnvTrackingCopy(state.info))
+	}
+}
+
+// devEnvTrackingInfo mirrors Node's getEnvTrackingInfo for the shared instance
+// fields. Only known Node fields are eligible: Go also stores user environment
+// variables and volume metadata in instance_data.json, neither of which belongs
+// in telemetry. Local login credentials are excluded in both runtimes.
+func devEnvTrackingInfo(slug string) map[string]any {
+	info := map[string]any{"slug": slug}
+	data, err := os.ReadFile(filepath.Join(paths.EnvironmentPath(slug), "instance_data.json"))
+	if err != nil {
+		return info
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(data, &fields); err != nil {
+		return info
+	}
+	// Node's readEnvironmentData maps these legacy names before tracking.
+	if legacy, ok := fields["clientCode"]; ok && string(legacy) != "null" {
+		fields["appCode"] = legacy
+	}
+	for _, legacyKey := range []string{"enterpriseSearchEnabled", "elasticsearchEnabled"} {
+		if legacy, ok := fields[legacyKey]; ok && string(legacy) == "true" {
+			fields["elasticsearch"] = legacy
+			break
+		}
+	}
+	for _, key := range []string{
+		"siteSlug", "wpTitle", "multisite", "wordpress", "muPlugins", "appCode",
+		"mediaRedirectDomain", "phpmyadmin", "xdebug", "xdebugConfig", "mariadb",
+		"php", "elasticsearch", "mailpit", "photon", "cron", "pullAfter",
+		"version",
+	} {
+		raw, ok := fields[key]
+		if !ok {
+			continue
+		}
+		var value any
+		if key == "wordpress" || key == "muPlugins" || key == "appCode" {
+			var compact bytes.Buffer
+			if err := json.Compact(&compact, raw); err != nil {
+				continue
+			}
+			value = compact.String()
+		} else if err := json.Unmarshal(raw, &value); err != nil {
+			continue
+		}
+		if key == "php" {
+			if php, ok := value.(string); ok {
+				if colon := strings.IndexByte(php, ':'); colon >= 0 {
+					value = php[colon+1:]
+				}
+			}
+		}
+		info[devEnvSnakeCase(key)] = value
+	}
+	return info
+}
+
+func devEnvSnakeCase(key string) string {
+	var b strings.Builder
+	for _, r := range key {
+		if r >= 'A' && r <= 'Z' {
+			b.WriteByte('_')
+			b.WriteRune(r + ('a' - 'A'))
+		} else {
+			b.WriteRune(r)
+		}
+	}
+	return b.String()
+}