don't pass the log instance to every function

  * use a global logger instance
      HINT: plog.GlobalLogger()

README.org

@@ -128,7 +128,7 @@ sudo service sysctl restart
 You can use *lsleases* as a go library in your own programs.
 For example to trigger any custom action on device discovery.
 
-#+BEGIN_SRC go :tangle examples/simple-sniffer.go :mkdirp yes
+#+BEGIN_SRC go :tangle examples/simple-sniffer.go :mkdirp yes :eval no
 package main
 
 import "github.com/j-keck/lsleases/pkg/sniffer"
@@ -137,11 +137,11 @@ import "github.com/j-keck/plog"
 
 func main() {
   // create a logger instance
-  log := plog.NewDefaultConsoleLogger()
+  log := plog.GlobalLogger().Add(plog.NewDefaultConsoleLogger())
 
   // create the sniffer with the default configuration
   cfg := config.NewDefaultConfig()
-  sniffer := sniffer.NewSniffer(cfg, log)
+  sniffer := sniffer.NewSniffer(cfg)
 
   // subscribe to DHCP leases events and log the events
   go func() {
@@ -161,8 +161,6 @@ func main() {
 }
 #+END_SRC
 
-#+RESULTS:
-
 #+BEGIN_SRC shell :eval no
 GO111MODULE=on sudo go run examples/simple-sniffer.go
 #+END_SRC

cmd/lsleases/main.go

@@ -36,13 +36,13 @@ type CliConfig struct {
 func main() {
 	cfg := parseFlags()
 
-	log := plog.NewDefaultConsoleLogger()
+	log := plog.GlobalLogger().Add(plog.NewDefaultConsoleLogger())
 	log.SetLevel(cfg.logLevel)
 
 	switch cfg.action {
 	case PrintVersion:
 		var serverVersion string
-		if version, err := cscom.AskServer(log, cscom.GetVersion); err == nil {
+		if version, err := cscom.AskServer(cscom.GetVersion); err == nil {
 			serverVersion = version.(cscom.Version).String()
 		} else {
 			serverVersion = err.Error()
@@ -53,7 +53,7 @@ func main() {
 		flag.Usage()
 
 	case Standalone:
-		sniffer := sniffer.NewSniffer(config.NewDefaultConfig(), log)
+		sniffer := sniffer.NewSniffer(config.NewDefaultConfig())
 		go func() {
 			leasesC := sniffer.Subscribe(10)
 
@@ -73,7 +73,7 @@ func main() {
 
 
 	case ListLeases:
-		if leases, err := cscom.AskServer(log, cscom.GetLeases); err == nil {
+		if leases, err := cscom.AskServer(cscom.GetLeases); err == nil {
 			if cfg.jsonOutput {
 				listLeasesAsJson(leases.(cscom.Leases))
 			} else {
@@ -84,14 +84,14 @@ func main() {
 		}
 
 	case WatchLeases:
-		if leases, err := cscom.AskServer(log, cscom.GetLeases); err == nil {
+
+		if leases, err := cscom.AskServer(cscom.GetLeases); err == nil {
 
 			format := "%-9s  %-15s  %-17s  %s\n"
 			fmt.Printf(format, "Captured", "Ip", "Mac", "Host")
 			var ts int64
 			for {
 				if leases, err = cscom.AskServerWithPayload(
-					log,
 					cscom.GetLeasesSince,
 					fmt.Sprintf("%d", ts),
 				); err == nil {
@@ -114,10 +114,10 @@ func main() {
 		}
 
 	case ClearLeases:
-		cscom.TellServer(log, cscom.ClearLeases)
+		cscom.TellServer(cscom.ClearLeases)
 
 	case Shutdown:
-		cscom.TellServer(log, cscom.Shutdown)
+		cscom.TellServer(cscom.Shutdown)
 	}
 }
 

cmd/lsleasesd/main.go

@@ -29,29 +29,29 @@ func main() {
 	}
 
 	log := newLogger(cliCfg)
-	if err := daemon.Start(daemonCfg, log); err != nil {
+	if err := daemon.Start(daemonCfg); err != nil {
 		log.Errorf("unable to start daemon - %s", err.Error())
 	}
 }
 
 func newLogger(cliCfg CliConfig) plog.Logger {
 
-	log := plog.NewConsoleLogger(" | ")
-	log.SetLevel(cliCfg.logLevel)
+	consoleLogger := plog.NewConsoleLogger(" | ")
+	consoleLogger.SetLevel(cliCfg.logLevel)
 
 	if cliCfg.logTimestamps {
-		log.AddLogFormatter(plog.TimestampUnixDate)
+		consoleLogger.AddLogFormatter(plog.TimestampUnixDate)
 	}
 
-	log.AddLogFormatter(plog.Level)
+	consoleLogger.AddLogFormatter(plog.Level)
 
 	if cliCfg.logLevel == plog.Trace {
-		log.AddLogFormatter(plog.Location)
+		consoleLogger.AddLogFormatter(plog.Location)
 	}
 
-	log.AddLogFormatter(plog.Message)
+	consoleLogger.AddLogFormatter(plog.Message)
 
-	return log
+	return plog.GlobalLogger().Add(consoleLogger)
 }
 
 func parseFlags() (CliConfig, config.Config) {

examples/simple-sniffer.go

@@ -1,16 +1,17 @@
 package main
 
+
 import "github.com/j-keck/lsleases/pkg/sniffer"
 import "github.com/j-keck/lsleases/pkg/config"
 import "github.com/j-keck/plog"
 
 func main() {
   // create a logger instance
-  log := plog.NewDefaultConsoleLogger()
+  log := plog.GlobalLogger().Add(plog.NewDefaultConsoleLogger())
 
   // create the sniffer with the default configuration
   cfg := config.NewDefaultConfig()
-  sniffer := sniffer.NewSniffer(cfg, log)
+  sniffer := sniffer.NewSniffer(cfg)
 
   // subscribe to DHCP leases events and log the events
   go func() {

go.mod

@@ -2,5 +2,6 @@ module github.com/j-keck/lsleases
 
 require (
 	github.com/j-keck/arping v1.0.0
-	github.com/j-keck/plog v0.2.0
+	github.com/j-keck/npipe v0.0.0-20140709165524-960540cf17da // indirect
+	github.com/j-keck/plog v0.3.1
 )

go.sum

@@ -1,4 +1,8 @@
 github.com/j-keck/arping v1.0.0 h1:DN6Wy73IeadEEo5xVCgEp+ZGn2xmAypggxj8mtxXBD0=
 github.com/j-keck/arping v1.0.0/go.mod h1:ymszkNOg6tORTn+6F6j+Jc8TOr5osrynvN6ivFWZ2GA=
+github.com/j-keck/npipe v0.0.0-20140709165524-960540cf17da h1:SudnLPWLlxluCwG+rG57aMb5IzNSjkps7YnujoXCzCI=
+github.com/j-keck/npipe v0.0.0-20140709165524-960540cf17da/go.mod h1:EI3m1IbzpJKV1aVwKTfNeaDtt2bCMqTNaEraoB7KsmI=
 github.com/j-keck/plog v0.2.0 h1:zc7GH64QHK6VZ3BXGKcYS3K8jCtyyb+AmOhhXZNOcvU=
 github.com/j-keck/plog v0.2.0/go.mod h1:iGLlLlvHFSIeoRTzy8pcq26/04m2r+446IoFkxWrWfs=
+github.com/j-keck/plog v0.3.1 h1:dnKZ9y588R1Mbw0pB4/K2uXMCLXbd0OkATqX7uDGZb4=
+github.com/j-keck/plog v0.3.1/go.mod h1:iGLlLlvHFSIeoRTzy8pcq26/04m2r+446IoFkxWrWfs=

pkg/cscom/cscom.go

@@ -3,18 +3,21 @@ package cscom
 import (
 	"encoding/json"
 	"github.com/j-keck/lsleases/pkg/leases"
+	"github.com/j-keck/plog"
 	"io"
 	"net"
 )
 
+var log = plog.GlobalLogger()
+
 type ClientRequest string
 
 const (
-	GetVersion       = ClientRequest("get-version")
-	GetLeases        = ClientRequest("get-leases")
-	GetLeasesSince   = ClientRequest("get-leases-since")
-	ClearLeases      = ClientRequest("clear-leases")
-	Shutdown         = ClientRequest("shutdown")
+	GetVersion     = ClientRequest("get-version")
+	GetLeases      = ClientRequest("get-leases")
+	GetLeasesSince = ClientRequest("get-leases-since")
+	ClearLeases    = ClientRequest("clear-leases")
+	Shutdown       = ClientRequest("shutdown")
 )
 
 type ServerResponse interface {

pkg/cscom/cscom_client.go

@@ -1,12 +1,11 @@
 package cscom
 
 import (
-	"github.com/j-keck/lsleases/pkg/config"
-	"github.com/j-keck/plog"
 	"fmt"
+	"github.com/j-keck/lsleases/pkg/config"
 )
 
-func TellServer(log plog.Logger, clientReq ClientRequest) error {
+func TellServer(clientReq ClientRequest) error {
 	log.Tracef("connect to unix-domain-socket at: %s", config.SOCK_PATH)
 	con, err := connect()
 	if err != nil {
@@ -19,11 +18,11 @@ func TellServer(log plog.Logger, clientReq ClientRequest) error {
 	return err
 }
 
-func AskServer(log plog.Logger, clientReq ClientRequest) (ServerResponse, error) {
-	return AskServerWithPayload(log, clientReq, "")
+func AskServer(clientReq ClientRequest) (ServerResponse, error) {
+	return AskServerWithPayload(clientReq, "")
 }
 
-func AskServerWithPayload(log plog.Logger, clientReq ClientRequest, payload string) (ServerResponse, error) {
+func AskServerWithPayload(clientReq ClientRequest, payload string) (ServerResponse, error) {
 	log.Tracef("connect to unix-domain-socket at: %s", config.SOCK_PATH)
 	con, err := connect()
 	if err != nil {

pkg/cscom/cscom_server.go

@@ -2,36 +2,34 @@ package cscom
 
 import (
 	"github.com/j-keck/lsleases/pkg/config"
-	"github.com/j-keck/plog"
 	"net"
 	"strings"
 )
 
 type comServer struct {
-	log  plog.Logger
 	lsnr net.Listener
 }
 
-func NewComServer(log plog.Logger) (*comServer, error) {
+func NewComServer() (*comServer, error) {
 	log.Tracef("start listener on %s", config.SOCK_PATH)
-	lsnr, err := startListener(log)
+	lsnr, err := startListener()
 	if err != nil {
 		return new(comServer), err
 	}
 
-	return &comServer{log, lsnr}, nil
+	return &comServer{lsnr}, nil
 }
 
 func (self *comServer) Listen(cb func(ClientRequest, string) ServerResponse) error {
-	self.log.Trace("waiting for client connection")
+	log.Trace("waiting for client connection")
 	con, err := self.lsnr.Accept()
 	if err != nil {
 		return err
 	}
 
-	self.log.Trace("client connected - waiting for message")
+	log.Trace("client connected - waiting for message")
 	raw := strings.TrimSpace(readString(con))
-	self.log.Tracef("client message received: '%s'", raw)
+	log.Tracef("client message received: '%s'", raw)
 
 	// try to split the given message in a request and payload part.
 	var req ClientRequest
@@ -54,5 +52,5 @@ func (self *comServer) Listen(cb func(ClientRequest, string) ServerResponse) err
 }
 
 func (self *comServer) Stop() {
-	stopListener(self.log)
+	stopListener()
 }

pkg/cscom/cscom_server_nix.go

@@ -4,17 +4,16 @@ package cscom
 
 import (
 	"github.com/j-keck/lsleases/pkg/config"
-	"github.com/j-keck/plog"
 	"net"
 	"os"
 	"fmt"
 	"path"
 )
 
-func startListener(log plog.Logger) (net.Listener, error) {
+func startListener() (net.Listener, error) {
 	// remove stale sock file if it exists
 	if _, err := os.Stat(config.SOCK_PATH); err == nil {
-		if _, err := AskServer(log, GetVersion); err != nil {
+		if _, err := AskServer(GetVersion); err != nil {
 			log.Debugf("remove stale socket file %s", config.SOCK_PATH)
 			if err = os.Remove(config.SOCK_PATH); err != nil {
 				return nil, fmt.Errorf("delete stale socket file failed - %s", err.Error())
@@ -44,6 +43,6 @@ func startListener(log plog.Logger) (net.Listener, error) {
 	return ls, nil
 }
 
-func stopListener(log plog.Logger) error {
+func stopListener() error {
 	return os.Remove(config.SOCK_PATH)
 }

pkg/cscom/cscom_server_win.go

@@ -9,10 +9,10 @@ import (
 	"net"
 )
 
-func startListener(log plog.Logger) (net.Listener, error) {
+func startListener() (net.Listener, error) {
 	return npipe.Listen(config.SOCK_PATH)
 }
 
-func stopListener(log plog.Logger) error {
+func stopListener() error {
 	return nil
 }

pkg/daemon/daemon.go

@@ -11,22 +11,24 @@ import (
 	"strconv"
 )
 
+var log = plog.GlobalLogger()
+
 // FIXME:
 //  - shutdown logic - os.Exit(0) doen't "call" 'defer com.Stop()'.
 //    the old sock file are not deleted
 //  - shutdown logic is interleaved with the program logic
-func Start(cfg config.Config, log plog.Logger) error {
+func Start(cfg config.Config) error {
 	log.Infof("startup  - version: %s", version)
 
 	// client-server communication
-	com, err := cscom.NewComServer(log)
+	com, err := cscom.NewComServer()
 	if err != nil {
 		return err
 	}
 	defer com.Stop()
 
 	// initialize sniffer
-	sniffer := sniffer.NewCachedSniffer(cfg, log)
+	sniffer := sniffer.NewCachedSniffer(cfg)
 	if cfg.PersistentLeases {
 		if err := sniffer.LoadLeases(); err != nil {
 			log.Infof("unable to load leases - start with empty leases cache - %s", err.Error())

pkg/leases/alive_checker.go

@@ -1,7 +1,4 @@
 package leases
 
-import "github.com/j-keck/plog"
-
 type aliveChecker struct {
-	log plog.Logger
 }

pkg/leases/alive_checker_nix.go

@@ -3,17 +3,16 @@
 package leases
 
 import "github.com/j-keck/arping"
-import "github.com/j-keck/plog"
 import "net"
 import "errors"
 
-func NewAliveChecker(log plog.Logger) (*aliveChecker, error) {
+func NewAliveChecker() (*aliveChecker, error) {
 
 	// find any local ip where
 	//  * the interface is not down
 	//  * is no loopback interface (because it has no mac)
 	//  * is no v6 address
-	ip, err := findLocalIP(log)
+	ip, err := findLocalIP()
 	if err != nil {
 		return nil, err
 	}
@@ -23,7 +22,7 @@ func NewAliveChecker(log plog.Logger) (*aliveChecker, error) {
 	log.Tracef("arping to '%s' to check permission", ip.String())
 	if _, _, err := arping.Ping(ip); err == arping.ErrTimeout {
 		log.Tracef("arping check succeed")
-		return &aliveChecker{log}, nil
+		return new(aliveChecker), nil
 	} else {
 		return nil, errors.New("no permission for arping")
 	}
@@ -39,7 +38,7 @@ func (self *aliveChecker) IsAlive(ip string) (bool, error) {
 	}
 }
 
-func findLocalIP(log plog.Logger) (net.IP, error) {
+func findLocalIP() (net.IP, error) {
 	log.Trace("search interface for arping test")
 	ifaces, err := net.Interfaces()
 	if err != nil {