@automattic/vip 4.1.4 → 4.1.5

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

@@ -31,6 +31,7 @@ func DevEnvCmd() *cobra.Command {
 		devEnvEnvvarCmd(),
 		devEnvImportCmd(),
 	)
+	installDevEnvTelemetry(root)
 	return root
 }
 

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

@@ -116,9 +116,13 @@ func envvarSetCmd() *cobra.Command {
 			// a valid shell identifier and the container silently ignores it.
 			name := strings.TrimSpace(args[0])
 			if name == "" {
+				devEnvTrackingSpecial(cmd, "dev_env_envvar_set_invalid_name")
+				devEnvTrackingCancelled(cmd)
 				return errors.New("variable name is required")
 			}
 			if err := envvar.ValidateName(name); err != nil {
+				devEnvTrackingSpecial(cmd, "dev_env_envvar_set_invalid_name")
+				devEnvTrackingCancelled(cmd)
 				return err
 			}
 			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will set variable %q for environment %q: fromFile=%t", name, slug, fromFile != "")
@@ -138,6 +142,8 @@ func envvarSetCmd() *cobra.Command {
 			default:
 				value, err = appctx.Input(cmd, fmt.Sprintf("Value for %s", name), "")
 				if err != nil {
+					devEnvTrackingSpecial(cmd, "dev_env_envvar_set_user_cancelled_input")
+					devEnvTrackingCancelled(cmd)
 					return err
 				}
 			}

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

@@ -324,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 {
@@ -612,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
 					}
@@ -690,6 +692,7 @@ func devEnvDestroyCmd() *cobra.Command {
 					return err
 				}
 				if !ok {
+					devEnvTrackingCancelled(cmd)
 					return nil
 				}
 			}
@@ -766,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()
+}

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

@@ -0,0 +1,322 @@
+package commands
+
+import (
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Automattic/vip/internal/devenv"
+	"github.com/Automattic/vip/internal/devenv/paths"
+	"github.com/Automattic/vip/internal/telemetry"
+	"github.com/spf13/cobra"
+)
+
+type devEnvCapturedEvent struct {
+	name  string
+	props map[string]any
+}
+
+type devEnvEventClient struct{ events []devEnvCapturedEvent }
+
+func (c *devEnvEventClient) TrackEvent(name string, props map[string]any) error {
+	copyProps := make(map[string]any, len(props))
+	for k, v := range props {
+		copyProps[k] = v
+	}
+	c.events = append(c.events, devEnvCapturedEvent{name: name, props: copyProps})
+	return nil
+}
+
+func TestDevEnvTrackingInfoOmitsCredentials(t *testing.T) {
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	slug := "example-site"
+	if err := os.MkdirAll(paths.EnvironmentPath(slug), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	data := []byte(`{"siteSlug":"example-site","wpTitle":"Example Site","php":"php-fpm:8.4","adminPassword":"local-password","autologinKey":"local-key","envVars":{"API_TOKEN":"private-value"},"overrides":"API_TOKEN: private-value"}`)
+	if err := os.WriteFile(filepath.Join(paths.EnvironmentPath(slug), "instance_data.json"), data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	got := devEnvTrackingInfo(slug)
+	if got["slug"] != slug || got["site_slug"] != slug || got["wp_title"] != "Example Site" || got["php"] != "8.4" {
+		t.Fatalf("safe tracking properties = %#v", got)
+	}
+	for _, key := range []string{"admin_password", "autologin_key", "env_vars", "overrides"} {
+		if _, ok := got[key]; ok {
+			t.Errorf("credential-bearing property %q was included", key)
+		}
+	}
+}
+
+func TestDevEnvTrackingInfoMissingRecord(t *testing.T) {
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	got := devEnvTrackingInfo("missing")
+	if len(got) != 1 || got["slug"] != "missing" {
+		t.Fatalf("missing-record tracking properties = %#v, want slug only", got)
+	}
+}
+
+func TestDevEnvTrackingInfoMapsLegacyFields(t *testing.T) {
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	slug := "legacy-site"
+	if err := os.MkdirAll(paths.EnvironmentPath(slug), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	data := []byte(`{"siteSlug":"legacy-site","clientCode":{"repo":"example"},"elasticsearchEnabled":true}`)
+	if err := os.WriteFile(filepath.Join(paths.EnvironmentPath(slug), "instance_data.json"), data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	got := devEnvTrackingInfo(slug)
+	if got["app_code"] != `{"repo":"example"}` || got["elasticsearch"] != true {
+		t.Fatalf("legacy tracking properties = %#v", got)
+	}
+	if _, ok := got["client_code"]; ok {
+		t.Fatalf("legacy field was sent directly: %#v", got)
+	}
+}
+
+func TestDevEnvCommandTelemetryAfterSlugResolution(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	info := &cobra.Command{Use: "info", RunE: func(cmd *cobra.Command, _ []string) error {
+		_, err := ResolveSlug(cmd)
+		return err
+	}}
+	addSlugFlag(info)
+	root.AddCommand(info)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"info", "--slug=example-site"})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.events) != 2 || client.events[0].name != "dev_env_info_command_execute" || client.events[1].name != "dev_env_info_command_success" {
+		t.Fatalf("events = %#v", client.events)
+	}
+	if client.events[0].props["slug"] != "example-site" {
+		t.Fatalf("execute properties = %#v", client.events[0].props)
+	}
+}
+
+func TestDevEnvTelemetryDoesNotStartBeforeSlugResolution(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	t.Chdir(t.TempDir())
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	info := &cobra.Command{Use: "info", RunE: func(cmd *cobra.Command, _ []string) error {
+		_, err := ResolveSlug(cmd)
+		return err
+	}}
+	addSlugFlag(info)
+	root.AddCommand(info)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"info"})
+	if err := root.Execute(); err == nil {
+		t.Fatal("expected missing environment to fail")
+	}
+	if len(client.events) != 0 {
+		t.Fatalf("events before slug resolution = %#v", client.events)
+	}
+}
+
+func TestDevEnvTelemetryRecordsCommandError(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	logs := &cobra.Command{Use: "logs", RunE: func(cmd *cobra.Command, _ []string) error {
+		if _, err := ResolveSlug(cmd); err != nil {
+			return err
+		}
+		return errors.New("log stream failed")
+	}}
+	addSlugFlag(logs)
+	root.AddCommand(logs)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"logs", "--slug=example-site"})
+	if err := root.Execute(); err == nil {
+		t.Fatal("expected logs to fail")
+	}
+	if len(client.events) != 2 || client.events[1].name != "dev_env_logs_command_error" || client.events[1].props["failure"] != "log stream failed" {
+		t.Fatalf("error events = %#v", client.events)
+	}
+}
+
+func TestDevEnvCreateEmitsCommandEvents(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	t.Chdir(t.TempDir())
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := DevEnvCmd()
+	root.SetOut(io.Discard)
+	root.SetErr(io.Discard)
+	root.SetArgs([]string{"create", "--slug=example-site", "--title=Example Site"})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.events) != 2 || client.events[0].name != "dev_env_create_command_execute" || client.events[1].name != "dev_env_create_command_success" {
+		t.Fatalf("create events = %#v", client.events)
+	}
+	if client.events[0].props["slug"] != "example-site" {
+		t.Fatalf("create properties = %#v", client.events[0].props)
+	}
+}
+
+func TestDevEnvImportSQLTracksDumpType(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	file := filepath.Join(t.TempDir(), "export.sql")
+	if err := os.WriteFile(file, []byte("-- ordinary SQL export\nCREATE TABLE wp_posts (id int);\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	imp := &cobra.Command{Use: "import"}
+	sql := &cobra.Command{Use: "sql", RunE: func(cmd *cobra.Command, _ []string) error {
+		_, err := ResolveSlug(cmd)
+		return err
+	}}
+	addSlugFlag(sql)
+	imp.AddCommand(sql)
+	root.AddCommand(imp)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"import", "sql", "--slug=example-site", file})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.events) != 2 || client.events[0].props["sqldump_type"] != "MYSQLDUMP" {
+		t.Fatalf("import SQL events = %#v", client.events)
+	}
+}
+
+func TestDevEnvEnvvarSetInvalidNameEvent(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := DevEnvCmd()
+	root.SetOut(io.Discard)
+	root.SetErr(io.Discard)
+	root.SetArgs([]string{"envvar", "set", "--slug=example-site", "invalid-name", "value"})
+	if err := root.Execute(); err == nil {
+		t.Fatal("expected invalid variable name to fail")
+	}
+	if len(client.events) != 2 || client.events[0].name != "dev_env_envvar_set_command_execute" || client.events[1].name != "dev_env_envvar_set_invalid_name" {
+		t.Fatalf("invalid-name events = %#v", client.events)
+	}
+}
+
+func TestDevEnvEventNamesCoverEveryCommandLeaf(t *testing.T) {
+	root := DevEnvCmd()
+	seen := map[string]bool{}
+	var walk func(*cobra.Command, string)
+	walk = func(parent *cobra.Command, prefix string) {
+		for _, child := range parent.Commands() {
+			path := strings.TrimSpace(prefix + " " + child.Name())
+			if child.RunE != nil {
+				if _, ok := devEnvEventNames[path]; !ok {
+					t.Errorf("no event name for %q", path)
+				}
+				seen[path] = true
+			}
+			walk(child, path)
+		}
+	}
+	walk(root, "")
+	for path := range devEnvEventNames {
+		if !seen[path] {
+			t.Errorf("event name %q has no command leaf", path)
+		}
+	}
+}
+
+func TestDevEnvAllCommandUsesAllProperty(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	info := &cobra.Command{Use: "info", RunE: func(*cobra.Command, []string) error { return nil }}
+	info.Flags().Bool("all", false, "")
+	root.AddCommand(info)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"info", "--all"})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.events) != 2 || client.events[0].props["all"] != true || client.events[1].props["all"] != true {
+		t.Fatalf("all events = %#v", client.events)
+	}
+}
+
+func TestDevEnvSyncNotRunningUsesNodeEvent(t *testing.T) {
+	t.Setenv("DO_NOT_TRACK", "")
+	t.Setenv("GO_ENV", "")
+	t.Setenv("NODE_ENV", "")
+	client := &devEnvEventClient{}
+	old := GetConfig()
+	SetConfig(Config{Tracker: &telemetry.Tracker{Clients: []telemetry.Client{client}}})
+	t.Cleanup(func() { SetConfig(old) })
+
+	root := &cobra.Command{Use: "dev-env"}
+	sync := &cobra.Command{Use: "sync"}
+	sql := &cobra.Command{Use: "sql", RunE: func(cmd *cobra.Command, _ []string) error {
+		devEnvTrackingBegin(cmd, map[string]any{"slug": "example-site", "app": 123, "env": "develop", "multisite": false})
+		return devenv.ErrEnvironmentNotStarted
+	}}
+	sync.AddCommand(sql)
+	root.AddCommand(sync)
+	installDevEnvTelemetry(root)
+	root.SetArgs([]string{"sync", "sql"})
+	if err := root.Execute(); !errors.Is(err, devenv.ErrEnvironmentNotStarted) {
+		t.Fatalf("got error %v", err)
+	}
+	if len(client.events) != 2 || client.events[1].name != "dev_env_sync_sql_command_env_not_running_error" || client.events[1].props["errorMessage"] != "Environment was not running" {
+		t.Fatalf("sync events = %#v", client.events)
+	}
+}