TUN-3470: Replace in-house logger calls with zerolog

2026-06-09 04:30:31 +08:00 · 2020-11-25 00:55:13 -06:00
parent 06404bf3e8
commit 870f5fa907
151 changed files with 7120 additions and 3365 deletions
--- a/cmd/cloudflared/tunnel/cmd.go
+++ b/cmd/cloudflared/tunnel/cmd.go
@@ -35,6 +35,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 	"github.com/urfave/cli/v2/altsrc"
 )
@@ -42,8 +43,6 @@ import (
 const (
 	sentryDSN = "https://56a9c9fa5c364ab28f34b14f35ea0f1b:3e8827f6f9f740738eb11138f7bebb68@sentry.io/189878"

-	sshLogFileDirectory = "/usr/local/var/log/cloudflared/"
-
 	// sshPortFlag is the port on localhost the cloudflared ssh server will run on
 	sshPortFlag = "local-ssh-port"

@@ -174,14 +173,14 @@ func runAdhocNamedTunnel(sc *subcommandContext, name string) error {
 			return errors.Wrap(err, "failed to create tunnel")
 		}
 	} else {
-		sc.logger.Infof("Tunnel already created with ID %s", tunnel.ID)
+		sc.log.Info().Msgf("Tunnel already created with ID %s", tunnel.ID)
 	}

 	if r, ok := routeFromFlag(sc.c); ok {
 		if res, err := sc.route(tunnel.ID, r); err != nil {
-			sc.logger.Errorf("failed to create route, please create it manually. err: %v.", err)
+			sc.log.Error().Msgf("failed to create route, please create it manually. err: %v.", err)
 		} else {
-			sc.logger.Infof(res.SuccessSummary())
+			sc.log.Info().Msgf(res.SuccessSummary())
 		}
 	}

@@ -194,7 +193,7 @@ func runAdhocNamedTunnel(sc *subcommandContext, name string) error {

 // runClassicTunnel creates a "classic" non-named tunnel
 func runClassicTunnel(sc *subcommandContext) error {
-	return StartServer(sc.c, version, shutdownC, graceShutdownC, nil, sc.logger, sc.isUIEnabled)
+	return StartServer(sc.c, version, shutdownC, graceShutdownC, nil, sc.log, sc.isUIEnabled)
 }

 func routeFromFlag(c *cli.Context) (tunnelstore.Route, bool) {
@@ -213,7 +212,7 @@ func StartServer(
 	shutdownC,
 	graceShutdownC chan struct{},
 	namedTunnel *connection.NamedTunnelConfig,
-	generalLogger logger.Service,
+	log *zerolog.Logger,
 	isUIEnabled bool,
 ) error {
 	_ = raven.SetDSN(sentryDSN)
@@ -224,45 +223,45 @@ func StartServer(
 	dnsReadySignal := make(chan struct{})

 	if config.GetConfiguration().Source() == "" {
-		generalLogger.Infof(config.ErrNoConfigFile.Error())
+		log.Info().Msg(config.ErrNoConfigFile.Error())
 	}

 	if c.IsSet("trace-output") {
 		tmpTraceFile, err := ioutil.TempFile("", "trace")
 		if err != nil {
-			generalLogger.Errorf("Failed to create new temporary file to save trace output: %s", err)
+			log.Error().Msgf("Failed to create new temporary file to save trace output: %s", err)
 		}

 		defer func() {
 			if err := tmpTraceFile.Close(); err != nil {
-				generalLogger.Errorf("Failed to close trace output file %s with error: %s", tmpTraceFile.Name(), err)
+				log.Error().Msgf("Failed to close trace output file %s with error: %s", tmpTraceFile.Name(), err)
 			}
 			if err := os.Rename(tmpTraceFile.Name(), c.String("trace-output")); err != nil {
-				generalLogger.Errorf("Failed to rename temporary trace output file %s to %s with error: %s", tmpTraceFile.Name(), c.String("trace-output"), err)
+				log.Error().Msgf("Failed to rename temporary trace output file %s to %s with error: %s", tmpTraceFile.Name(), c.String("trace-output"), err)
 			} else {
 				err := os.Remove(tmpTraceFile.Name())
 				if err != nil {
-					generalLogger.Errorf("Failed to remove the temporary trace file %s with error: %s", tmpTraceFile.Name(), err)
+					log.Error().Msgf("Failed to remove the temporary trace file %s with error: %s", tmpTraceFile.Name(), err)
 				}
 			}
 		}()

 		if err := trace.Start(tmpTraceFile); err != nil {
-			generalLogger.Errorf("Failed to start trace: %s", err)
+			log.Error().Msgf("Failed to start trace: %s", err)
 			return errors.Wrap(err, "Error starting tracing")
 		}
 		defer trace.Stop()
 	}

 	buildInfo := buildinfo.GetBuildInfo(version)
-	buildInfo.Log(generalLogger)
-	logClientOptions(c, generalLogger)
+	buildInfo.Log(log)
+	logClientOptions(c, log)

 	if c.IsSet("proxy-dns") {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			errC <- runDNSProxyServer(c, dnsReadySignal, shutdownC, generalLogger)
+			errC <- runDNSProxyServer(c, dnsReadySignal, shutdownC, log)
 		}()
 	} else {
 		close(dnsReadySignal)
@@ -273,12 +272,12 @@ func StartServer(

 	go notifySystemd(connectedSignal)
 	if c.IsSet("pidfile") {
-		go writePidFile(connectedSignal, c.String("pidfile"), generalLogger)
+		go writePidFile(connectedSignal, c.String("pidfile"), log)
 	}

 	cloudflaredID, err := uuid.NewRandom()
 	if err != nil {
-		generalLogger.Errorf("Cannot generate cloudflared ID: %s", err)
+		log.Error().Msgf("Cannot generate cloudflared ID: %s", err)
 		return err
 	}

@@ -289,12 +288,12 @@ func StartServer(
 	}()

 	// update needs to be after DNS proxy is up to resolve equinox server address
-	if updater.IsAutoupdateEnabled(c, generalLogger) {
-		generalLogger.Infof("Autoupdate frequency is set to %v", c.Duration("autoupdate-freq"))
+	if updater.IsAutoupdateEnabled(c, log) {
+		log.Info().Msgf("Autoupdate frequency is set to %v", c.Duration("autoupdate-freq"))
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			autoupdater := updater.NewAutoUpdater(c.Duration("autoupdate-freq"), &listeners, generalLogger)
+			autoupdater := updater.NewAutoUpdater(c.Duration("autoupdate-freq"), &listeners, log)
 			errC <- autoupdater.Run(ctx)
 		}()
 	}
@@ -303,21 +302,18 @@ func StartServer(
 	if dnsProxyStandAlone(c) {
 		connectedSignal.Notify()
 		// no grace period, handle SIGINT/SIGTERM immediately
-		return waitToShutdown(&wg, errC, shutdownC, graceShutdownC, 0, generalLogger)
+		return waitToShutdown(&wg, errC, shutdownC, graceShutdownC, 0, log)
 	}

 	url := c.String("url")
 	hostname := c.String("hostname")
 	if url == hostname && url != "" && hostname != "" {
 		errText := "hostname and url shouldn't match. See --help for more information"
-		generalLogger.Error(errText)
+		log.Error().Msg(errText)
 		return fmt.Errorf(errText)
 	}

-	transportLogger, err := logger.CreateTransportLoggerFromContext(c, isUIEnabled)
-	if err != nil {
-		return errors.Wrap(err, "error setting up transport logger")
-	}
+	transportLog := logger.CreateTransportLoggerFromContext(c, isUIEnabled)

 	readinessCh := make(chan connection.Event, 16)
 	uiCh := make(chan connection.Event, 16)
@@ -325,30 +321,30 @@ func StartServer(
 		readinessCh,
 		uiCh,
 	}
-	tunnelConfig, ingressRules, err := prepareTunnelConfig(c, buildInfo, version, generalLogger, transportLogger, namedTunnel, isUIEnabled, eventChannels)
+	tunnelConfig, ingressRules, err := prepareTunnelConfig(c, buildInfo, version, log, transportLog, namedTunnel, isUIEnabled, eventChannels)
 	if err != nil {
-		generalLogger.Errorf("Couldn't start tunnel: %v", err)
+		log.Error().Msgf("Couldn't start tunnel: %v", err)
 		return err
 	}

 	metricsListener, err := listeners.Listen("tcp", c.String("metrics"))
 	if err != nil {
-		generalLogger.Errorf("Error opening metrics server listener: %s", err)
+		log.Error().Msgf("Error opening metrics server listener: %s", err)
 		return errors.Wrap(err, "Error opening metrics server listener")
 	}
 	defer metricsListener.Close()
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		errC <- metrics.ServeMetrics(metricsListener, shutdownC, readinessCh, generalLogger)
+		errC <- metrics.ServeMetrics(metricsListener, shutdownC, readinessCh, log)
 	}()

-	ingressRules.StartOrigins(&wg, generalLogger, shutdownC, errC)
+	ingressRules.StartOrigins(&wg, log, shutdownC, errC)

 	reconnectCh := make(chan origin.ReconnectSignal, 1)
 	if c.IsSet("stdin-control") {
-		generalLogger.Info("Enabling control through stdin")
-		go stdinControl(reconnectCh, generalLogger)
+		log.Info().Msg("Enabling control through stdin")
+		go stdinControl(reconnectCh, log)
 	}

 	wg.Add(1)
@@ -365,31 +361,15 @@ func StartServer(
 			&ingressRules,
 			tunnelConfig.HAConnections,
 		)
-		logLevels, err := logger.ParseLevelString(c.String("loglevel"))
-		if err != nil {
-			return err
-		}
-		tunnelInfo.LaunchUI(ctx, generalLogger, transportLogger, logLevels, uiCh)
+		tunnelInfo.LaunchUI(ctx, log, transportLog, uiCh)
 	}

-	return waitToShutdown(&wg, errC, shutdownC, graceShutdownC, c.Duration("grace-period"), generalLogger)
-}
-
-// forceSetFlag attempts to set the given flag value in the closest context that has it defined
-func forceSetFlag(c *cli.Context, name, value string) {
-	for _, ctx := range c.Lineage() {
-		if err := ctx.Set(name, value); err == nil {
-			break
-		}
-	}
+	return waitToShutdown(&wg, errC, shutdownC, graceShutdownC, c.Duration("grace-period"), log)
 }

 func SetFlagsFromConfigFile(c *cli.Context) error {
 	const exitCode = 1
-	log, err := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)
-	if err != nil {
-		return cliutil.PrintLoggerSetupError("error setting up logger", err)
-	}
+	log := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)
 	inputSource, err := config.ReadConfigFile(c, log)
 	if err != nil {
 		if err == config.ErrNoConfigFile {
@@ -411,20 +391,20 @@ func waitToShutdown(wg *sync.WaitGroup,
 	errC chan error,
 	shutdownC, graceShutdownC chan struct{},
 	gracePeriod time.Duration,
-	logger logger.Service,
+	log *zerolog.Logger,
 ) error {
 	var err error
 	if gracePeriod > 0 {
-		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceShutdownC, gracePeriod, logger)
+		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceShutdownC, gracePeriod, log)
 	} else {
-		err = waitForSignal(errC, shutdownC, logger)
+		err = waitForSignal(errC, shutdownC, log)
 		close(graceShutdownC)
 	}

 	if err != nil {
-		logger.Errorf("Quitting due to error: %s", err)
+		log.Error().Msgf("Quitting due to error: %s", err)
 	} else {
-		logger.Info("Quitting...")
+		log.Info().Msg("Quitting...")
 	}
 	// Wait for clean exit, discarding all errors
 	go func() {
@@ -440,16 +420,16 @@ func notifySystemd(waitForSignal *signal.Signal) {
 	daemon.SdNotify(false, "READY=1")
 }

-func writePidFile(waitForSignal *signal.Signal, pidFile string, logger logger.Service) {
+func writePidFile(waitForSignal *signal.Signal, pidFile string, log *zerolog.Logger) {
 	<-waitForSignal.Wait()
 	expandedPath, err := homedir.Expand(pidFile)
 	if err != nil {
-		logger.Errorf("Unable to expand %s, try to use absolute path in --pidfile: %s", pidFile, err)
+		log.Error().Msgf("Unable to expand %s, try to use absolute path in --pidfile: %s", pidFile, err)
 		return
 	}
 	file, err := os.Create(expandedPath)
 	if err != nil {
-		logger.Errorf("Unable to write pid to %s: %s", expandedPath, err)
+		log.Error().Msgf("Unable to write pid to %s: %s", expandedPath, err)
 		return
 	}
 	defer file.Close()
@@ -1018,7 +998,7 @@ func configureProxyDNSFlags(shouldHide bool) []cli.Flag {
 	}
 }

-func stdinControl(reconnectCh chan origin.ReconnectSignal, logger logger.Service) {
+func stdinControl(reconnectCh chan origin.ReconnectSignal, log *zerolog.Logger) {
 	for {
 		scanner := bufio.NewScanner(os.Stdin)
 		for scanner.Scan() {
@@ -1033,17 +1013,17 @@ func stdinControl(reconnectCh chan origin.ReconnectSignal, logger logger.Service
 				if len(parts) > 1 {
 					var err error
 					if reconnect.Delay, err = time.ParseDuration(parts[1]); err != nil {
-						logger.Error(err.Error())
+						log.Error().Msg(err.Error())
 						continue
 					}
 				}
-				logger.Infof("Sending reconnect signal %+v", reconnect)
+				log.Info().Msgf("Sending reconnect signal %+v", reconnect)
 				reconnectCh <- reconnect
 			default:
-				logger.Infof("Unknown command: %s", command)
+				log.Info().Msgf("Unknown command: %s", command)
 				fallthrough
 			case "help":
-				logger.Info(`Supported command:
+				log.Info().Msg(`Supported command:
 reconnect [delay]
 - restarts one randomly chosen connection with optional delay before reconnect`)
 			}
--- a/cmd/cloudflared/tunnel/configuration.go
+++ b/cmd/cloudflared/tunnel/configuration.go
@@ -14,7 +14,6 @@ import (
 	"github.com/cloudflare/cloudflared/edgediscovery"
 	"github.com/cloudflare/cloudflared/h2mux"
 	"github.com/cloudflare/cloudflared/ingress"
-	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/origin"
 	"github.com/cloudflare/cloudflared/tlsconfig"
 	tunnelpogs "github.com/cloudflare/cloudflared/tunnelrpc/pogs"
@@ -23,6 +22,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/crypto/ssh/terminal"
 )
@@ -46,16 +46,16 @@ func findDefaultOriginCertPath() string {
 	return ""
 }

-func generateRandomClientID(logger logger.Service) (string, error) {
+func generateRandomClientID(log *zerolog.Logger) (string, error) {
 	u, err := uuid.NewRandom()
 	if err != nil {
-		logger.Errorf("couldn't create UUID for client ID %s", err)
+		log.Error().Msgf("couldn't create UUID for client ID %s", err)
 		return "", err
 	}
 	return u.String(), nil
 }

-func logClientOptions(c *cli.Context, logger logger.Service) {
+func logClientOptions(c *cli.Context, log *zerolog.Logger) {
 	flags := make(map[string]interface{})
 	for _, flag := range c.LocalFlagNames() {
 		flags[flag] = c.Generic(flag)
@@ -69,7 +69,7 @@ func logClientOptions(c *cli.Context, logger logger.Service) {
 	}

 	if len(flags) > 0 {
-		logger.Infof("Environment variables %v", flags)
+		log.Info().Msgf("Environment variables %v", flags)
 	}

 	envs := make(map[string]string)
@@ -84,7 +84,7 @@ func logClientOptions(c *cli.Context, logger logger.Service) {
 		}
 	}
 	if len(envs) > 0 {
-		logger.Infof("Environmental variables %v", envs)
+		log.Info().Msgf("Environmental variables %v", envs)
 	}
 }

@@ -92,32 +92,32 @@ func dnsProxyStandAlone(c *cli.Context) bool {
 	return c.IsSet("proxy-dns") && (!c.IsSet("hostname") && !c.IsSet("tag") && !c.IsSet("hello-world"))
 }

-func findOriginCert(c *cli.Context, logger logger.Service) (string, error) {
+func findOriginCert(c *cli.Context, log *zerolog.Logger) (string, error) {
 	originCertPath := c.String("origincert")
 	if originCertPath == "" {
-		logger.Infof("Cannot determine default origin certificate path. No file %s in %v", config.DefaultCredentialFile, config.DefaultConfigSearchDirectories())
+		log.Info().Msgf("Cannot determine default origin certificate path. No file %s in %v", config.DefaultCredentialFile, config.DefaultConfigSearchDirectories())
 		if isRunningFromTerminal() {
-			logger.Errorf("You need to specify the origin certificate path with --origincert option, or set TUNNEL_ORIGIN_CERT environment variable. See %s for more information.", argumentsUrl)
+			log.Error().Msgf("You need to specify the origin certificate path with --origincert option, or set TUNNEL_ORIGIN_CERT environment variable. See %s for more information.", argumentsUrl)
 			return "", fmt.Errorf("Client didn't specify origincert path when running from terminal")
 		} else {
-			logger.Errorf("You need to specify the origin certificate path by specifying the origincert option in the configuration file, or set TUNNEL_ORIGIN_CERT environment variable. See %s for more information.", serviceUrl)
+			log.Error().Msgf("You need to specify the origin certificate path by specifying the origincert option in the configuration file, or set TUNNEL_ORIGIN_CERT environment variable. See %s for more information.", serviceUrl)
 			return "", fmt.Errorf("Client didn't specify origincert path")
 		}
 	}
 	var err error
 	originCertPath, err = homedir.Expand(originCertPath)
 	if err != nil {
-		logger.Errorf("Cannot resolve path %s: %s", originCertPath, err)
+		log.Error().Msgf("Cannot resolve path %s: %s", originCertPath, err)
 		return "", fmt.Errorf("Cannot resolve path %s", originCertPath)
 	}
 	// Check that the user has acquired a certificate using the login command
 	ok, err := config.FileExists(originCertPath)
 	if err != nil {
-		logger.Errorf("Cannot check if origin cert exists at path %s", originCertPath)
+		log.Error().Msgf("Cannot check if origin cert exists at path %s", originCertPath)
 		return "", fmt.Errorf("Cannot check if origin cert exists at path %s", originCertPath)
 	}
 	if !ok {
-		logger.Errorf(`Cannot find a valid certificate for your origin at the path:
+		log.Error().Msgf(`Cannot find a valid certificate for your origin at the path:

    %s

@@ -132,23 +132,23 @@ If you don't have a certificate signed by Cloudflare, run the command:
 	return originCertPath, nil
 }

-func readOriginCert(originCertPath string, logger logger.Service) ([]byte, error) {
-	logger.Debugf("Reading origin cert from %s", originCertPath)
+func readOriginCert(originCertPath string, log *zerolog.Logger) ([]byte, error) {
+	log.Debug().Msgf("Reading origin cert from %s", originCertPath)

 	// Easier to send the certificate as []byte via RPC than decoding it at this point
 	originCert, err := ioutil.ReadFile(originCertPath)
 	if err != nil {
-		logger.Errorf("Cannot read %s to load origin certificate: %s", originCertPath, err)
+		log.Error().Msgf("Cannot read %s to load origin certificate: %s", originCertPath, err)
 		return nil, fmt.Errorf("Cannot read %s to load origin certificate", originCertPath)
 	}
 	return originCert, nil
 }

-func getOriginCert(c *cli.Context, logger logger.Service) ([]byte, error) {
-	if originCertPath, err := findOriginCert(c, logger); err != nil {
+func getOriginCert(c *cli.Context, log *zerolog.Logger) ([]byte, error) {
+	if originCertPath, err := findOriginCert(c, log); err != nil {
 		return nil, err
 	} else {
-		return readOriginCert(originCertPath, logger)
+		return readOriginCert(originCertPath, log)
 	}
 }

@@ -156,8 +156,8 @@ func prepareTunnelConfig(
 	c *cli.Context,
 	buildInfo *buildinfo.BuildInfo,
 	version string,
-	logger logger.Service,
-	transportLogger logger.Service,
+	log *zerolog.Logger,
+	transportLogger *zerolog.Logger,
 	namedTunnel *connection.NamedTunnelConfig,
 	isUIEnabled bool,
 	eventChans []chan connection.Event,
@@ -166,13 +166,13 @@ func prepareTunnelConfig(

 	hostname, err := validation.ValidateHostname(c.String("hostname"))
 	if err != nil {
-		logger.Errorf("Invalid hostname: %s", err)
+		log.Error().Msgf("Invalid hostname: %s", err)
 		return nil, ingress.Ingress{}, errors.Wrap(err, "Invalid hostname")
 	}
 	isFreeTunnel := hostname == ""
 	clientID := c.String("id")
 	if !c.IsSet("id") {
-		clientID, err = generateRandomClientID(logger)
+		clientID, err = generateRandomClientID(log)
 		if err != nil {
 			return nil, ingress.Ingress{}, err
 		}
@@ -180,7 +180,7 @@ func prepareTunnelConfig(

 	tags, err := NewTagSliceFromCLI(c.StringSlice("tag"))
 	if err != nil {
-		logger.Errorf("Tag parse failure: %s", err)
+		log.Error().Msgf("Tag parse failure: %s", err)
 		return nil, ingress.Ingress{}, errors.Wrap(err, "Tag parse failure")
 	}

@@ -188,7 +188,7 @@ func prepareTunnelConfig(

 	var originCert []byte
 	if !isFreeTunnel {
-		originCert, err = getOriginCert(c, logger)
+		originCert, err = getOriginCert(c, log)
 		if err != nil {
 			return nil, ingress.Ingress{}, errors.Wrap(err, "Error getting origin cert")
 		}
@@ -227,17 +227,17 @@ func prepareTunnelConfig(

 	// Convert single-origin configuration into multi-origin configuration.
 	if ingressRules.IsEmpty() {
-		ingressRules, err = ingress.NewSingleOrigin(c, !isNamedTunnel, logger)
+		ingressRules, err = ingress.NewSingleOrigin(c, !isNamedTunnel)
 		if err != nil {
 			return nil, ingress.Ingress{}, err
 		}
 	}

-	protocolSelector, err := connection.NewProtocolSelector(c.String("protocol"), namedTunnel, edgediscovery.HTTP2Percentage, origin.ResolveTTL, logger)
+	protocolSelector, err := connection.NewProtocolSelector(c.String("protocol"), namedTunnel, edgediscovery.HTTP2Percentage, origin.ResolveTTL, log)
 	if err != nil {
 		return nil, ingress.Ingress{}, err
 	}
-	logger.Infof("Initial protocol %s", protocolSelector.Current())
+	log.Info().Msgf("Initial protocol %s", protocolSelector.Current())

 	edgeTLSConfigs := make(map[connection.Protocol]*tls.Config, len(connection.ProtocolList))
 	for _, p := range connection.ProtocolList {
@@ -248,7 +248,7 @@ func prepareTunnelConfig(
 		edgeTLSConfigs[p] = edgeTLSConfig
 	}

-	originClient := origin.NewClient(ingressRules, tags, logger)
+	originClient := origin.NewClient(ingressRules, tags, log)
 	connectionConfig := &connection.Config{
 		OriginClient:    originClient,
 		GracePeriod:     c.Duration("grace-period"),
@@ -272,7 +272,7 @@ func prepareTunnelConfig(
 		IsFreeTunnel:     isFreeTunnel,
 		LBPool:           c.String("lb-pool"),
 		Tags:             tags,
-		Logger:           logger,
+		Log:              log,
 		Observer:         connection.NewObserver(transportLogger, eventChans, isUIEnabled),
 		ReportedVersion:  version,
 		Retries:          c.Uint("retries"),
--- a/cmd/cloudflared/tunnel/credential_finder.go
+++ b/cmd/cloudflared/tunnel/credential_finder.go
@@ -5,8 +5,9 @@ import (
 	"path/filepath"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/config"
-	"github.com/cloudflare/cloudflared/logger"
+
 	"github.com/google/uuid"
+	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 )

@@ -39,25 +40,25 @@ func (a staticPath) Path() (string, error) {
 // Implements CredFinder and looks for the credentials file in several directories
 // searching for a file named <id>.json
 type searchByID struct {
-	id     uuid.UUID
-	c      *cli.Context
-	logger logger.Service
-	fs     fileSystem
+	id  uuid.UUID
+	c   *cli.Context
+	log *zerolog.Logger
+	fs  fileSystem
 }

-func newSearchByID(id uuid.UUID, c *cli.Context, logger logger.Service, fs fileSystem) CredFinder {
+func newSearchByID(id uuid.UUID, c *cli.Context, log *zerolog.Logger, fs fileSystem) CredFinder {
 	return searchByID{
-		id:     id,
-		c:      c,
-		logger: logger,
-		fs:     fs,
+		id:  id,
+		c:   c,
+		log: log,
+		fs:  fs,
 	}
 }

 func (s searchByID) Path() (string, error) {

 	// Fallback to look for tunnel credentials in the origin cert directory
-	if originCertPath, err := findOriginCert(s.c, s.logger); err == nil {
+	if originCertPath, err := findOriginCert(s.c, s.log); err == nil {
 		originCertDir := filepath.Dir(originCertPath)
 		if filePath, err := tunnelFilePath(s.id, originCertDir); err == nil {
 			if s.fs.validFilePath(filePath) {
--- a/cmd/cloudflared/tunnel/ingress_subcommands.go
+++ b/cmd/cloudflared/tunnel/ingress_subcommands.go
@@ -4,12 +4,12 @@ import (
 	"fmt"
 	"net/url"

-	"github.com/pkg/errors"
-	"github.com/urfave/cli/v2"
-
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/config"
 	"github.com/cloudflare/cloudflared/ingress"
+
+	"github.com/pkg/errors"
+	"github.com/urfave/cli/v2"
 )

 func buildIngressSubcommand() *cli.Command {
--- a/cmd/cloudflared/tunnel/login.go
+++ b/cmd/cloudflared/tunnel/login.go
@@ -8,9 +8,9 @@ import (
 	"path/filepath"
 	"syscall"

-	homedir "github.com/mitchellh/go-homedir"
+	"github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
-	cli "github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v2"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/config"
@@ -40,10 +40,7 @@ func buildLoginSubcommand(hidden bool) *cli.Command {
 }

 func login(c *cli.Context) error {
-	logger, err := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)
-	if err != nil {
-		return errors.Wrap(err, "error setting up logger")
-	}
+	log := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)

 	path, ok, err := checkForExistingCert()
 	if ok {
@@ -59,7 +56,15 @@ func login(c *cli.Context) error {
 		return err
 	}

-	resourceData, err := transfer.Run(loginURL, "cert", "callback", callbackStoreURL, false, false, logger)
+	resourceData, err := transfer.Run(
+		loginURL,
+		"cert",
+		"callback",
+		callbackStoreURL,
+		false,
+		false,
+		log,
+	)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Failed to write the certificate due to the following error:\n%v\n\nYour browser will download the certificate instead. You will have to manually\ncopy it to the following path:\n\n%s\n", err, path)
 		return err
--- a/cmd/cloudflared/tunnel/server.go
+++ b/cmd/cloudflared/tunnel/server.go
@@ -1,20 +1,19 @@
 package tunnel

 import (
-	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/tunneldns"

-	"github.com/urfave/cli/v2"
-
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
+	"github.com/urfave/cli/v2"
 )

-func runDNSProxyServer(c *cli.Context, dnsReadySignal, shutdownC chan struct{}, logger logger.Service) error {
+func runDNSProxyServer(c *cli.Context, dnsReadySignal, shutdownC chan struct{}, log *zerolog.Logger) error {
 	port := c.Int("proxy-dns-port")
 	if port <= 0 || port > 65535 {
 		return errors.New("The 'proxy-dns-port' must be a valid port number in <1, 65535> range.")
 	}
-	listener, err := tunneldns.CreateListener(c.String("proxy-dns-address"), uint16(port), c.StringSlice("proxy-dns-upstream"), c.StringSlice("proxy-dns-bootstrap"), logger)
+	listener, err := tunneldns.CreateListener(c.String("proxy-dns-address"), uint16(port), c.StringSlice("proxy-dns-upstream"), c.StringSlice("proxy-dns-bootstrap"), log)
 	if err != nil {
 		close(dnsReadySignal)
 		listener.Stop()
@@ -26,6 +25,6 @@ func runDNSProxyServer(c *cli.Context, dnsReadySignal, shutdownC chan struct{},
 		return errors.Wrap(err, "Cannot start the DNS over HTTPS proxy server")
 	}
 	<-shutdownC
-	listener.Stop()
+	_ = listener.Stop()
 	return nil
 }
--- a/cmd/cloudflared/tunnel/signal.go
+++ b/cmd/cloudflared/tunnel/signal.go
@@ -6,24 +6,24 @@ import (
 	"syscall"
 	"time"

-	"github.com/cloudflare/cloudflared/logger"
+	"github.com/rs/zerolog"
 )

 // waitForSignal notifies all routines to shutdownC immediately by closing the
 // shutdownC when one of the routines in main exits, or when this process receives
 // SIGTERM/SIGINT
-func waitForSignal(errC chan error, shutdownC chan struct{}, logger logger.Service) error {
+func waitForSignal(errC chan error, shutdownC chan struct{}, log *zerolog.Logger) error {
 	signals := make(chan os.Signal, 10)
 	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)
 	defer signal.Stop(signals)

 	select {
 	case err := <-errC:
-		logger.Infof("terminating due to error: %v", err)
+		log.Info().Msgf("terminating due to error: %v", err)
 		close(shutdownC)
 		return err
 	case s := <-signals:
-		logger.Infof("terminating due to signal %s", s)
+		log.Info().Msgf("terminating due to signal %s", s)
 		close(shutdownC)
 	case <-shutdownC:
 	}
@@ -41,7 +41,7 @@ func waitForSignal(errC chan error, shutdownC chan struct{}, logger logger.Servi
 func waitForSignalWithGraceShutdown(errC chan error,
 	shutdownC, graceShutdownC chan struct{},
 	gracePeriod time.Duration,
-	logger logger.Service,
+	logger *zerolog.Logger,
 ) error {
 	signals := make(chan os.Signal, 10)
 	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)
@@ -49,16 +49,16 @@ func waitForSignalWithGraceShutdown(errC chan error,

 	select {
 	case err := <-errC:
-		logger.Infof("Initiating graceful shutdown due to %v ...", err)
+		logger.Info().Msgf("Initiating graceful shutdown due to %v ...", err)
 		close(graceShutdownC)
 		close(shutdownC)
 		return err
 	case s := <-signals:
-		logger.Infof("Initiating graceful shutdown due to signal %s ...", s)
+		logger.Info().Msgf("Initiating graceful shutdown due to signal %s ...", s)
 		close(graceShutdownC)
-		waitForGracePeriod(signals, errC, shutdownC, gracePeriod, logger)
+		waitForGracePeriod(signals, errC, shutdownC, gracePeriod)
 	case <-graceShutdownC:
-		waitForGracePeriod(signals, errC, shutdownC, gracePeriod, logger)
+		waitForGracePeriod(signals, errC, shutdownC, gracePeriod)
 	case <-shutdownC:
 		close(graceShutdownC)
 	}
@@ -70,7 +70,6 @@ func waitForGracePeriod(signals chan os.Signal,
 	errC chan error,
 	shutdownC chan struct{},
 	gracePeriod time.Duration,
-	logger logger.Service,
 ) {
 	// Unregister signal handler early, so the client can send a second SIGTERM/SIGINT
 	// to force shutdown cloudflared
--- a/cmd/cloudflared/tunnel/signal_test.go
+++ b/cmd/cloudflared/tunnel/signal_test.go
@@ -2,11 +2,11 @@ package tunnel

 import (
 	"fmt"
+	"github.com/rs/zerolog"
 	"syscall"
 	"testing"
 	"time"

-	"github.com/cloudflare/cloudflared/logger"
 	"github.com/stretchr/testify/assert"
 )

@@ -28,7 +28,7 @@ func testChannelClosed(t *testing.T, c chan struct{}) {
 }

 func TestWaitForSignal(t *testing.T) {
-	logger := logger.NewOutputWriter(logger.NewMockWriteManager())
+	log := zerolog.Nop()

 	// Test handling server error
 	errC := make(chan error)
@@ -39,7 +39,7 @@ func TestWaitForSignal(t *testing.T) {
 	}()

 	// received error, shutdownC should be closed
-	err := waitForSignal(errC, shutdownC, logger)
+	err := waitForSignal(errC, shutdownC, &log)
 	assert.Equal(t, serverErr, err)
 	testChannelClosed(t, shutdownC)

@@ -56,10 +56,10 @@ func TestWaitForSignal(t *testing.T) {
 		go func(sig syscall.Signal) {
 			// sleep for a tick to prevent sending signal before calling waitForSignal
 			time.Sleep(tick)
-			syscall.Kill(syscall.Getpid(), sig)
+			_ = syscall.Kill(syscall.Getpid(), sig)
 		}(sig)

-		err = waitForSignal(errC, shutdownC, logger)
+		err = waitForSignal(errC, shutdownC, &log)
 		assert.Equal(t, nil, err)
 		assert.Equal(t, shutdownErr, <-errC)
 		testChannelClosed(t, shutdownC)
@@ -76,10 +76,10 @@ func TestWaitForSignalWithGraceShutdown(t *testing.T) {
 		errC <- serverErr
 	}()

-	logger := logger.NewOutputWriter(logger.NewMockWriteManager())
+	log := zerolog.Nop()

 	// received error, both shutdownC and graceshutdownC should be closed
-	err := waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, logger)
+	err := waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, &log)
 	assert.Equal(t, serverErr, err)
 	testChannelClosed(t, shutdownC)
 	testChannelClosed(t, graceshutdownC)
@@ -89,7 +89,7 @@ func TestWaitForSignalWithGraceShutdown(t *testing.T) {
 	shutdownC = make(chan struct{})
 	graceshutdownC = make(chan struct{})
 	close(shutdownC)
-	err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, logger)
+	err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, &log)
 	assert.NoError(t, err)
 	testChannelClosed(t, shutdownC)
 	testChannelClosed(t, graceshutdownC)
@@ -99,7 +99,7 @@ func TestWaitForSignalWithGraceShutdown(t *testing.T) {
 	shutdownC = make(chan struct{})
 	graceshutdownC = make(chan struct{})
 	close(graceshutdownC)
-	err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, logger)
+	err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, &log)
 	assert.NoError(t, err)
 	testChannelClosed(t, shutdownC)
 	testChannelClosed(t, graceshutdownC)
@@ -119,10 +119,10 @@ func TestWaitForSignalWithGraceShutdown(t *testing.T) {
 		go func(sig syscall.Signal) {
 			// sleep for a tick to prevent sending signal before calling waitForSignalWithGraceShutdown
 			time.Sleep(tick)
-			syscall.Kill(syscall.Getpid(), sig)
+			_ = syscall.Kill(syscall.Getpid(), sig)
 		}(sig)

-		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, logger)
+		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, &log)
 		assert.Equal(t, nil, err)
 		assert.Equal(t, graceShutdownErr, <-errC)
 		testChannelClosed(t, shutdownC)
@@ -145,10 +145,10 @@ func TestWaitForSignalWithGraceShutdown(t *testing.T) {
 		go func(sig syscall.Signal) {
 			// sleep for a tick to prevent sending signal before calling waitForSignalWithGraceShutdown
 			time.Sleep(tick)
-			syscall.Kill(syscall.Getpid(), sig)
+			_ = syscall.Kill(syscall.Getpid(), sig)
 		}(sig)

-		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, logger)
+		err = waitForSignalWithGraceShutdown(errC, shutdownC, graceshutdownC, tick, &log)
 		assert.Equal(t, nil, err)
 		assert.Equal(t, shutdownErr, <-errC)
 		testChannelClosed(t, shutdownC)
--- a/cmd/cloudflared/tunnel/subcommand_context.go
+++ b/cmd/cloudflared/tunnel/subcommand_context.go
@@ -8,6 +8,7 @@ import (

 	"github.com/google/uuid"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"

 	"github.com/cloudflare/cloudflared/certutil"
@@ -29,7 +30,7 @@ func (e errInvalidJSONCredential) Error() string {
 // pass between subcommands, and make sure they are only initialized once
 type subcommandContext struct {
 	c           *cli.Context
-	logger      logger.Service
+	log         *zerolog.Logger
 	isUIEnabled bool
 	fs          fileSystem

@@ -42,14 +43,11 @@ func newSubcommandContext(c *cli.Context) (*subcommandContext, error) {
 	isUIEnabled := c.IsSet(uiFlag) && c.String("name") != ""

 	// If UI is enabled, terminal log output should be disabled -- log should be written into a UI log window instead
-	logger, err := logger.CreateLoggerFromContext(c, isUIEnabled)
-	if err != nil {
-		return nil, errors.Wrap(err, "error setting up logger")
-	}
+	log := logger.CreateLoggerFromContext(c, isUIEnabled)

 	return &subcommandContext{
 		c:           c,
-		logger:      logger,
+		log:         log,
 		isUIEnabled: isUIEnabled,
 		fs:          realFileSystem{},
 	}, nil
@@ -60,7 +58,7 @@ func (sc *subcommandContext) credentialFinder(tunnelID uuid.UUID) CredFinder {
 	if path := sc.c.String(CredFileFlag); path != "" {
 		return newStaticPath(path, sc.fs)
 	}
-	return newSearchByID(tunnelID, sc.c, sc.logger, sc.fs)
+	return newSearchByID(tunnelID, sc.c, sc.log, sc.fs)
 }

 type userCredential struct {
@@ -77,7 +75,15 @@ func (sc *subcommandContext) client() (tunnelstore.Client, error) {
 		return nil, err
 	}
 	userAgent := fmt.Sprintf("cloudflared/%s", version)
-	client, err := tunnelstore.NewRESTClient(sc.c.String("api-url"), credential.cert.AccountID, credential.cert.ZoneID, credential.cert.ServiceKey, userAgent, sc.logger)
+	client, err := tunnelstore.NewRESTClient(
+		sc.c.String("api-url"),
+		credential.cert.AccountID,
+		credential.cert.ZoneID,
+		credential.cert.ServiceKey,
+		userAgent,
+		sc.log,
+	)
+
 	if err != nil {
 		return nil, err
 	}
@@ -87,11 +93,11 @@ func (sc *subcommandContext) client() (tunnelstore.Client, error) {

 func (sc *subcommandContext) credential() (*userCredential, error) {
 	if sc.userCredential == nil {
-		originCertPath, err := findOriginCert(sc.c, sc.logger)
+		originCertPath, err := findOriginCert(sc.c, sc.log)
 		if err != nil {
 			return nil, errors.Wrap(err, "Error locating origin cert")
 		}
-		blocks, err := readOriginCert(originCertPath, sc.logger)
+		blocks, err := readOriginCert(originCertPath, sc.log)
 		if err != nil {
 			return nil, errors.Wrapf(err, "Can't read origin cert from %s", originCertPath)
 		}
@@ -163,7 +169,7 @@ func (sc *subcommandContext) create(name string) (*tunnelstore.Tunnel, error) {
 		TunnelName:   name,
 	}
 	filePath, writeFileErr := writeTunnelCredentials(credential.certPath, &tunnelCredentials)
-	if err != nil {
+	if writeFileErr != nil {
 		var errorLines []string
 		errorLines = append(errorLines, fmt.Sprintf("Your tunnel '%v' was created with ID %v. However, cloudflared couldn't write to the tunnel credentials file at %v.json.", tunnel.Name, tunnel.ID, tunnel.ID))
 		errorLines = append(errorLines, fmt.Sprintf("The file-writing error is: %v", writeFileErr))
@@ -176,13 +182,13 @@ func (sc *subcommandContext) create(name string) (*tunnelstore.Tunnel, error) {
 		errorMsg := strings.Join(errorLines, "\n")
 		return nil, errors.New(errorMsg)
 	}
-	sc.logger.Infof("Tunnel credentials written to %v. cloudflared chose this file based on where your origin certificate was found. Keep this file secret. To revoke these credentials, delete the tunnel.", filePath)
+	sc.log.Info().Msgf("Tunnel credentials written to %v. cloudflared chose this file based on where your origin certificate was found. Keep this file secret. To revoke these credentials, delete the tunnel.", filePath)

 	if outputFormat := sc.c.String(outputFormatFlag.Name); outputFormat != "" {
 		return nil, renderOutput(outputFormat, &tunnel)
 	}

-	sc.logger.Infof("Created tunnel %s with id %s", tunnel.Name, tunnel.ID)
+	sc.log.Info().Msgf("Created tunnel %s with id %s", tunnel.Name, tunnel.ID)
 	return tunnel, nil
 }

@@ -230,7 +236,7 @@ func (sc *subcommandContext) delete(tunnelIDs []uuid.UUID) error {
 		credFinder := sc.credentialFinder(id)
 		if tunnelCredentialsPath, err := credFinder.Path(); err == nil {
 			if err = os.Remove(tunnelCredentialsPath); err != nil {
-				sc.logger.Infof("Tunnel %v was deleted, but we could not remove its credentials file  %s: %s. Consider deleting this file manually.", id, tunnelCredentialsPath, err)
+				sc.log.Info().Msgf("Tunnel %v was deleted, but we could not remove its credentials file  %s: %s. Consider deleting this file manually.", id, tunnelCredentialsPath, err)
 			}
 		}
 	}
@@ -254,18 +260,19 @@ func (sc *subcommandContext) run(tunnelID uuid.UUID) error {
 	credentials, err := sc.findCredentials(tunnelID)
 	if err != nil {
 		if e, ok := err.(errInvalidJSONCredential); ok {
-			sc.logger.Errorf("The credentials file at %s contained invalid JSON. This is probably caused by passing the wrong filepath. Reminder: the credentials file is a .json file created via `cloudflared tunnel create`.", e.path)
-			sc.logger.Errorf("Invalid JSON when parsing credentials file: %s", e.err.Error())
+			sc.log.Error().Msgf("The credentials file at %s contained invalid JSON. This is probably caused by passing the wrong filepath. Reminder: the credentials file is a .json file created via `cloudflared tunnel create`.", e.path)
+			sc.log.Error().Msgf("Invalid JSON when parsing credentials file: %s", e.err.Error())
 		}
 		return err
 	}
+
 	return StartServer(
 		sc.c,
 		version,
 		shutdownC,
 		graceShutdownC,
 		&connection.NamedTunnelConfig{Credentials: credentials},
-		sc.logger,
+		sc.log,
 		sc.isUIEnabled,
 	)
 }
@@ -276,9 +283,9 @@ func (sc *subcommandContext) cleanupConnections(tunnelIDs []uuid.UUID) error {
 		return err
 	}
 	for _, tunnelID := range tunnelIDs {
-		sc.logger.Infof("Cleanup connection for tunnel %s", tunnelID)
+		sc.log.Info().Msgf("Cleanup connection for tunnel %s", tunnelID)
 		if err := client.CleanupConnections(tunnelID); err != nil {
-			sc.logger.Errorf("Error cleaning up connections for tunnel %v, error :%v", tunnelID, err)
+			sc.log.Error().Msgf("Error cleaning up connections for tunnel %v, error :%v", tunnelID, err)
 		}
 	}
 	return nil
--- a/cmd/cloudflared/tunnel/subcommand_context_test.go
+++ b/cmd/cloudflared/tunnel/subcommand_context_test.go
@@ -4,16 +4,15 @@ import (
 	"encoding/base64"
 	"flag"
 	"fmt"
+	"github.com/rs/zerolog"
 	"reflect"
 	"testing"
 	"time"

 	"github.com/cloudflare/cloudflared/connection"
-	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/tunnelstore"
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v2"
 )

@@ -106,7 +105,7 @@ func (fs mockFileSystem) readFile(filePath string) ([]byte, error) {
 func Test_subcommandContext_findCredentials(t *testing.T) {
 	type fields struct {
 		c                 *cli.Context
-		logger            logger.Service
+		log               *zerolog.Logger
 		isUIEnabled       bool
 		fs                fileSystem
 		tunnelstoreClient tunnelstore.Client
@@ -137,8 +136,7 @@ func Test_subcommandContext_findCredentials(t *testing.T) {
 		},
 		vfp: func(string) bool { return true },
 	}
-	logger, err := logger.New()
-	require.NoError(t, err)
+	log := zerolog.Nop()

 	tests := []struct {
 		name    string
@@ -150,13 +148,13 @@ func Test_subcommandContext_findCredentials(t *testing.T) {
 		{
 			name: "Filepath given leads to old credentials file",
 			fields: fields{
-				logger: logger,
-				fs:     fs,
+				log: &log,
+				fs:  fs,
 				c: func() *cli.Context {
 					flagSet := flag.NewFlagSet("test0", flag.PanicOnError)
 					flagSet.String(CredFileFlag, oldCertPath, "")
 					c := cli.NewContext(cli.NewApp(), flagSet, nil)
-					err = c.Set(CredFileFlag, oldCertPath)
+					_ = c.Set(CredFileFlag, oldCertPath)
 					return c
 				}(),
 			},
@@ -172,13 +170,13 @@ func Test_subcommandContext_findCredentials(t *testing.T) {
 		{
 			name: "Filepath given leads to new credentials file",
 			fields: fields{
-				logger: logger,
-				fs:     fs,
+				log: &log,
+				fs:  fs,
 				c: func() *cli.Context {
 					flagSet := flag.NewFlagSet("test0", flag.PanicOnError)
 					flagSet.String(CredFileFlag, newCertPath, "")
 					c := cli.NewContext(cli.NewApp(), flagSet, nil)
-					err = c.Set(CredFileFlag, newCertPath)
+					_ = c.Set(CredFileFlag, newCertPath)
 					return c
 				}(),
 			},
@@ -197,7 +195,7 @@ func Test_subcommandContext_findCredentials(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			sc := &subcommandContext{
 				c:                 tt.fields.c,
-				logger:            tt.fields.logger,
+				log:               tt.fields.log,
 				isUIEnabled:       tt.fields.isUIEnabled,
 				fs:                tt.fields.fs,
 				tunnelstoreClient: tt.fields.tunnelstoreClient,
--- a/cmd/cloudflared/tunnel/subcommands.go
+++ b/cmd/cloudflared/tunnel/subcommands.go
@@ -223,7 +223,7 @@ func fmtAndPrintTunnelList(tunnels []*tunnelstore.Tunnel, showRecentlyDisconnect
 	defer writer.Flush()

 	// Print column headers with tabbed columns
-	fmt.Fprintln(writer, "ID\tNAME\tCREATED\tCONNECTIONS\t")
+	_, _ = fmt.Fprintln(writer, "ID\tNAME\tCREATED\tCONNECTIONS\t")

 	// Loop through tunnels, create formatted string for each, and print using tabwriter
 	for _, t := range tunnels {
@@ -234,7 +234,7 @@ func fmtAndPrintTunnelList(tunnels []*tunnelstore.Tunnel, showRecentlyDisconnect
 			t.CreatedAt.Format(time.RFC3339),
 			fmtConnections(t.Connections, showRecentlyDisconnected),
 		)
-		fmt.Fprintln(writer, formattedStr)
+		_, _ = fmt.Fprintln(writer, formattedStr)
 	}
 }

@@ -360,7 +360,7 @@ func runNamedTunnel(sc *subcommandContext, tunnelRef string) error {
 		return errors.Wrap(err, "error parsing tunnel ID")
 	}

-	sc.logger.Infof("Starting tunnel %s", tunnelID.String())
+	sc.log.Info().Msgf("Starting tunnel %s", tunnelID.String())

 	return sc.run(tunnelID)
 }
@@ -515,7 +515,7 @@ func routeCommand(c *cli.Context) error {
 		return err
 	}

-	sc.logger.Infof(res.SuccessSummary())
+	sc.log.Info().Msg(res.SuccessSummary())
 	return nil
 }