Merge pull request #220 from bytecodealliance/ydnar/verbose

cmd/wit-bindgen-go, wit/logging: add logging package, verbose (-v) and debug (-vv) flags

Author: ydnar

CHANGELOG.md

@@ -4,10 +4,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+### Added
+
+- `wit-bindgen-go` now accepts arguments that control the level of logging output on stderr. Verbose mode (`-v` or `--verbose`) will print informational log lines, warnings, and errors. Debug mode (`-vv` or `--debug`) will emit finer-grained debugging information. By default, `wit-bindgen-go` will print warnings or errors.
+
 ### Fixed
 
 - [#215](https://github.com/bytecodealliance/wasm-tools-go/issues/215): generate variant accessor methods with the correct scope for Go names.
 
+### New Contributors
+
+- [@vados-cosmonic](https://github.com/vados-cosmonic): [#212](https://github.com/bytecodealliance/wasm-tools-go/issues/212) and [#214](https://github.com/bytecodealliance/wasm-tools-go/pull/214) — verbose logging controls in `wit-bindgen-go`.
+
 ## [v0.3.0] — 2024-10-11
 
 ### Added

cmd/wit-bindgen-go/cmd/generate/generate.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bytecodealliance/wasm-tools-go/internal/go/gen"
 	"github.com/bytecodealliance/wasm-tools-go/internal/witcli"
 	"github.com/bytecodealliance/wasm-tools-go/wit/bindgen"
+	"github.com/bytecodealliance/wasm-tools-go/wit/logging"
 	"github.com/urfave/cli/v3"
 )
 
@@ -66,6 +67,7 @@ var Command = &cli.Command{
 
 // Config is the configuration for the `generate` command.
 type config struct {
+	logger    logging.Logger
 	dryRun    bool
 	out       string
 	outPerm   os.FileMode
@@ -90,6 +92,7 @@ func action(ctx context.Context, cmd *cli.Command) error {
 
 	packages, err := bindgen.Go(res,
 		bindgen.GeneratedBy(cmd.Root().Name),
+		bindgen.Logger(cfg.logger),
 		bindgen.World(cfg.world),
 		bindgen.PackageRoot(cfg.pkgRoot),
 		bindgen.Versioned(cfg.versioned),
@@ -103,14 +106,15 @@ func action(ctx context.Context, cmd *cli.Command) error {
 }
 
 func parseFlags(cmd *cli.Command) (*config, error) {
+	logger := witcli.Logger(cmd.Bool("verbose"), cmd.Bool("debug"))
 	dryRun := cmd.Bool("dry-run")
 	out := cmd.String("out")
 
 	info, err := witcli.FindOrCreateDir(out)
 	if err != nil {
 		return nil, err
 	}
-	fmt.Fprintf(os.Stderr, "Output dir: %s\n", out)
+	logger.Infof("Output dir: %s\n", out)
 	outPerm := info.Mode().Perm()
 
 	pkgRoot := cmd.String("package-root")
@@ -120,14 +124,15 @@ func parseFlags(cmd *cli.Command) (*config, error) {
 			return nil, err
 		}
 	}
-	fmt.Fprintf(os.Stderr, "Package root: %s\n", pkgRoot)
+	logger.Infof("Package root: %s\n", pkgRoot)
 
 	path, err := witcli.LoadPath(cmd.Args().Slice()...)
 	if err != nil {
 		return nil, err
 	}
 
 	return &config{
+		logger,
 		dryRun,
 		out,
 		outPerm,
@@ -141,21 +146,21 @@ func parseFlags(cmd *cli.Command) (*config, error) {
 }
 
 func writeGoPackages(packages []*gen.Package, cfg *config) error {
-	fmt.Fprintf(os.Stderr, "Generated %d package(s)\n", len(packages))
+	cfg.logger.Infof("Generated %d Go package(s)\n", len(packages))
 	for _, pkg := range packages {
 		if !pkg.HasContent() {
-			fmt.Fprintf(os.Stderr, "Skipping empty package: %s\n", pkg.Path)
+			cfg.logger.Debugf("Skipped empty package: %s\n", pkg.Path)
 			continue
 		}
-		fmt.Fprintf(os.Stderr, "Generated package: %s\n", pkg.Path)
+		cfg.logger.Infof("Generated package: %s\n", pkg.Path)
 
 		for _, filename := range codec.SortedKeys(pkg.Files) {
 			file := pkg.Files[filename]
 			dir := filepath.Join(cfg.out, strings.TrimPrefix(file.Package.Path, cfg.pkgRoot))
 			path := filepath.Join(dir, file.Name)
 
 			if !file.HasContent() {
-				fmt.Fprintf(os.Stderr, "Skipping empty file: %s\n", path)
+				cfg.logger.Debugf("\tSkipping empty file: %s\n", path)
 				continue
 			}
 
@@ -168,9 +173,9 @@ func writeGoPackages(packages []*gen.Package, cfg *config) error {
 				if content == nil {
 					return err
 				}
-				fmt.Fprintf(os.Stderr, "Error formatting file: %v\n", err)
+				cfg.logger.Errorf("\tError formatting file: %v\n", err)
 			} else {
-				fmt.Fprintf(os.Stderr, "Generated file: %s\n", path)
+				cfg.logger.Infof("\t%s\n", path)
 			}
 
 			if cfg.dryRun {

cmd/wit-bindgen-go/main.go

@@ -4,61 +4,67 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"runtime/debug"
 
 	"github.com/urfave/cli/v3"
 
 	"github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go/cmd/generate"
 	"github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go/cmd/wit"
+	"github.com/bytecodealliance/wasm-tools-go/internal/witcli"
 )
 
-var (
-	version       = ""
-	revision      = ""
-	versionString = ""
-)
-
-func init() {
-	build, ok := debug.ReadBuildInfo()
-	if !ok {
-		return
-	}
-	version = build.Main.Version
-	for _, s := range build.Settings {
-		switch s.Key {
-		case "vcs.revision":
-			revision = s.Value
-		}
-	}
-	if version == "" {
-		version = "(none)"
-	}
-	versionString = version
-	if revision != "" {
-		versionString += " (" + revision + ")"
+func main() {
+	err := Command.Run(context.Background(), os.Args)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
 	}
 }
 
-func main() {
-	cmd := &cli.Command{
-		Name:  "wit-bindgen-go",
-		Usage: "inspect or manipulate WebAssembly Interface Types for Go",
-		Commands: []*cli.Command{
-			generate.Command,
-			wit.Command,
+var Command = &cli.Command{
+	Name:  "wit-bindgen-go",
+	Usage: "inspect or manipulate WebAssembly Interface Types for Go",
+	Commands: []*cli.Command{
+		generate.Command,
+		wit.Command,
+		version,
+	},
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:        "version",
+			Usage:       "print the version",
+			HideDefault: true,
+			Local:       true,
 		},
-		Flags: []cli.Flag{
-			&cli.BoolFlag{
-				Name:  "force-wit",
-				Usage: "force loading WIT via wasm-tools",
-			},
+		&cli.BoolFlag{
+			Name:  "force-wit",
+			Usage: "force loading WIT via wasm-tools",
 		},
-		Version: versionString,
-	}
+		&cli.BoolFlag{
+			Name:    "verbose",
+			Aliases: []string{"v"},
+			Usage:   "print verbose logging messages",
+		},
+		&cli.BoolFlag{
+			Name:    "debug",
+			Aliases: []string{"vv"},
+			Usage:   "print debug logging messages",
+		},
+	},
+	Action: action,
+}
 
-	err := cmd.Run(context.Background(), os.Args)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
-		os.Exit(1)
+func action(ctx context.Context, cmd *cli.Command) error {
+	if cmd.Bool("version") {
+		return version.Run(ctx, nil)
 	}
+	return cli.ShowAppHelp(cmd)
+}
+
+var version = &cli.Command{
+	Name:  "version",
+	Usage: "print the version",
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		fmt.Printf("%s version %s\n", cmd.Root().Name, witcli.Version())
+		return nil
+	},
 }

cmd/wit-bindgen-go/main_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"testing"
+)
+
+// TestSimpleGenVerbosity ensures that a basic generation case honors the verbose flag
+func TestSimpleGenVerbosity(t *testing.T) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd := Command
+	cmd.Writer = &stdout
+	cmd.ErrWriter = &stderr
+
+	args := []string{
+		"wit-bindgen-go",
+		"generate",
+		"--world",
+		"http-fetch-simple",
+		"--dry-run",
+		"../../testdata/codegen/simple-http.wit",
+	}
+
+	// Run the app without verbose
+	cmd.Run(context.Background(), args)
+	if stderr.Len() != 0 {
+		t.Errorf("output was written to stderr despite lack of --verbose")
+	}
+
+	stdout.Reset()
+	stderr.Reset()
+
+	cmd.Run(context.Background(), append(args, "-v"))
+	if stderr.Len() == 0 {
+		t.Errorf("no output was written to stderr when -v was used")
+	}
+
+	cmd.Run(context.Background(), append(args, "-vv"))
+	if stderr.Len() == 0 {
+		t.Errorf("no output was written to stderr when -vv was used")
+	}
+
+	cmd.Run(context.Background(), append(args, "--verbose"))
+	if stderr.Len() == 0 {
+		t.Errorf("no output was written to stderr when --verbose was used")
+	}
+}

internal/witcli/logger.go

@@ -0,0 +1,18 @@
+package witcli
+
+import (
+	"os"
+
+	"github.com/bytecodealliance/wasm-tools-go/wit/logging"
+)
+
+// Logger returns a [logging.Logger] that outputs to stdout.
+func Logger(verbose, debug bool) logging.Logger {
+	level := logging.LevelWarn
+	if debug {
+		level = logging.LevelDebug
+	} else if verbose {
+		level = logging.LevelInfo
+	}
+	return logging.NewLogger(os.Stderr, level)
+}

internal/witcli/version.go

@@ -0,0 +1,34 @@
+package witcli
+
+import (
+	"runtime/debug"
+	"sync"
+)
+
+// Version returns the version string of this module.
+func Version() string {
+	return versionString()
+}
+
+var versionString = sync.OnceValue(func() string {
+	build, ok := debug.ReadBuildInfo()
+	if !ok {
+		return "(none)"
+	}
+	version := build.Main.Version
+	var revision string
+	for _, s := range build.Settings {
+		switch s.Key {
+		case "vcs.revision":
+			revision = s.Value
+		}
+	}
+	if version == "" {
+		version = "(none)"
+	}
+	versionString := version
+	if revision != "" {
+		versionString += " (" + revision + ")"
+	}
+	return versionString
+})