multi: add persistent logger

Author: guggero

client.go

@@ -192,7 +192,7 @@ func (s *Client) Run(ctx context.Context,
 	if err != nil {
 		return fmt.Errorf("GetInfo error: %v", err)
 	}
-	logger.Infof("Connected to lnd node %v with pubkey %v",
+	log.Infof("Connected to lnd node %v with pubkey %v",
 		info.Alias, hex.EncodeToString(info.IdentityPubkey[:]),
 	)
 
@@ -235,22 +235,22 @@ func (s *Client) Run(ctx context.Context,
 	}
 
 	if err != nil {
-		logger.Errorf("Swap client terminating: %v", err)
+		log.Errorf("Swap client terminating: %v", err)
 	} else {
-		logger.Info("Swap client terminating")
+		log.Info("Swap client terminating")
 	}
 
 	// Cancel all remaining active goroutines.
 	mainCancel()
 
 	// Wait for all to finish.
-	logger.Debug("Wait for executor to finish")
+	log.Debug("Wait for executor to finish")
 	s.executor.waitFinished()
 
-	logger.Debug("Wait for goroutines to finish")
+	log.Debug("Wait for goroutines to finish")
 	s.wg.Wait()
 
-	logger.Info("Swap client terminated")
+	log.Info("Swap client terminated")
 
 	return err
 }
@@ -270,7 +270,7 @@ func (s *Client) resumeSwaps(ctx context.Context,
 		}
 		swap, err := resumeLoopOutSwap(ctx, swapCfg, pend)
 		if err != nil {
-			logger.Errorf("resuming loop out swap: %v", err)
+			log.Errorf("resuming loop out swap: %v", err)
 			continue
 		}
 
@@ -283,7 +283,7 @@ func (s *Client) resumeSwaps(ctx context.Context,
 		}
 		swap, err := resumeLoopInSwap(ctx, swapCfg, pend)
 		if err != nil {
-			logger.Errorf("resuming loop in swap: %v", err)
+			log.Errorf("resuming loop in swap: %v", err)
 			continue
 		}
 
@@ -303,7 +303,7 @@ func (s *Client) resumeSwaps(ctx context.Context,
 func (s *Client) LoopOut(globalCtx context.Context,
 	request *OutRequest) (*lntypes.Hash, btcutil.Address, error) {
 
-	logger.Infof("LoopOut %v to %v (channel: %v)",
+	log.Infof("LoopOut %v to %v (channel: %v)",
 		request.Amount, request.DestAddr,
 		request.LoopOutChannel,
 	)
@@ -358,7 +358,7 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		return nil, err
 	}
 
-	logger.Infof("Offchain swap destination: %x", quote.SwapPaymentDest)
+	log.Infof("Offchain swap destination: %x", quote.SwapPaymentDest)
 
 	swapFee := quote.SwapFee
 
@@ -418,7 +418,7 @@ func (s *Client) waitForInitialized(ctx context.Context) error {
 func (s *Client) LoopIn(globalCtx context.Context,
 	request *LoopInRequest) (*lntypes.Hash, btcutil.Address, error) {
 
-	logger.Infof("Loop in %v (channel: %v)",
+	log.Infof("Loop in %v (channel: %v)",
 		request.Amount,
 		request.LoopInChannel,
 	)

cmd/loopd/config.go

@@ -1,5 +1,23 @@
 package main
 
+import (
+	"path/filepath"
+
+	"github.com/btcsuite/btcutil"
+)
+
+var (
+	loopDirBase = btcutil.AppDataDir("loop", false)
+
+	defaultLogLevel    = "info"
+	defaultLogDirname  = "logs"
+	defaultLogFilename = "loopd.log"
+	defaultLogDir      = filepath.Join(loopDirBase, defaultLogDirname)
+
+	defaultMaxLogFiles    = 3
+	defaultMaxLogFileSize = 10
+)
+
 type lndConfig struct {
 	Host        string `long:"host" description:"lnd instance rpc address"`
 	MacaroonDir string `long:"macaroondir" description:"Path to the directory containing all the required lnd macaroons"`
@@ -16,6 +34,12 @@ type config struct {
 	RPCListen   string `long:"rpclisten" description:"Address to listen on for gRPC clients"`
 	RESTListen  string `long:"restlisten" description:"Address to listen on for REST clients"`
 
+	LogDir         string `long:"logdir" description:"Directory to log output."`
+	MaxLogFiles    int    `long:"maxlogfiles" description:"Maximum logfiles to keep (0 for no rotation)"`
+	MaxLogFileSize int    `long:"maxlogfilesize" description:"Maximum logfile size in MB"`
+
+	DebugLevel string `short:"d" long:"debuglevel" description:"Logging level for all subsystems {trace, debug, info, warn, error, critical} -- You may also specify <subsystem>=<level>,<subsystem2>=<level>,... to set the log level for individual subsystems -- Use show to list available subsystems"`
+
 	Lnd *lndConfig `group:"lnd" namespace:"lnd"`
 
 	View viewParameters `command:"view" alias:"v" description:"View all swaps in the database. This command can only be executed when loopd is not running."`
@@ -27,10 +51,14 @@ const (
 )
 
 var defaultConfig = config{
-	Network:    "mainnet",
-	RPCListen:  "localhost:11010",
-	RESTListen: "localhost:8081",
-	Insecure:   false,
+	Network:        "mainnet",
+	RPCListen:      "localhost:11010",
+	RESTListen:     "localhost:8081",
+	Insecure:       false,
+	LogDir:         defaultLogDir,
+	MaxLogFiles:    defaultMaxLogFiles,
+	MaxLogFileSize: defaultMaxLogFileSize,
+	DebugLevel:     defaultLogLevel,
 	Lnd: &lndConfig{
 		Host: "localhost:10009",
 	},

cmd/loopd/daemon.go

@@ -40,7 +40,7 @@ func daemon(config *config) error {
 		}
 	}
 
-	logger.Infof("Swap server address: %v", config.SwapServer)
+	log.Infof("Swap server address: %v", config.SwapServer)
 
 	// Create an instance of the loop client library.
 	swapClient, cleanup, err := getClient(
@@ -73,7 +73,7 @@ func daemon(config *config) error {
 	looprpc.RegisterSwapClientServer(grpcServer, &server)
 
 	// Next, start the gRPC server listening for HTTP/2 connections.
-	logger.Infof("Starting gRPC listener")
+	log.Infof("Starting gRPC listener")
 	grpcListener, err := net.Listen("tcp", config.RPCListen)
 	if err != nil {
 		return fmt.Errorf("RPC server unable to listen on %s",
@@ -95,7 +95,7 @@ func daemon(config *config) error {
 		return err
 	}
 
-	logger.Infof("Starting REST proxy listener")
+	log.Infof("Starting REST proxy listener")
 	restListener, err := net.Listen("tcp", config.RESTListen)
 	if err != nil {
 		return fmt.Errorf("REST proxy unable to listen on %s",
@@ -115,14 +115,14 @@ func daemon(config *config) error {
 	go func() {
 		defer wg.Done()
 
-		logger.Infof("Starting swap client")
+		log.Infof("Starting swap client")
 		err := swapClient.Run(mainCtx, statusChan)
 		if err != nil {
-			logger.Error(err)
+			log.Error(err)
 		}
-		logger.Infof("Swap client stopped")
+		log.Infof("Swap client stopped")
 
-		logger.Infof("Stopping gRPC server")
+		log.Infof("Stopping gRPC server")
 		grpcServer.Stop()
 
 		cancel()
@@ -133,7 +133,7 @@ func daemon(config *config) error {
 	go func() {
 		defer wg.Done()
 
-		logger.Infof("Waiting for updates")
+		log.Infof("Waiting for updates")
 		for {
 			select {
 			case swap := <-statusChan:
@@ -160,12 +160,12 @@ func daemon(config *config) error {
 	go func() {
 		defer wg.Done()
 
-		logger.Infof("RPC server listening on %s", grpcListener.Addr())
-		logger.Infof("REST proxy listening on %s", restListener.Addr())
+		log.Infof("RPC server listening on %s", grpcListener.Addr())
+		log.Infof("REST proxy listening on %s", restListener.Addr())
 
 		err = grpcServer.Serve(grpcListener)
 		if err != nil {
-			logger.Error(err)
+			log.Error(err)
 		}
 	}()
 
@@ -175,7 +175,7 @@ func daemon(config *config) error {
 	// Run until the users terminates loopd or an error occurred.
 	select {
 	case <-interruptChannel:
-		logger.Infof("Received SIGINT (Ctrl+C).")
+		log.Infof("Received SIGINT (Ctrl+C).")
 
 		// TODO: Remove debug code.
 		// Debug code to dump goroutines on hanging exit.

cmd/loopd/log.go

@@ -1,24 +1,40 @@
 package main
 
 import (
-	"os"
-
 	"github.com/btcsuite/btclog"
+	"github.com/lightninglabs/loop"
+	"github.com/lightninglabs/loop/lndclient"
+	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightningnetwork/lnd/build"
 )
 
-// log is a logger that is initialized with no output filters.  This means the
-// package will not perform any logging by default until the caller requests
-// it.
 var (
-	backendLog = btclog.NewBackend(logWriter{})
-	logger     = backendLog.Logger("LOOPD")
+	logWriter = build.NewRotatingLogWriter()
+
+	log = build.NewSubLogger("LOOPD", logWriter.GenSubLogger)
 )
 
-// logWriter implements an io.Writer that outputs to both standard output and
-// the write-end pipe of an initialized log rotator.
-type logWriter struct{}
+func init() {
+	setSubLogger("LOOPD", log, nil)
+	addSubLogger("LOOP", loop.UseLogger)
+	addSubLogger("LNDC", lndclient.UseLogger)
+	addSubLogger("STORE", loopdb.UseLogger)
+}
+
+// addSubLogger is a helper method to conveniently create and register the
+// logger of a sub system.
+func addSubLogger(subsystem string, useLogger func(btclog.Logger)) {
+	logger := build.NewSubLogger(subsystem, logWriter.GenSubLogger)
+	setSubLogger(subsystem, logger, useLogger)
+}
+
+// setSubLogger is a helper method to conveniently register the logger of a sub
+// system.
+func setSubLogger(subsystem string, logger btclog.Logger,
+	useLogger func(btclog.Logger)) {
 
-func (logWriter) Write(p []byte) (n int, err error) {
-	os.Stdout.Write(p)
-	return len(p), nil
+	logWriter.RegisterSubLogger(subsystem, logger)
+	if useLogger != nil {
+		useLogger(logger)
+	}
 }

cmd/loopd/main.go

@@ -7,10 +7,9 @@ import (
 	"strings"
 	"sync"
 
-	flags "github.com/jessevdk/go-flags"
-
-	"github.com/btcsuite/btcutil"
+	"github.com/jessevdk/go-flags"
 	"github.com/lightninglabs/loop"
+	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/lntypes"
 )
 
@@ -19,7 +18,6 @@ const (
 )
 
 var (
-	loopDirBase           = btcutil.AppDataDir("loop", false)
 	defaultConfigFilename = "loopd.conf"
 
 	swaps            = make(map[lntypes.Hash]loop.SwapInfo)
@@ -81,8 +79,32 @@ func start() error {
 		os.Exit(0)
 	}
 
+	// Special show command to list supported subsystems and exit.
+	if config.DebugLevel == "show" {
+		fmt.Printf("Supported subsystems: %v\n",
+			logWriter.SupportedSubsystems())
+		os.Exit(0)
+	}
+
+	// Append the network type to the log directory so it is
+	// "namespaced" per network in the same fashion as the data directory.
+	config.LogDir = filepath.Join(config.LogDir, config.Network)
+
+	// Initialize logging at the default logging level.
+	err = logWriter.InitLogRotator(
+		filepath.Join(config.LogDir, defaultLogFilename),
+		config.MaxLogFileSize, config.MaxLogFiles,
+	)
+	if err != nil {
+		return err
+	}
+	err = build.ParseAndSetDebugLevels(config.DebugLevel, logWriter)
+	if err != nil {
+		return err
+	}
+
 	// Print the version before executing either primary directive.
-	logger.Infof("Version: %v", loop.Version())
+	log.Infof("Version: %v", loop.Version())
 
 	// Execute command.
 	if parser.Active == nil {