feat(compute): add metadata subcommand

.fastly/config.toml

@@ -3,6 +3,11 @@ config_version = 4
 [fastly]
 api_endpoint = "https://api.fastly.com"
 
+[wasm-metadata]
+build_info = "enable"
+machine_info = "disable" # users have to opt-in for this (everything else they'll have to opt-out)
+package_info = "enable"
+
 [language]
 [language.go]
 tinygo_constraint = ">= 0.28.1-0"          # NOTE -0 indicates to the CLI's semver package that we accept pre-releases (TinyGo users commonly use pre-releases).

DEVELOP.md

@@ -58,14 +58,20 @@ CLI_CATEGORY=logging CLI_CATEGORY_COMMAND=logging CLI_PACKAGE=foobar CLI_COMMAND
 
 ### `.fastly/config.toml`
 
-The CLI dynamically generates the `./pkg/config/config.toml` within the CI release process so it can be embedded into the CLI binary. 
+The CLI dynamically generates the `./pkg/config/config.toml` within the CI release process so it can be embedded into the CLI binary.
 
 The file is added to `.gitignore` to avoid it being added to the git repository.
 
 When compiling the CLI for a new release, it will execute [`./scripts/config.sh`](./scripts/config.sh). The script uses [`./.fastly/config.toml`](./.fastly/config.toml) as a template file to then dynamically inject a list of starter kits (pulling their data from their public repositories).
 
 The resulting configuration is then saved to disk at `./pkg/config/config.toml` and embedded into the CLI when compiled.
 
+When a user installs the CLI for the first time, they'll have no existing config and so the embedded config will be used. In the future, when the user updates their CLI, the existing config they have will be used.
+
+If the config has changed in any way, then you (the CLI developer) should ensure the `config_version` number is bumped before publishing a new CLI release. This is because when the user updates to that new CLI version and the invoke the CLI, the CLI will identify a mismatch between the user's local config version and the embedded config version. This will cause the embedded config to be merged with the local config and consequently the user's config will be updated to include the new fields.
+
+> **NOTE:** The CLI does provide a `fastly config --reset` option that resets the config to a version compatible with the user's current CLI version. This is fallback for users who run into issues for whatever reason.
+
 ### Running Compute commands locally
 
 If you need to test the Fastly CLI locally while developing a Compute feature, then use the `--dir` flag (exposed on `compute build`, `compute deploy`, `compute serve` and `compute publish`) to ensure the CLI doesn't attempt to treat the repository directory as your project directory.

pkg/app/commands.go

@@ -116,6 +116,7 @@ func defineCommands(
 	computeHashFiles := compute.NewHashFilesCommand(computeCmdRoot.CmdClause, g, computeBuild)
 	computeHashsum := compute.NewHashsumCommand(computeCmdRoot.CmdClause, g, computeBuild)
 	computeInit := compute.NewInitCommand(computeCmdRoot.CmdClause, g, m)
+	computeMetadata := compute.NewMetadataCommand(computeCmdRoot.CmdClause, g)
 	computePack := compute.NewPackCommand(computeCmdRoot.CmdClause, g, m)
 	computePublish := compute.NewPublishCommand(computeCmdRoot.CmdClause, g, computeBuild, computeDeploy)
 	computeServe := compute.NewServeCommand(computeCmdRoot.CmdClause, g, computeBuild, opts.Versioners.Viceroy)
@@ -481,6 +482,7 @@ func defineCommands(
 		computeHashFiles,
 		computeHashsum,
 		computeInit,
+		computeMetadata,
 		computePack,
 		computePublish,
 		computeServe,

pkg/app/run.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/fastly/go-fastly/v8/fastly"
 	"github.com/fastly/kingpin"
@@ -96,15 +97,15 @@ func Run(opts RunOpts) error {
 	app.Flag("verbose", "Verbose logging").Short('v').BoolVar(&g.Flags.Verbose)
 
 	commands := defineCommands(app, &g, *opts.Manifest, opts)
-	command, name, err := processCommandInput(opts, app, &g, commands)
+	command, commandName, err := processCommandInput(opts, app, &g, commands)
 	if err != nil {
 		return err
 	}
 	// We short-circuit the execution for specific cases:
 	//
 	// - cmd.ArgsIsHelpJSON() == true
 	// - shell autocompletion flag provided
-	switch name {
+	switch commandName {
 	case "help--format=json":
 		fallthrough
 	case "help--formatjson":
@@ -113,6 +114,18 @@ func Run(opts RunOpts) error {
 		return nil
 	}
 
+	if !g.Config.CLI.MetadataNoticeDisplayed && commandCollectsData(commandName) {
+		// FIXME: We need the actual URL to point users to.
+		text.Important(g.Output, "The Fastly CLI is configured to collect data related to Wasm builds (e.g. compilation times, resource usage, and other non-identifying data). To learn more about what data is being collected, why, and how to disable it: https://www.fastly.com/")
+		text.Break(g.Output)
+		g.Config.CLI.MetadataNoticeDisplayed = true
+		err := g.Config.Write(g.ConfigPath)
+		if err != nil {
+			return fmt.Errorf("failed to persist change to metadata notice: %w", err)
+		}
+		time.Sleep(5 * time.Second) // this message is only displayed once so give the user a chance to see it before it possibly scrolls off screen
+	}
+
 	if g.Flags.Quiet {
 		opts.Manifest.File.SetQuiet(true)
 	}
@@ -136,7 +149,7 @@ func Run(opts RunOpts) error {
 	// If we are using the token from config file, check the file's permissions
 	// to assert if they are not too open or have been altered outside of the
 	// application and warn if so.
-	segs := strings.Split(name, " ")
+	segs := strings.Split(commandName, " ")
 	if source == lookup.SourceFile && (len(segs) > 0 && segs[0] != "profile") {
 		if fi, err := os.Stat(config.FilePath); err == nil {
 			if mode := fi.Mode().Perm(); mode > config.FilePermissions {
@@ -177,7 +190,7 @@ func Run(opts RunOpts) error {
 		return fmt.Errorf("error constructing Fastly realtime stats client: %w", err)
 	}
 
-	if opts.Versioners.CLI != nil && name != "update" && !version.IsPreRelease(revision.AppVersion) {
+	if opts.Versioners.CLI != nil && commandName != "update" && !version.IsPreRelease(revision.AppVersion) {
 		f := update.CheckAsync(
 			revision.AppVersion,
 			opts.Versioners.CLI,
@@ -246,3 +259,13 @@ func determineProfile(manifestValue, flagValue string, profiles config.Profiles)
 	name, _ := profile.Default(profiles)
 	return name
 }
+
+// commandCollectsData determines if the command to be executed is one that
+// collects data related to a Wasm binary.
+func commandCollectsData(command string) bool {
+	switch command {
+	case "compute build", "compute hashsum", "compute hash-files", "compute publish", "compute serve":
+		return true
+	}
+	return false
+}

pkg/app/run_test.go

@@ -117,7 +117,7 @@ whoami
 
 			go func() {
 				var buf bytes.Buffer
-				io.Copy(&buf, r)
+				_, _ = io.Copy(&buf, r)
 				outC <- buf.String()
 			}()
 

pkg/commands/compute/build.go

@@ -222,7 +222,7 @@ func (c *BuildCommand) Exec(in io.Reader, out io.Writer) (err error) {
 	// Also make sure hidden flags (across all composite commands) aren't hidden.
 	metadataDisable, _ := strconv.ParseBool(c.Globals.Env.WasmMetadataDisable)
 	if c.MetadataEnable && !metadataDisable {
-		if err := c.AnnotateWasmBinaryLong(wasmtools, metadataArgs, language, out); err != nil {
+		if err := c.AnnotateWasmBinaryLong(wasmtools, metadataArgs, language); err != nil {
 			return err
 		}
 	} else {
@@ -327,7 +327,7 @@ func (c *BuildCommand) AnnotateWasmBinaryShort(wasmtools string, args []string)
 }
 
 // AnnotateWasmBinaryLong annotates the Wasm binary will all available data.
-func (c *BuildCommand) AnnotateWasmBinaryLong(wasmtools string, args []string, language *Language, out io.Writer) error {
+func (c *BuildCommand) AnnotateWasmBinaryLong(wasmtools string, args []string, language *Language) error {
 	var ms runtime.MemStats
 	runtime.ReadMemStats(&ms)
 

pkg/commands/compute/metadata.go

@@ -0,0 +1,99 @@
+package compute
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/fastly/cli/pkg/cmd"
+	"github.com/fastly/cli/pkg/config"
+	fsterr "github.com/fastly/cli/pkg/errors"
+	"github.com/fastly/cli/pkg/global"
+	"github.com/fastly/cli/pkg/text"
+)
+
+// MetadataCommand controls what metadata is collected for a Wasm binary.
+type MetadataCommand struct {
+	cmd.Base
+
+	disable        bool
+	disableBuild   bool
+	disableMachine bool
+	disablePackage bool
+	enable         bool
+	enableBuild    bool
+	enableMachine  bool
+	enablePackage  bool
+}
+
+// NewMetadataCommand returns a new command registered in the parent.
+func NewMetadataCommand(parent cmd.Registerer, g *global.Data) *MetadataCommand {
+	var c MetadataCommand
+	c.Globals = g
+	c.CmdClause = parent.Command("metadata", "Control what metadata is collected")
+	c.CmdClause.Flag("disable", "Disable all metadata").BoolVar(&c.disable)
+	c.CmdClause.Flag("disable-build", "Disable metadata for information regarding the time taken for builds and compilation processes").BoolVar(&c.disableBuild)
+	c.CmdClause.Flag("disable-machine", "Disable metadata for general, non-identifying system specifications (CPU, RAM, operating system)").BoolVar(&c.disableMachine)
+	c.CmdClause.Flag("disable-package", "Disable metadata for packages and libraries utilized in your source code").BoolVar(&c.disablePackage)
+	c.CmdClause.Flag("enable", "Enable all metadata").BoolVar(&c.enable)
+	c.CmdClause.Flag("enable-build", "Enable metadata for information regarding the time taken for builds and compilation processes").BoolVar(&c.enableBuild)
+	c.CmdClause.Flag("enable-machine", "Enable metadata for general, non-identifying system specifications (CPU, RAM, operating system)").BoolVar(&c.enableMachine)
+	c.CmdClause.Flag("enable-package", "Enable metadata for packages and libraries utilized in your source code").BoolVar(&c.enablePackage)
+	return &c
+}
+
+// Exec implements the command interface.
+func (c *MetadataCommand) Exec(_ io.Reader, out io.Writer) error {
+	if c.disable && c.enable {
+		return fsterr.ErrInvalidEnableDisableFlagCombo
+	}
+	if c.disable {
+		c.Globals.Config.WasmMetadata = toggleAll("disable")
+	}
+	if c.enable {
+		c.Globals.Config.WasmMetadata = toggleAll("enable")
+	}
+	if c.disable && (c.enableBuild || c.enableMachine || c.enablePackage) {
+		text.Info(out, "We will disable all metadata except for the specified `--enable-*` flags")
+		text.Break(out)
+	}
+	if c.enable && (c.disableBuild || c.disableMachine || c.disablePackage) {
+		text.Info(out, "We will enable all metadata except for the specified `--disable-*` flags")
+		text.Break(out)
+	}
+	if c.enableBuild {
+		c.Globals.Config.WasmMetadata.BuildInfo = "enable"
+	}
+	if c.enableMachine {
+		c.Globals.Config.WasmMetadata.MachineInfo = "enable"
+	}
+	if c.enablePackage {
+		c.Globals.Config.WasmMetadata.PackageInfo = "enable"
+	}
+	if c.disableBuild {
+		c.Globals.Config.WasmMetadata.BuildInfo = "disable"
+	}
+	if c.disableMachine {
+		c.Globals.Config.WasmMetadata.MachineInfo = "disable"
+	}
+	if c.disablePackage {
+		c.Globals.Config.WasmMetadata.PackageInfo = "disable"
+	}
+	err := c.Globals.Config.Write(c.Globals.ConfigPath)
+	if err != nil {
+		return fmt.Errorf("failed to persist metadata choices to disk: %w", err)
+	}
+	text.Success(out, "configuration updated (see: `fastly config`)")
+	text.Break(out)
+	text.Output(out, "Build Information: %s", c.Globals.Config.WasmMetadata.BuildInfo)
+	text.Output(out, "Machine Information: %s", c.Globals.Config.WasmMetadata.MachineInfo)
+	text.Output(out, "Package Information: %s", c.Globals.Config.WasmMetadata.PackageInfo)
+	return nil
+}
+
+func toggleAll(state string) config.WasmMetadata {
+	var t config.WasmMetadata
+	t.BuildInfo = state
+	t.MachineInfo = state
+	t.PackageInfo = state
+	return t
+}