all: eliminate usage of global ProxyLogger

So setting up logging for ctrld binary and ctrld packages could be done
more easily, decouple the required setup for interactive vs daemon
running.

This is the first step toward replacing rs/zerolog libary with a
different logging library.

internal/clientinfo/client_info.go

@@ -79,6 +79,7 @@ type Table struct {
 	initOnce          sync.Once
 	stopOnce          sync.Once
 	refreshInterval   int
+	logger            *ctrld.Logger
 
 	dhcp           *dhcp
 	merlin         *merlinDiscover
@@ -98,11 +99,14 @@ type Table struct {
 	ptrNameservers []string
 }
 
-func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string) *Table {
+func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string, logger *ctrld.Logger) *Table {
 	refreshInterval := cfg.Service.DiscoverRefreshInterval
 	if refreshInterval <= 0 {
 		refreshInterval = 2 * 60 // 2 minutes
 	}
+	if logger == nil {
+		logger = ctrld.NopLogger
+	}
 	return &Table{
 		svcCfg:          cfg.Service,
 		quitCh:          make(chan struct{}),
@@ -111,6 +115,7 @@ func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string) *Table {
 		cdUID:           cdUID,
 		ptrNameservers:  ns,
 		refreshInterval: refreshInterval,
+		logger:          logger,
 	}
 }
 
@@ -179,7 +184,7 @@ func (t *Table) SetSelfIP(ip string) {
 
 // initSelfDiscover initializes necessary client metadata for self query.
 func (t *Table) initSelfDiscover() {
-	t.dhcp = &dhcp{selfIP: t.selfIP}
+	t.dhcp = &dhcp{selfIP: t.selfIP, logger: t.logger}
 	t.dhcp.addSelf()
 	t.ipResolvers = append(t.ipResolvers, t.dhcp)
 	t.macResolvers = append(t.macResolvers, t.dhcp)
@@ -189,14 +194,14 @@ func (t *Table) initSelfDiscover() {
 func (t *Table) init() {
 	// Custom client ID presents, use it as the only source.
 	if _, clientID := controld.ParseRawUID(t.cdUID); clientID != "" {
-		ctrld.ProxyLogger.Load().Debug().Msg("start self discovery with custom client id")
+		t.logger.Debug().Msg("start self discovery with custom client id")
 		t.initSelfDiscover()
 		return
 	}
 
 	// If we are running on platforms that should only do self discover, use it as the only source, too.
 	if ctrld.SelfDiscover() {
-		ctrld.ProxyLogger.Load().Debug().Msg("start self discovery on desktop platforms")
+		t.logger.Debug().Msg("start self discovery on desktop platforms")
 		t.initSelfDiscover()
 		return
 	}
@@ -208,7 +213,7 @@ func (t *Table) init() {
 	//  - Merlin
 	//  - Ubios
 	if t.discoverDHCP() || t.discoverARP() {
-		t.merlin = &merlinDiscover{}
+		t.merlin = &merlinDiscover{logger: t.logger}
 		t.ubios = &ubiosDiscover{}
 		discovers := map[string]interface {
 			refresher
@@ -219,7 +224,7 @@ func (t *Table) init() {
 		}
 		for platform, discover := range discovers {
 			if err := discover.refresh(); err != nil {
-				ctrld.ProxyLogger.Load().Warn().Err(err).Msgf("failed to init %s discover", platform)
+				t.logger.Warn().Err(err).Msgf("failed to init %s discover", platform)
 			}
 			t.hostnameResolvers = append(t.hostnameResolvers, discover)
 			t.refreshers = append(t.refreshers, discover)
@@ -227,10 +232,10 @@ func (t *Table) init() {
 	}
 	// Hosts file mapping.
 	if t.discoverHosts() {
-		t.hf = &hostsFile{}
-		ctrld.ProxyLogger.Load().Debug().Msg("start hosts file discovery")
+		t.hf = &hostsFile{logger: t.logger}
+		t.logger.Debug().Msg("start hosts file discovery")
 		if err := t.hf.init(); err != nil {
-			ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init hosts file discover")
+			t.logger.Error().Err(err).Msg("could not init hosts file discover")
 		} else {
 			t.hostnameResolvers = append(t.hostnameResolvers, t.hf)
 			t.refreshers = append(t.refreshers, t.hf)
@@ -239,10 +244,10 @@ func (t *Table) init() {
 	}
 	// DHCP lease files.
 	if t.discoverDHCP() {
-		t.dhcp = &dhcp{selfIP: t.selfIP}
-		ctrld.ProxyLogger.Load().Debug().Msg("start dhcp discovery")
+		t.dhcp = &dhcp{selfIP: t.selfIP, logger: t.logger}
+		t.logger.Debug().Msg("start dhcp discovery")
 		if err := t.dhcp.init(); err != nil {
-			ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init DHCP discover")
+			t.logger.Error().Err(err).Msg("could not init DHCP discover")
 		} else {
 			t.ipResolvers = append(t.ipResolvers, t.dhcp)
 			t.macResolvers = append(t.macResolvers, t.dhcp)
@@ -253,8 +258,8 @@ func (t *Table) init() {
 	// ARP/NDP table.
 	if t.discoverARP() {
 		t.arp = &arpDiscover{}
-		t.ndp = &ndpDiscover{}
-		ctrld.ProxyLogger.Load().Debug().Msg("start arp discovery")
+		t.ndp = &ndpDiscover{logger: t.logger}
+		t.logger.Debug().Msg("start arp discovery")
 		discovers := map[string]interface {
 			refresher
 			IpResolver
@@ -266,7 +271,7 @@ func (t *Table) init() {
 
 		for protocol, discover := range discovers {
 			if err := discover.refresh(); err != nil {
-				ctrld.ProxyLogger.Load().Error().Err(err).Msgf("could not init %s discover", protocol)
+				t.logger.Error().Err(err).Msgf("could not init %s discover", protocol)
 			} else {
 				t.ipResolvers = append(t.ipResolvers, discover)
 				t.macResolvers = append(t.macResolvers, discover)
@@ -283,7 +288,10 @@ func (t *Table) init() {
 	}
 	// PTR lookup.
 	if t.discoverPTR() {
-		t.ptr = &ptrDiscover{resolver: ctrld.NewPrivateResolver()}
+		t.ptr = &ptrDiscover{
+			resolver: ctrld.NewPrivateResolver(context.Background()),
+			logger:   t.logger,
+		}
 		if len(t.ptrNameservers) > 0 {
 			nss := make([]string, 0, len(t.ptrNameservers))
 			for _, ns := range t.ptrNameservers {
@@ -295,18 +303,18 @@ func (t *Table) init() {
 				if _, portErr := strconv.Atoi(port); portErr == nil && port != "0" && net.ParseIP(host) != nil {
 					nss = append(nss, net.JoinHostPort(host, port))
 				} else {
-					ctrld.ProxyLogger.Load().Warn().Msgf("ignoring invalid nameserver for ptr discover: %q", ns)
+					t.logger.Warn().Msgf("ignoring invalid nameserver for ptr discover: %q", ns)
 				}
 			}
 			if len(nss) > 0 {
 				t.ptr.resolver = ctrld.NewResolverWithNameserver(nss)
-				ctrld.ProxyLogger.Load().Debug().Msgf("using nameservers %v for ptr discovery", nss)
+				t.logger.Debug().Msgf("using nameservers %v for ptr discovery", nss)
 			}
 
 		}
-		ctrld.ProxyLogger.Load().Debug().Msg("start ptr discovery")
+		t.logger.Debug().Msg("start ptr discovery")
 		if err := t.ptr.refresh(); err != nil {
-			ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init PTR discover")
+			t.logger.Error().Err(err).Msg("could not init PTR discover")
 		} else {
 			t.hostnameResolvers = append(t.hostnameResolvers, t.ptr)
 			t.refreshers = append(t.refreshers, t.ptr)
@@ -314,10 +322,10 @@ func (t *Table) init() {
 	}
 	// mdns.
 	if t.discoverMDNS() {
-		t.mdns = &mdns{}
-		ctrld.ProxyLogger.Load().Debug().Msg("start mdns discovery")
+		t.mdns = &mdns{logger: t.logger}
+		t.logger.Debug().Msg("start mdns discovery")
 		if err := t.mdns.init(t.quitCh); err != nil {
-			ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init mDNS discover")
+			t.logger.Error().Err(err).Msg("could not init mDNS discover")
 		} else {
 			t.hostnameResolvers = append(t.hostnameResolvers, t.mdns)
 		}

internal/clientinfo/client_info_test.go

@@ -2,6 +2,8 @@ package clientinfo
 
 import (
 	"testing"
+
+	"github.com/Control-D-Inc/ctrld"
 )
 
 func Test_normalizeIP(t *testing.T) {
@@ -28,8 +30,9 @@ func Test_normalizeIP(t *testing.T) {
 
 func TestTable_LookupRFC1918IPv4(t *testing.T) {
 	table := &Table{
-		dhcp: &dhcp{},
-		arp:  &arpDiscover{},
+		dhcp:   &dhcp{},
+		arp:    &arpDiscover{},
+		logger: ctrld.NopLogger,
 	}
 
 	table.ipResolvers = append(table.ipResolvers, table.dhcp)

internal/clientinfo/dhcp.go

@@ -13,9 +13,8 @@ import (
 	"strings"
 	"sync"
 
-	"tailscale.com/net/netmon"
-
 	"github.com/fsnotify/fsnotify"
+	"tailscale.com/net/netmon"
 	"tailscale.com/util/lineread"
 
 	"github.com/Control-D-Inc/ctrld"
@@ -30,6 +29,7 @@ type dhcp struct {
 
 	watcher *fsnotify.Watcher
 	selfIP  string
+	logger  *ctrld.Logger
 }
 
 func (d *dhcp) init() error {
@@ -52,7 +52,7 @@ func (d *dhcp) watchChanges() {
 	}
 	if dir := router.LeaseFilesDir(); dir != "" {
 		if err := d.watcher.Add(dir); err != nil {
-			ctrld.ProxyLogger.Load().Err(err).Str("dir", dir).Msg("could not watch lease dir")
+			d.logger.Err(err).Str("dir", dir).Msg("could not watch lease dir")
 		}
 	}
 	for {
@@ -64,7 +64,7 @@ func (d *dhcp) watchChanges() {
 			if event.Has(fsnotify.Create) {
 				if format, ok := clientInfoFiles[event.Name]; ok {
 					if err := d.addLeaseFile(event.Name, format); err != nil {
-						ctrld.ProxyLogger.Load().Err(err).Str("file", event.Name).Msg("could not add lease file")
+						d.logger.Err(err).Str("file", event.Name).Msg("could not add lease file")
 					}
 				}
 				continue
@@ -72,14 +72,14 @@ func (d *dhcp) watchChanges() {
 			if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
 				format := clientInfoFiles[event.Name]
 				if err := d.readLeaseFile(event.Name, format); err != nil && !os.IsNotExist(err) {
-					ctrld.ProxyLogger.Load().Err(err).Str("file", event.Name).Msg("leases file changed but failed to update client info")
+					d.logger.Err(err).Str("file", event.Name).Msg("leases file changed but failed to update client info")
 				}
 			}
 		case err, ok := <-d.watcher.Errors:
 			if !ok {
 				return
 			}
-			ctrld.ProxyLogger.Load().Err(err).Msg("could not watch client info file")
+			d.logger.Err(err).Msg("could not watch client info file")
 		}
 	}
 
@@ -222,7 +222,7 @@ func (d *dhcp) dnsmasqReadClientInfoReader(reader io.Reader) error {
 		}
 		ip := normalizeIP(string(fields[2]))
 		if net.ParseIP(ip) == nil {
-			ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
+			d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
 			ip = ""
 		}
 
@@ -275,7 +275,7 @@ func (d *dhcp) iscDHCPReadClientInfoReader(reader io.Reader) error {
 		case "lease":
 			ip = normalizeIP(strings.ToLower(fields[1]))
 			if net.ParseIP(ip) == nil {
-				ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
+				d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
 				ip = ""
 			}
 		case "hardware":
@@ -328,7 +328,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
 		}
 		ip := normalizeIP(record[0])
 		if net.ParseIP(ip) == nil {
-			ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
+			d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
 			ip = ""
 		}
 
@@ -350,7 +350,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
 func (d *dhcp) addSelf() {
 	hostname, err := os.Hostname()
 	if err != nil {
-		ctrld.ProxyLogger.Load().Err(err).Msg("could not get hostname")
+		d.logger.Err(err).Msg("could not get hostname")
 		return
 	}
 	hostname = normalizeHostname(hostname)

internal/clientinfo/hostsfile.go

@@ -27,6 +27,7 @@ type hostsFile struct {
 	watcher *fsnotify.Watcher
 	mu      sync.Mutex
 	m       map[string][]string
+	logger  *ctrld.Logger
 }
 
 // init performs initialization works, which is necessary before hostsFile can be fully operated.
@@ -55,7 +56,7 @@ func (hf *hostsFile) refresh() error {
 	// override hosts file with host_entries.conf content if present.
 	hem, err := parseHostEntriesConf(hostEntriesConfPath)
 	if err != nil && !os.IsNotExist(err) {
-		ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not read host_entries.conf file")
+		hf.logger.Debug().Err(err).Msg("could not read host_entries.conf file")
 	}
 	for k, v := range hem {
 		hf.m[k] = v
@@ -77,14 +78,14 @@ func (hf *hostsFile) watchChanges() {
 			}
 			if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
 				if err := hf.refresh(); err != nil && !os.IsNotExist(err) {
-					ctrld.ProxyLogger.Load().Err(err).Msg("hosts file changed but failed to update client info")
+					hf.logger.Err(err).Msg("hosts file changed but failed to update client info")
 				}
 			}
 		case err, ok := <-hf.watcher.Errors:
 			if !ok {
 				return
 			}
-			ctrld.ProxyLogger.Load().Err(err).Msg("could not watch client info file")
+			hf.logger.Err(err).Msg("could not watch client info file")
 		}
 	}
 

internal/clientinfo/mdns.go

@@ -34,7 +34,8 @@ var (
 )
 
 type mdns struct {
-	name sync.Map // ip => hostname
+	name   sync.Map // ip => hostname
+	logger *ctrld.Logger
 }
 
 func (m *mdns) LookupHostnameByIP(ip string) string {
@@ -93,9 +94,9 @@ func (m *mdns) init(quitCh chan struct{}) error {
 	}
 
 	// Check if IPv6 is available once and use the result for the rest of the function.
-	ctrld.ProxyLogger.Load().Debug().Msgf("checking for IPv6 availability in mdns init")
+	m.logger.Debug().Msgf("checking for IPv6 availability in mdns init")
 	ipv6 := ctrldnet.IPv6Available(context.Background())
-	ctrld.ProxyLogger.Load().Debug().Msgf("IPv6 is %v in mdns init", ipv6)
+	m.logger.Debug().Msgf("IPv6 is %v in mdns init", ipv6)
 
 	v4ConnList := make([]*net.UDPConn, 0, len(ifaces))
 	v6ConnList := make([]*net.UDPConn, 0, len(ifaces))
@@ -129,11 +130,11 @@ func (m *mdns) probeLoop(conns []*net.UDPConn, remoteAddr net.Addr, quitCh chan
 	for {
 		err := m.probe(conns, remoteAddr)
 		if shouldStopProbing(err) {
-			ctrld.ProxyLogger.Load().Warn().Msgf("stop probing %q: %v", remoteAddr, err)
+			m.logger.Warn().Msgf("stop probing %q: %v", remoteAddr, err)
 			break
 		}
 		if err != nil {
-			ctrld.ProxyLogger.Load().Warn().Err(err).Msg("error while probing mdns")
+			m.logger.Warn().Err(err).Msg("error while probing mdns")
 			bo.BackOff(context.Background(), errors.New("mdns probe backoff"))
 			continue
 		}
@@ -161,7 +162,7 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
 			if errors.Is(err, net.ErrClosed) {
 				return
 			}
-			ctrld.ProxyLogger.Load().Debug().Err(err).Msg("mdns readLoop error")
+			m.logger.Debug().Err(err).Msg("mdns readLoop error")
 			return
 		}
 
@@ -184,11 +185,11 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
 			if ip != "" && name != "" {
 				name = normalizeHostname(name)
 				if val, loaded := m.name.LoadOrStore(ip, name); !loaded {
-					ctrld.ProxyLogger.Load().Debug().Msgf("found hostname: %q, ip: %q via mdns", name, ip)
+					m.logger.Debug().Msgf("found hostname: %q, ip: %q via mdns", name, ip)
 				} else {
 					old := val.(string)
 					if old != name {
-						ctrld.ProxyLogger.Load().Debug().Msgf("update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
+						m.logger.Debug().Msgf("update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
 						m.name.Store(ip, name)
 					}
 				}
@@ -227,7 +228,7 @@ func (m *mdns) probe(conns []*net.UDPConn, remoteAddr net.Addr) error {
 // getDataFromAvahiDaemonCache reads entries from avahi-daemon cache to update mdns data.
 func (m *mdns) getDataFromAvahiDaemonCache() {
 	if _, err := exec.LookPath("avahi-browse"); err != nil {
-		ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not find avahi-browse binary, skipping.")
+		m.logger.Debug().Err(err).Msg("could not find avahi-browse binary, skipping.")
 		return
 	}
 	// Run avahi-browse to discover services from cache:
@@ -237,7 +238,7 @@ func (m *mdns) getDataFromAvahiDaemonCache() {
 	//  - "-c" -> read from cache.
 	out, err := exec.Command("avahi-browse", "-a", "-r", "-p", "-c").Output()
 	if err != nil {
-		ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not browse services from avahi cache")
+		m.logger.Debug().Err(err).Msg("could not browse services from avahi cache")
 		return
 	}
 	m.storeDataFromAvahiBrowseOutput(bytes.NewReader(out))
@@ -257,7 +258,7 @@ func (m *mdns) storeDataFromAvahiBrowseOutput(r io.Reader) {
 		name := normalizeHostname(fields[6])
 		// Only using cache value if we don't have existed one.
 		if _, loaded := m.name.LoadOrStore(ip, name); !loaded {
-			ctrld.ProxyLogger.Load().Debug().Msgf("found hostname: %q, ip: %q via avahi cache", name, ip)
+			m.logger.Debug().Msgf("found hostname: %q, ip: %q via avahi cache", name, ip)
 		}
 	}
 }

internal/clientinfo/mdns_test.go

@@ -3,6 +3,8 @@ package clientinfo
 import (
 	"strings"
 	"testing"
+
+	"github.com/Control-D-Inc/ctrld"
 )
 
 func Test_mdns_storeDataFromAvahiBrowseOutput(t *testing.T) {
@@ -11,7 +13,7 @@ func Test_mdns_storeDataFromAvahiBrowseOutput(t *testing.T) {
 =;wlp0s20f3;IPv6;Foo\032\0402\041;_companion-link._tcp;local;Foo-2.local;192.168.1.123;64842;"rpBA=00:00:00:00:00:01" "rpHI=e6ae2cbbca0e" "rpAD=36566f4d850f" "rpVr=510.71.1" "rpHA=0ddc20fdddc8" "rpFl=0x30000" "rpHN=1d4a03afdefa" "rpMac=0"
 =;wlp0s20f3;IPv4;Foo\032\0402\041;_companion-link._tcp;local;Foo-2.local;192.168.1.123;64842;"rpBA=00:00:00:00:00:01" "rpHI=e6ae2cbbca0e" "rpAD=36566f4d850f" "rpVr=510.71.1" "rpHA=0ddc20fdddc8" "rpFl=0x30000" "rpHN=1d4a03afdefa" "rpMac=0"
 `
-	m := &mdns{}
+	m := &mdns{logger: ctrld.NopLogger}
 	m.storeDataFromAvahiBrowseOutput(strings.NewReader(content))
 	ip := "192.168.1.123"
 	val, loaded := m.name.LoadOrStore(ip, "")

internal/clientinfo/merlin.go

@@ -15,6 +15,7 @@ const merlinNvramCustomClientListKey = "custom_clientlist"
 
 type merlinDiscover struct {
 	hostname sync.Map // mac => hostname
+	logger   *ctrld.Logger
 }
 
 func (m *merlinDiscover) refresh() error {
@@ -25,7 +26,7 @@ func (m *merlinDiscover) refresh() error {
 	if err != nil {
 		return err
 	}
-	ctrld.ProxyLogger.Load().Debug().Msg("reading Merlin custom client list")
+	m.logger.Debug().Msg("reading Merlin custom client list")
 	m.parseMerlinCustomClientList(out)
 	return nil
 }

internal/clientinfo/ndp.go

@@ -20,8 +20,9 @@ import (
 
 // ndpDiscover provides client discovery functionality using NDP protocol.
 type ndpDiscover struct {
-	mac sync.Map // ip  => mac
-	ip  sync.Map // mac => ip
+	mac    sync.Map // ip  => mac
+	ip     sync.Map // mac => ip
+	logger *ctrld.Logger
 }
 
 // refresh re-scans the NDP table.
@@ -97,7 +98,7 @@ func (nd *ndpDiscover) saveInfo(ip, mac string) {
 func (nd *ndpDiscover) listen(ctx context.Context) {
 	ifis, err := allInterfacesWithV6LinkLocal()
 	if err != nil {
-		ctrld.ProxyLogger.Load().Debug().Err(err).Msg("failed to find valid ipv6 interfaces")
+		nd.logger.Debug().Err(err).Msg("failed to find valid ipv6 interfaces")
 		return
 	}
 	for _, ifi := range ifis {
@@ -110,11 +111,11 @@ func (nd *ndpDiscover) listen(ctx context.Context) {
 func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface) {
 	c, ip, err := ndp.Listen(ifi, ndp.Unspecified)
 	if err != nil {
-		ctrld.ProxyLogger.Load().Debug().Err(err).Msg("ndp listen failed")
+		nd.logger.Debug().Err(err).Msg("ndp listen failed")
 		return
 	}
 	defer c.Close()
-	ctrld.ProxyLogger.Load().Debug().Msgf("listening ndp on: %s", ip.String())
+	nd.logger.Debug().Msgf("listening ndp on: %s", ip.String())
 	for {
 		select {
 		case <-ctx.Done():
@@ -128,7 +129,7 @@ func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface
 			if errors.As(readErr, &opErr) && (opErr.Timeout() || opErr.Temporary()) {
 				continue
 			}
-			ctrld.ProxyLogger.Load().Debug().Err(readErr).Msg("ndp read loop error")
+			nd.logger.Debug().Err(readErr).Msg("ndp read loop error")
 			return
 		}
 

internal/clientinfo/ndp_linux.go

@@ -5,15 +5,13 @@ import (
 
 	"github.com/vishvananda/netlink"
 	"golang.org/x/sys/unix"
-
-	"github.com/Control-D-Inc/ctrld"
 )
 
 // scan populates NDP table using information from system mappings.
 func (nd *ndpDiscover) scan() {
 	neighs, err := netlink.NeighList(0, netlink.FAMILY_V6)
 	if err != nil {
-		ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not get neigh list")
+		nd.logger.Warn().Err(err).Msg("could not get neigh list")
 		return
 	}
 
@@ -34,7 +32,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
 	done := make(chan struct{})
 	defer close(done)
 	if err := netlink.NeighSubscribe(ch, done); err != nil {
-		ctrld.ProxyLogger.Load().Err(err).Msg("could not perform neighbor subscribing")
+		nd.logger.Err(err).Msg("could not perform neighbor subscribing")
 		return
 	}
 	for {
@@ -47,7 +45,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
 			}
 			ip := normalizeIP(nu.IP.String())
 			if nu.Type == unix.RTM_DELNEIGH {
-				ctrld.ProxyLogger.Load().Debug().Msgf("removing NDP neighbor: %s", ip)
+				nd.logger.Debug().Msgf("removing NDP neighbor: %s", ip)
 				nd.mac.Delete(ip)
 				continue
 			}
@@ -56,7 +54,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
 			case netlink.NUD_REACHABLE:
 				nd.saveInfo(ip, mac)
 			case netlink.NUD_FAILED:
-				ctrld.ProxyLogger.Load().Debug().Msgf("removing NDP neighbor with failed state: %s", ip)
+				nd.logger.Debug().Msgf("removing NDP neighbor with failed state: %s", ip)
 				nd.mac.Delete(ip)
 			}
 		}

internal/clientinfo/ndp_others.go

@@ -7,8 +7,6 @@ import (
 	"context"
 	"os/exec"
 	"runtime"
-
-	"github.com/Control-D-Inc/ctrld"
 )
 
 // scan populates NDP table using information from system mappings.
@@ -17,14 +15,14 @@ func (nd *ndpDiscover) scan() {
 	case "windows":
 		data, err := exec.Command("netsh", "interface", "ipv6", "show", "neighbors").Output()
 		if err != nil {
-			ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not query ndp table")
+			nd.logger.Warn().Err(err).Msg("could not query ndp table")
 			return
 		}
 		nd.scanWindows(bytes.NewReader(data))
 	default:
 		data, err := exec.Command("ndp", "-an").Output()
 		if err != nil {
-			ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not query ndp table")
+			nd.logger.Warn().Err(err).Msg("could not query ndp table")
 			return
 		}
 		nd.scanUnix(bytes.NewReader(data))

internal/clientinfo/ptr_lookup.go

@@ -17,6 +17,7 @@ type ptrDiscover struct {
 	hostname   sync.Map // ip => hostname
 	resolver   ctrld.Resolver
 	serverDown atomic.Bool
+	logger     *ctrld.Logger
 }
 
 func (p *ptrDiscover) refresh() error {
@@ -73,14 +74,14 @@ func (p *ptrDiscover) lookupHostname(ip string) string {
 	msg := new(dns.Msg)
 	addr, err := dns.ReverseAddr(ip)
 	if err != nil {
-		ctrld.ProxyLogger.Load().Info().Str("discovery", "ptr").Err(err).Msg("invalid ip address")
+		p.logger.Info().Str("discovery", "ptr").Err(err).Msg("invalid ip address")
 		return ""
 	}
 	msg.SetQuestion(addr, dns.TypePTR)
 	ans, err := p.resolver.Resolve(ctx, msg)
 	if err != nil {
 		if p.serverDown.CompareAndSwap(false, true) {
-			ctrld.ProxyLogger.Load().Info().Str("discovery", "ptr").Err(err).Msg("could not perform PTR lookup")
+			p.logger.Info().Str("discovery", "ptr").Err(err).Msg("could not perform PTR lookup")
 			go p.checkServer()
 		}
 		return ""