fix: Support external log control (#311)

* fix: Fully swap out the logger to make it configurable by callers

* fix: Explicitly plumb logger throughout the entire codebase

Author: yhakbar

cli/boilerplate_cli.go

@@ -4,13 +4,15 @@ package cli
 import (
 	"context"
 	"fmt"
+	"os"
 	"path/filepath"
 	"runtime"
 
 	"github.com/urfave/cli/v2"
 
 	"github.com/gruntwork-io/boilerplate/manifest"
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/templates"
 	"github.com/gruntwork-io/boilerplate/variables"
 	"github.com/gruntwork-io/boilerplate/version"
@@ -139,7 +141,9 @@ func runApp(cliContext *cli.Context) error {
 	// The root boilerplate.yml is not itself a dependency, so we pass an empty Dependency.
 	emptyDep := variables.Dependency{}
 
-	result, err := templates.ProcessTemplateWithContext(ctx, opts, opts, &emptyDep)
+	l := logging.New(os.Stdout, logging.LevelInfo)
+
+	result, err := templates.ProcessTemplateWithContext(ctx, l, opts, opts, &emptyDep)
 	if err != nil {
 		return err
 	}

cmd/wasm/main.go

@@ -8,6 +8,7 @@ import (
 	"syscall/js"
 
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/render"
 )
 
@@ -45,7 +46,7 @@ func renderTemplate(this js.Value, args []js.Value) any {
 		OnMissingConfig: options.Ignore,
 	}
 
-	result, err := render.RenderTemplateFromString("template", templateStr, variables, opts)
+	result, err := render.RenderTemplateFromString(logging.Discard(), "template", templateStr, variables, opts)
 	if err != nil {
 		return js.Global().Get("Error").New(fmt.Sprintf("template rendering failed: %v", err))
 	}

config/config.go

@@ -13,8 +13,8 @@ import (
 	"gopkg.in/yaml.v3"
 
 	"github.com/gruntwork-io/boilerplate/internal/fileutil"
-	"github.com/gruntwork-io/boilerplate/internal/logging"
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/util"
 	"github.com/gruntwork-io/boilerplate/variables"
 )
@@ -192,12 +192,12 @@ func (config *BoilerplateConfig) MarshalYAML() (any, error) {
 }
 
 // LoadBoilerplateConfig loads the boilerplate.yml config contents for the folder specified in the given options.
-func LoadBoilerplateConfig(opts *options.BoilerplateOptions) (*BoilerplateConfig, error) {
+func LoadBoilerplateConfig(l logging.Logger, opts *options.BoilerplateOptions) (*BoilerplateConfig, error) {
 	configPath := BoilerplateConfigPath(opts.TemplateFolder)
 
 	switch {
 	case fileutil.PathExists(configPath):
-		logging.Logger.Printf("Loading boilerplate config from %s", configPath)
+		l.Debugf("Loading boilerplate config from %s", configPath)
 
 		bytes, err := os.ReadFile(configPath)
 		if err != nil {
@@ -206,7 +206,7 @@ func LoadBoilerplateConfig(opts *options.BoilerplateOptions) (*BoilerplateConfig
 
 		return ParseBoilerplateConfig(bytes)
 	case opts.OnMissingConfig == options.Ignore:
-		logging.Logger.Printf("Warning: boilerplate config file not found at %s. The %s flag is set, so ignoring. Note that no variables will be available while generating.", configPath, options.OptMissingConfigAction)
+		l.Warnf("boilerplate config file not found at %s. The %s flag is set, so ignoring. Note that no variables will be available while generating.", configPath, options.OptMissingConfigAction)
 		return &BoilerplateConfig{}, nil
 	default:
 		// If the template URL is similar to a git URL, surface in error message that there may be a misspelling/typo.

config/config_test.go

@@ -14,6 +14,7 @@ import (
 	"gopkg.in/yaml.v3"
 
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/testutil"
 	"github.com/gruntwork-io/boilerplate/variables"
 
@@ -621,7 +622,7 @@ func TestParseBoilerplateConfigMultipleHooks(t *testing.T) {
 func TestLoadBoilerplateConfigFullConfig(t *testing.T) {
 	t.Parallel()
 
-	actual, err := LoadBoilerplateConfig(testutil.CreateTestOptions("../test-fixtures/config-test/full-config"))
+	actual, err := LoadBoilerplateConfig(logging.Discard(), testutil.CreateTestOptions("../test-fixtures/config-test/full-config"))
 	expected := &BoilerplateConfig{
 		Partials: []string{"../templates/foo"},
 		Variables: []variables.Variable{
@@ -655,7 +656,7 @@ func TestLoadBoilerplateConfigNoConfig(t *testing.T) {
 	t.Parallel()
 
 	templateFolder := "../test-fixtures/config-test/no-config"
-	_, err := LoadBoilerplateConfig(testutil.CreateTestOptions(templateFolder))
+	_, err := LoadBoilerplateConfig(logging.Discard(), testutil.CreateTestOptions(templateFolder))
 	expectedErr := BoilerplateConfigNotFound(path.Join(templateFolder, "boilerplate.yml"))
 
 	assert.ErrorIs(t, err, expectedErr, "Expected error %v but got %v", expectedErr, err)
@@ -667,7 +668,7 @@ func TestLoadBoilerplateConfigNoConfigIgnore(t *testing.T) {
 	templateFolder := "../test-fixtures/config-test/no-config"
 	opts := testutil.CreateTestOptions(templateFolder)
 	opts.OnMissingConfig = options.Ignore
-	actual, err := LoadBoilerplateConfig(opts)
+	actual, err := LoadBoilerplateConfig(logging.Discard(), opts)
 	expected := &BoilerplateConfig{}
 
 	require.NoError(t, err, "Unexpected error: %v", err)
@@ -677,7 +678,7 @@ func TestLoadBoilerplateConfigNoConfigIgnore(t *testing.T) {
 func TestLoadBoilerplateConfigInvalidConfig(t *testing.T) {
 	t.Parallel()
 
-	_, err := LoadBoilerplateConfig(testutil.CreateTestOptions("../test-fixtures/config-test/invalid-config"))
+	_, err := LoadBoilerplateConfig(logging.Discard(), testutil.CreateTestOptions("../test-fixtures/config-test/invalid-config"))
 
 	require.Error(t, err)
 

config/get_variables.go

@@ -12,8 +12,8 @@ import (
 	"github.com/AlecAivazis/survey/v2/terminal"
 	ozzo "github.com/go-ozzo/ozzo-validation"
 	"github.com/gruntwork-io/boilerplate/internal/color"
-	"github.com/gruntwork-io/boilerplate/internal/logging"
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/render"
 	"github.com/gruntwork-io/boilerplate/variables"
 	"github.com/hashicorp/go-multierror"
@@ -24,16 +24,16 @@ const MaxReferenceDepth = 20
 // GetVariables gets a value for each of the variables specified in boilerplateConfig, other than those already in existingVariables.
 // The value for a variable can come from the user (if the non-interactive option isn't set), the default value in the
 // config, or a command line option.
-func GetVariables(opts *options.BoilerplateOptions, boilerplateConfig, rootBoilerplateConfig *BoilerplateConfig, thisDep *variables.Dependency) (map[string]any, error) {
-	return GetVariablesWithContext(context.Background(), opts, boilerplateConfig, rootBoilerplateConfig, thisDep)
+func GetVariables(l logging.Logger, opts *options.BoilerplateOptions, boilerplateConfig, rootBoilerplateConfig *BoilerplateConfig, thisDep *variables.Dependency) (map[string]any, error) {
+	return GetVariablesWithContext(context.Background(), l, opts, boilerplateConfig, rootBoilerplateConfig, thisDep)
 }
 
 // GetVariablesWithContext collects variables from the user, variable defaults in the boilerplate.yml config, command line options, and environment
 // variables. Variables in Boilerplate can can be used in both the Boilerplate config itself and in the templates.
 //
 // The value for a variable can come from the user (if the non-interactive option isn't set), the default value in the
 // config, or a command line option.
-func GetVariablesWithContext(ctx context.Context, opts *options.BoilerplateOptions, boilerplateConfig, rootBoilerplateConfig *BoilerplateConfig, thisDep *variables.Dependency) (map[string]any, error) {
+func GetVariablesWithContext(ctx context.Context, l logging.Logger, opts *options.BoilerplateOptions, boilerplateConfig, rootBoilerplateConfig *BoilerplateConfig, thisDep *variables.Dependency) (map[string]any, error) {
 	renderedVariables := map[string]any{}
 
 	// Add a variable for all variables contained in the root config file. This will allow Golang template users
@@ -104,7 +104,7 @@ func GetVariablesWithContext(ctx context.Context, opts *options.BoilerplateOptio
 	for _, keyOrderPair := range keyAndOrderPairs {
 		variable := variablesInConfig[keyOrderPair.Key]
 
-		unmarshalled, err := GetValueForVariable(variable, variablesInConfig, variablesToRender, opts, 0)
+		unmarshalled, err := GetValueForVariable(l, variable, variablesInConfig, variablesToRender, opts, 0)
 		if err != nil {
 			return nil, err
 		}
@@ -114,7 +114,7 @@ func GetVariablesWithContext(ctx context.Context, opts *options.BoilerplateOptio
 
 	// Pass all the user provided variables through a rendering pipeline to ensure they are evaluated down to
 	// primitives.
-	newlyRenderedVariables, err := render.RenderVariablesWithContext(ctx, opts, variablesToRender, renderedVariables)
+	newlyRenderedVariables, err := render.RenderVariablesWithContext(ctx, l, opts, variablesToRender, renderedVariables)
 	if err != nil {
 		return nil, err
 	}
@@ -135,6 +135,7 @@ func GetVariablesWithContext(ctx context.Context, opts *options.BoilerplateOptio
 }
 
 func GetValueForVariable(
+	l logging.Logger,
 	variable variables.Variable,
 	variablesInConfig map[string]variables.Variable,
 	valuesForPreviousVariables map[string]any,
@@ -161,11 +162,11 @@ func GetValueForVariable(
 			return nil, MissingReference{VariableName: variable.Name(), ReferenceName: variable.Reference()}
 		}
 
-		return GetValueForVariable(reference, variablesInConfig, valuesForPreviousVariables, opts, referenceDepth+1)
+		return GetValueForVariable(l, reference, variablesInConfig, valuesForPreviousVariables, opts, referenceDepth+1)
 	}
 
 	// Run the value we receive from getVariable through validations, ensuring values provided by --var-files will also be checked
-	value, err := getVariable(variable, opts)
+	value, err := getVariable(l, variable, opts)
 	if err != nil {
 		return value, err
 	}
@@ -183,23 +184,23 @@ func GetValueForVariable(
 
 // Get a value for the given variable. The value can come from the user (if the non-interactive option isn't set), the
 // default value in the config, or a command line option.
-func getVariable(variable variables.Variable, opts *options.BoilerplateOptions) (any, error) {
+func getVariable(l logging.Logger, variable variables.Variable, opts *options.BoilerplateOptions) (any, error) {
 	valueFromVars, valueSpecifiedInVars := getVariableFromVars(variable, opts)
 
 	switch {
 	case valueSpecifiedInVars:
-		logging.Logger.Printf("Using value specified via command line options for variable '%s': %s", variable.FullName(), valueFromVars)
+		l.Debugf("Using value specified via command line options for variable '%s': %s", variable.FullName(), valueFromVars)
 		return valueFromVars, nil
 	case opts.NonInteractive && variable.Default() != nil:
-		logging.Logger.Printf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
+		l.Debugf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
 		return variable.Default(), nil
 	case opts.NonInteractive:
 		return nil, MissingVariableWithNonInteractiveMode(variable.FullName())
 	case variable.Default() != nil && !variable.Confirm():
-		logging.Logger.Printf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
+		l.Debugf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
 		return variable.Default(), nil
 	default:
-		return getVariableFromUser(variable, variables.InvalidEntries{})
+		return getVariableFromUser(l, variable, variables.InvalidEntries{})
 	}
 }
 
@@ -215,7 +216,7 @@ func getVariableFromVars(variable variables.Variable, opts *options.BoilerplateO
 }
 
 // Get the value for the given variable by prompting the user
-func getVariableFromUser(variable variables.Variable, invalidEntries variables.InvalidEntries) (any, error) {
+func getVariableFromUser(l logging.Logger, variable variables.Variable, invalidEntries variables.InvalidEntries) (any, error) {
 	// Add a newline for legibility and padding
 	fmt.Println()
 
@@ -242,12 +243,12 @@ func getVariableFromUser(variable variables.Variable, invalidEntries variables.I
 			},
 		}
 
-		return getVariableFromUser(variable, ie)
+		return getVariableFromUser(l, variable, ie)
 	}
 
 	if value == "" {
 		// TODO: what if the user wanted an empty string instead of the default?
-		logging.Logger.Printf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
+		l.Debugf("Using default value for variable '%s': %v", variable.FullName(), variable.Default())
 		return variable.Default(), nil
 	}
 

config/get_variables_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/gruntwork-io/boilerplate/options"
+	"github.com/gruntwork-io/boilerplate/pkg/logging"
 	"github.com/gruntwork-io/boilerplate/testutil"
 	"github.com/gruntwork-io/boilerplate/variables"
 )
@@ -100,7 +101,7 @@ func TestGetVariableNoMatchNonInteractive(t *testing.T) {
 	variable := variables.NewStringVariable("foo")
 	opts := testutil.CreateTestOptionsForShell(true, false)
 
-	_, err := getVariable(variable, opts)
+	_, err := getVariable(logging.Discard(), variable, opts)
 
 	require.Error(t, err)
 	assert.ErrorIs(t, err, MissingVariableWithNonInteractiveMode("foo"), "Expected a MissingVariableWithNonInteractiveMode error but got %s", reflect.TypeOf(err))
@@ -119,7 +120,7 @@ func TestGetVariableInVarsNonInteractive(t *testing.T) {
 		},
 	}
 
-	actual, err := getVariable(variable, opts)
+	actual, err := getVariable(logging.Discard(), variable, opts)
 	expected := "bar"
 
 	require.NoError(t, err)
@@ -139,7 +140,7 @@ func TestGetVariableDefaultNonInteractive(t *testing.T) {
 		},
 	}
 
-	actual, err := getVariable(variable, opts)
+	actual, err := getVariable(logging.Discard(), variable, opts)
 	expected := "bar"
 
 	require.NoError(t, err)
@@ -154,7 +155,7 @@ func TestGetVariablesNoVariables(t *testing.T) {
 	rootBoilerplateConfig := &BoilerplateConfig{}
 	dependency := &variables.Dependency{}
 
-	actual, err := GetVariables(opts, boilerplateConfig, rootBoilerplateConfig, dependency)
+	actual, err := GetVariables(logging.Discard(), opts, boilerplateConfig, rootBoilerplateConfig, dependency)
 	expected := map[string]any{
 		"BoilerplateConfigVars": map[string]variables.Variable{},
 		"BoilerplateConfigDeps": map[string]*variables.Dependency{},
@@ -181,7 +182,7 @@ func TestGetVariablesNoMatchNonInteractive(t *testing.T) {
 	rootBoilerplateConfig := &BoilerplateConfig{}
 	dependency := &variables.Dependency{}
 
-	_, err := GetVariables(opts, boilerplateConfig, rootBoilerplateConfig, dependency)
+	_, err := GetVariables(logging.Discard(), opts, boilerplateConfig, rootBoilerplateConfig, dependency)
 
 	require.Error(t, err)
 	assert.ErrorIs(t, err, MissingVariableWithNonInteractiveMode("foo"), "Expected a MissingVariableWithNonInteractiveMode error but got %s", reflect.TypeOf(err))
@@ -208,7 +209,7 @@ func TestGetVariablesMatchFromVars(t *testing.T) {
 
 	dependency := &variables.Dependency{}
 
-	actual, err := GetVariables(opts, boilerplateConfig, rootBoilerplateConfig, dependency)
+	actual, err := GetVariables(logging.Discard(), opts, boilerplateConfig, rootBoilerplateConfig, dependency)
 	expected := map[string]any{
 		"foo":                   "bar",
 		"BoilerplateConfigVars": map[string]variables.Variable{},
@@ -248,7 +249,7 @@ func TestGetVariablesMatchFromVarsAndDefaults(t *testing.T) {
 
 	dependency := &variables.Dependency{}
 
-	actual, err := GetVariables(opts, boilerplateConfig, rootBoilerplateConfig, dependency)
+	actual, err := GetVariables(logging.Discard(), opts, boilerplateConfig, rootBoilerplateConfig, dependency)
 	expected := map[string]any{
 		"key1":                  "value1",
 		"key2":                  "value2",
@@ -275,7 +276,7 @@ func TestGetVariableInteractiveWithDefaultSkipsPrompt(t *testing.T) {
 		Vars:           map[string]any{},
 	}
 
-	actual, err := getVariable(variable, opts)
+	actual, err := getVariable(logging.Discard(), variable, opts)
 	require.NoError(t, err)
 	assert.Equal(t, "default-val", actual)
 }
@@ -294,7 +295,7 @@ func TestGetVariableInteractiveWithDefaultAndConfirmDoesNotSkipPrompt(t *testing
 		Vars:           map[string]any{},
 	}
 
-	actual, err := getVariable(variable, opts)
+	actual, err := getVariable(logging.Discard(), variable, opts)
 	require.NoError(t, err)
 	assert.Equal(t, "default-val", actual)
 }
@@ -308,7 +309,7 @@ func TestGetVariableInteractiveFormulaDefaultSkipsPrompt(t *testing.T) {
 		Vars:           map[string]any{},
 	}
 
-	actual, err := getVariable(variable, opts)
+	actual, err := getVariable(logging.Discard(), variable, opts)
 	require.NoError(t, err)
 	assert.Equal(t, "{{ .Primary }}", actual)
 }

docs/.gitignore

@@ -1,6 +1,9 @@
 # build output
 dist/
 
+# wasm artifacts fetched from GitHub Releases at build time (see scripts/fetch-wasm.mjs)
+public/wasm/
+
 # generated types
 .astro/