Use the standard log package for logging

Configure output to file/stdout using log.SetOutput rather than passing
loggers.

cmd/autocomplete.go

@@ -9,21 +9,21 @@ import (
 	"github.com/yext/edward/config"
 )
 
-func autocompleteServicesAndGroups(homeDir string, logger *log.Logger) {
+func autocompleteServicesAndGroups(homeDir string) {
 	printCommandChildren(RootCmd)
 
 	configPath, err := config.GetConfigPathFromWorkingDirectory(homeDir)
 	if err != nil {
-		logger.Println("Autocomplete> Error getting config path:", err)
+		log.Println("Autocomplete> Error getting config path:", err)
 		return
 	}
 	if configPath == "" {
-		logger.Println("Autocomplete> Config file not found")
+		log.Println("Autocomplete> Config file not found")
 		return
 	}
-	cfg, err := config.LoadConfig(configPath, common.EdwardVersion, logger)
+	cfg, err := config.LoadConfig(configPath, common.EdwardVersion)
 	if err != nil {
-		logger.Println("Autocomplete> Error loading config:", err)
+		log.Println("Autocomplete> Error loading config:", err)
 		return
 	}
 

cmd/root.go

@@ -27,8 +27,6 @@ var cfgFile string
 
 var edwardClient *edward.Client
 
-var logger *log.Logger
-
 var checkUpdateChan chan interface{}
 
 // RootCmd represents the base command when called without any subcommands
@@ -45,35 +43,44 @@ Build, start and manage service instances with a single command.`,
 			return errors.WithStack(err)
 		}
 
-		if redirectLogs {
-			logger = log.New(os.Stdout, fmt.Sprintf("%v >", os.Args), log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
-		}
-
 		prefix := "edward"
 		if len(args) > 0 {
 			prefix = fmt.Sprintf("%s %s", cmd.Use, args[0])
 		}
-		logger = log.New(&lumberjack.Logger{
+
+		if redirectLogs {
+			log.SetOutput(os.Stdout)
+			log.SetPrefix(fmt.Sprintf("%v >", prefix))
+			log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds | log.Lshortfile)
+		} else {
+			log.SetOutput(&lumberjack.Logger{
+				Filename:   path.Join(dirConfig.EdwardLogDir, "edward.log"),
+				MaxSize:    50, // megabytes
+				MaxBackups: 30,
+				MaxAge:     1, //days
+			})
+			log.SetPrefix(fmt.Sprintf("%s > ", prefix))
+			log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds | log.Lshortfile)
+		}
+
+		log.SetOutput(&lumberjack.Logger{
 			Filename:   path.Join(dirConfig.EdwardLogDir, "edward.log"),
 			MaxSize:    50, // megabytes
 			MaxBackups: 30,
 			MaxAge:     1, //days
-		}, fmt.Sprintf("%s > ", prefix), log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
+		})
+		log.SetPrefix(fmt.Sprintf("%s > ", prefix))
+		log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds | log.Lshortfile)
 
 		// Begin logging
-		logger.Printf("=== Edward v%v ===\n", common.EdwardVersion)
-		logger.Printf("Args: %v\n", os.Args)
+		log.Printf("=== Edward v%v ===\n", common.EdwardVersion)
+		log.Printf("Args: %v\n", os.Args)
 		// Recover from any panic and log appropriately
 		defer func() {
 			if r := recover(); r != nil {
-				fmt.Println("Recovered from panic:", r)
-				if logger != nil {
-					logger.Printf("Recovered from panic: %v", r)
-				}
-			}
-			if logger != nil {
-				logger.Printf("=== Exiting ===\n")
+				log.Println("Recovered from panic:", r)
 			}
+			log.Printf("=== Exiting ===\n")
 		}()
 
 		// Set the default config path
@@ -93,7 +100,7 @@ Build, start and manage service instances with a single command.`,
 		command := cmd.Use
 
 		if command != "generate" {
-			edwardClient, err = edward.NewClientWithConfig(configPath, common.EdwardVersion, logger)
+			edwardClient, err = edward.NewClientWithConfig(configPath, common.EdwardVersion)
 			if err != nil {
 				return errors.WithStack(err)
 			}
@@ -118,7 +125,6 @@ Build, start and manage service instances with a single command.`,
 		edwardClient.ServiceChecks = func(sgs []services.ServiceOrGroup) error {
 			return errors.WithStack(sudoIfNeeded(sgs))
 		}
-		edwardClient.Logger = logger
 		// Populate the Edward executable with this binary
 		edwardClient.EdwardExecutable = os.Args[0]
 
@@ -186,22 +192,24 @@ func Execute() {
 		logPrefix = fmt.Sprintf("edward %v >", os.Args[1:])
 	}
 
-	logger = log.New(&lumberjack.Logger{
+	log.SetOutput(&lumberjack.Logger{
 		Filename:   filepath.Join(defaultHome.EdwardLogDir, "edward.log"),
 		MaxSize:    50, // megabytes
 		MaxBackups: 30,
 		MaxAge:     1, //days
-	}, logPrefix, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
+	})
+	log.SetPrefix(logPrefix)
+	log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds | log.Lshortfile)
 
 	for _, arg := range os.Args {
 		if arg == "--generate-bash-completion" {
-			autocompleteServicesAndGroups(defaultHome.Dir, logger)
+			autocompleteServicesAndGroups(defaultHome.Dir)
 			return
 		}
 	}
 
 	if err := RootCmd.Execute(); err != nil {
-		logger.Printf("Error: %v\n", err)
+		log.Printf("Error: %v\n", err)
 		os.Exit(1)
 	}
 }
@@ -262,9 +270,9 @@ func initConfig() {
 
 func checkUpdateAvailable(homeDir string, checkUpdateChan chan interface{}) {
 	defer close(checkUpdateChan)
-	updateAvailable, latestVersion, err := updates.UpdateAvailable("yext", "edward", common.EdwardVersion, filepath.Join(homeDir, ".cache/version"), logger)
+	updateAvailable, latestVersion, err := updates.UpdateAvailable("yext", "edward", common.EdwardVersion, filepath.Join(homeDir, ".cache/version"))
 	if err != nil {
-		logger.Println("Error checking for updates:", err)
+		log.Println("Error checking for updates:", err)
 		return
 	}
 

cmd/run.go

@@ -31,7 +31,6 @@ var runCmd = &cobra.Command{
 			edwardClient.DirConfig,
 			*runFlags.noWatch,
 			*runFlags.directory,
-			edwardClient.Logger,
 		)
 		if err != nil {
 			return errors.WithStack(err)

cmd/sudo.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"os"
 	"os/user"
 	"strings"
@@ -34,13 +35,13 @@ func ensureSudoAble() error {
 	buffer.WriteString(strings.Join(os.Args, " "))
 	buffer.WriteString("\n")
 
-	logger.Printf("Writing sudoAbility script\n")
+	log.Printf("Writing sudoAbility script\n")
 	file, err := createScriptFile("sudoAbility", buffer.String())
 	if err != nil {
 		return errors.WithStack(err)
 	}
 
-	logger.Printf("Launching sudoAbility script: %v\n", file.Name())
+	log.Printf("Launching sudoAbility script: %v\n", file.Name())
 	err = syscall.Exec(file.Name(), []string{file.Name()}, os.Environ())
 	if err != nil {
 		return errors.WithStack(err)
@@ -58,18 +59,18 @@ func prepareForSudo() error {
 	if isChild == "" {
 		return errors.WithStack(ensureSudoAble())
 	}
-	logger.Println("Child process, sudo should be available")
+	log.Println("Child process, sudo should be available")
 	return nil
 }
 
 func sudoIfNeeded(sgs []services.ServiceOrGroup) error {
 	for _, sg := range sgs {
 		if sg.IsSudo(services.OperationConfig{}) {
-			logger.Printf("sudo required for %v\n", sg.GetName())
+			log.Printf("sudo required for %v\n", sg.GetName())
 			return errors.WithStack(prepareForSudo())
 		}
 	}
-	logger.Printf("sudo not required for any services/groups\n")
+	log.Printf("sudo not required for any services/groups\n")
 	return nil
 }