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.

cmd/cli/cli.go

@@ -349,7 +349,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
 	if newLogPath := cfg.Service.LogPath; newLogPath != "" && oldLogPath != newLogPath {
 		// After processCDFlags, log config may change, so reset mainLog and re-init logging.
 		l := zerolog.New(io.Discard)
-		mainLog.Store(&l)
+		mainLog.Store(&ctrld.Logger{Logger: &l})
 
 		// Copy logs written so far to new log file if possible.
 		if buf, err := os.ReadFile(oldLogPath); err == nil {
@@ -502,8 +502,7 @@ func readConfigFile(writeDefaultConfig, notice bool) bool {
 		if err := v.Unmarshal(&cfg); err != nil {
 			mainLog.Load().Fatal().Msgf("failed to unmarshal default config: %v", err)
 		}
-		nop := zerolog.Nop()
-		_, _ = tryUpdateListenerConfig(&cfg, &nop, func() {}, true)
+		_, _ = tryUpdateListenerConfig(&cfg, func() {}, true)
 		addExtraSplitDnsRule(&cfg)
 		if err := writeConfigFile(&cfg); err != nil {
 			mainLog.Load().Fatal().Msgf("failed to write default config file: %v", err)
@@ -591,7 +590,8 @@ func processNoConfigFlags(noConfigStart bool) {
 		Type:     pType,
 		Timeout:  5000,
 	}
-	puc.Init()
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+	puc.Init(loggerCtx)
 	upstream := map[string]*ctrld.UpstreamConfig{"0": puc}
 	if secondaryUpstream != "" {
 		sEndpoint, sType := endpointAndTyp(secondaryUpstream)
@@ -601,7 +601,7 @@ func processNoConfigFlags(noConfigStart bool) {
 			Type:     sType,
 			Timeout:  5000,
 		}
-		suc.Init()
+		suc.Init(loggerCtx)
 		upstream["1"] = suc
 		rules := make([]ctrld.Rule, 0, len(domains))
 		for _, domain := range domains {
@@ -634,13 +634,13 @@ func processCDFlags(cfg *ctrld.Config) (*controld.ResolverConfig, error) {
 	logger.Info().Msgf("fetching Controld D configuration from API: %s", cdUID)
 	bo := backoff.NewBackoff("processCDFlags", logf, 30*time.Second)
 	bo.LogLongerThan = 30 * time.Second
-	ctx := context.Background()
-	resolverConfig, err := controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev)
+	ctx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+	resolverConfig, err := controld.FetchResolverConfig(ctx, cdUID, rootCmd.Version, cdDev)
 	for {
 		if errUrlNetworkError(err) {
 			bo.BackOff(ctx, err)
 			logger.Warn().Msg("could not fetch resolver using bootstrap DNS, retrying...")
-			resolverConfig, err = controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev)
+			resolverConfig, err = controld.FetchResolverConfig(ctx, cdUID, rootCmd.Version, cdDev)
 			continue
 		}
 		break
@@ -938,9 +938,10 @@ func selfCheckResolveDomain(ctx context.Context, addr, scope string, domain stri
 		bo.BackOff(ctx, fmt.Errorf("ExchangeContext: %w", exErr))
 	}
 	mainLog.Load().Debug().Msgf("self-check against %q failed", domain)
+	loggerCtx := ctrld.LoggerCtx(ctx, mainLog.Load())
 	// Ping all upstreams to provide better error message to users.
 	for name, uc := range cfg.Upstream {
-		if err := uc.ErrorPing(); err != nil {
+		if err := uc.ErrorPing(loggerCtx); err != nil {
 			mainLog.Load().Err(err).Msgf("failed to connect to upstream.%s, endpoint: %s", name, uc.Endpoint)
 		}
 	}
@@ -1181,7 +1182,7 @@ func mobileListenerIp() string {
 // or defined but invalid to be used, e.g: using loopback address other
 // than 127.0.0.1 with systemd-resolved.
 func updateListenerConfig(cfg *ctrld.Config, notifyToLogServerFunc func()) bool {
-	updated, _ := tryUpdateListenerConfig(cfg, nil, notifyToLogServerFunc, true)
+	updated, _ := tryUpdateListenerConfig(cfg, notifyToLogServerFunc, true)
 	if addExtraSplitDnsRule(cfg) {
 		updated = true
 	}
@@ -1191,7 +1192,7 @@ func updateListenerConfig(cfg *ctrld.Config, notifyToLogServerFunc func()) bool
 // tryUpdateListenerConfig tries updating listener config with a working one.
 // If fatal is true, and there's listen address conflicted, the function do
 // fatal error.
-func tryUpdateListenerConfig(cfg *ctrld.Config, infoLogger *zerolog.Logger, notifyFunc func(), fatal bool) (updated, ok bool) {
+func tryUpdateListenerConfig(cfg *ctrld.Config, notifyFunc func(), fatal bool) (updated, ok bool) {
 	ok = true
 	lcc := make(map[string]*listenerConfigCheck)
 	cdMode := cdUID != ""
@@ -1235,9 +1236,6 @@ func tryUpdateListenerConfig(cfg *ctrld.Config, infoLogger *zerolog.Logger, noti
 	}
 
 	il := mainLog.Load()
-	if infoLogger != nil {
-		il = infoLogger
-	}
 	if isMobile() {
 		// On Mobile, only use first listener, ignore others.
 		firstLn := cfg.FirstListener()
@@ -1492,7 +1490,8 @@ func cdUIDFromProvToken() string {
 	}
 	req := &controld.UtilityOrgRequest{ProvToken: cdOrg, Hostname: customHostname}
 	// Process provision token if provided.
-	resolverConfig, err := controld.FetchResolverUID(req, rootCmd.Version, cdDev)
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+	resolverConfig, err := controld.FetchResolverUID(loggerCtx, req, rootCmd.Version, cdDev)
 	if err != nil {
 		mainLog.Load().Fatal().Err(err).Msgf("failed to fetch resolver uid with provision token: %s", cdOrg)
 	}
@@ -1819,7 +1818,8 @@ func runningIface(s service.Service) *ifaceResponse {
 
 // doValidateCdRemoteConfig fetches and validates custom config for cdUID.
 func doValidateCdRemoteConfig(cdUID string, fatal bool) error {
-	rc, err := controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev)
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+	rc, err := controld.FetchResolverConfig(loggerCtx, cdUID, rootCmd.Version, cdDev)
 	if err != nil {
 		logger := mainLog.Load().Fatal()
 		if !fatal {

cmd/cli/control_server.go

@@ -216,8 +216,9 @@ func (p *prog) registerControlServerHandler() {
 			return
 		}
 
+		loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
 		// Re-fetch pin code from API.
-		if rc, err := controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev); rc != nil {
+		if rc, err := controld.FetchResolverConfig(loggerCtx, cdUID, rootCmd.Version, cdDev); rc != nil {
 			if rc.DeactivationPin != nil {
 				cdDeactivationPin.Store(*rc.DeactivationPin)
 			} else {
@@ -321,7 +322,8 @@ func (p *prog) registerControlServerHandler() {
 		}
 		mainLog.Load().Debug().Msg("sending log file to ControlD server")
 		resp := logSentResponse{Size: r.size}
-		if err := controld.SendLogs(req, cdDev); err != nil {
+		loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+		if err := controld.SendLogs(loggerCtx, req, cdDev); err != nil {
 			mainLog.Load().Error().Msgf("could not send log file to ControlD server: %v", err)
 			resp.Error = err.Error()
 			w.WriteHeader(http.StatusInternalServerError)

cmd/cli/dns_proxy.go

@@ -110,6 +110,7 @@ func (p *prog) serveDNS(mainCtx context.Context, listenerNum string) error {
 		listenerConfig := p.cfg.Listener[listenerNum]
 		reqId := requestID()
 		ctx := context.WithValue(context.Background(), ctrld.ReqIdCtxKey{}, reqId)
+		ctx = ctrld.LoggerCtx(ctx, mainLog.Load())
 		if !listenerConfig.AllowWanClients && isWanClient(w.RemoteAddr()) {
 			ctrld.Log(ctx, mainLog.Load().Debug(), "query refused, listener does not allow WAN clients: %s", w.RemoteAddr().String())
 			answer := new(dns.Msg)
@@ -514,7 +515,7 @@ func (p *prog) proxy(ctx context.Context, req *proxyRequest) *proxyResponse {
 	}
 	resolve1 := func(upstream string, upstreamConfig *ctrld.UpstreamConfig, msg *dns.Msg) (*dns.Msg, error) {
 		ctrld.Log(ctx, mainLog.Load().Debug(), "sending query to %s: %s", upstream, upstreamConfig.Name)
-		dnsResolver, err := ctrld.NewResolver(upstreamConfig)
+		dnsResolver, err := ctrld.NewResolver(ctx, upstreamConfig)
 		if err != nil {
 			ctrld.Log(ctx, mainLog.Load().Error().Err(err), "failed to create resolver")
 			return nil, err
@@ -549,11 +550,11 @@ func (p *prog) proxy(ctx context.Context, req *proxyRequest) *proxyResponse {
 			// For timeout error (i.e: context deadline exceed), force re-bootstrapping.
 			var e net.Error
 			if errors.As(err, &e) && e.Timeout() {
-				upstreamConfig.ReBootstrap()
+				upstreamConfig.ReBootstrap(ctx)
 			}
 			// For network error, turn ipv6 off if enabled.
-			if ctrld.HasIPv6() && (errUrlNetworkError(err) || errNetworkError(err)) {
-				ctrld.DisableIPv6()
+			if ctrld.HasIPv6(ctx) && (errUrlNetworkError(err) || errNetworkError(err)) {
+				ctrld.DisableIPv6(ctx)
 			}
 		}
 
@@ -960,7 +961,8 @@ func (p *prog) doSelfUninstall(answer *dns.Msg) {
 	logger := mainLog.Load().With().Str("mode", "self-uninstall").Logger()
 	if p.refusedQueryCount > selfUninstallMaxQueries {
 		p.checkingSelfUninstall = true
-		_, err := controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev)
+		loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+		_, err := controld.FetchResolverConfig(loggerCtx, cdUID, rootCmd.Version, cdDev)
 		logger.Debug().Msg("maximum number of refused queries reached, checking device status")
 		selfUninstallCheck(err, p, logger)
 
@@ -1326,13 +1328,13 @@ func (p *prog) monitorNetworkChanges(ctx context.Context) error {
 
 		// Only set the IPv4 default if selfIP is a valid IPv4 address.
 		if ip := net.ParseIP(selfIP); ip != nil && ip.To4() != nil {
-			ctrld.SetDefaultLocalIPv4(ip)
+			ctrld.SetDefaultLocalIPv4(ctrld.LoggerCtx(ctx, mainLog.Load()), ip)
 			if !isMobile() && p.ciTable != nil {
 				p.ciTable.SetSelfIP(selfIP)
 			}
 		}
 		if ip := net.ParseIP(ipv6); ip != nil {
-			ctrld.SetDefaultLocalIPv6(ip)
+			ctrld.SetDefaultLocalIPv6(ctrld.LoggerCtx(ctx, mainLog.Load()), ip)
 		}
 		mainLog.Load().Debug().Msgf("Set default local IPv4: %s, IPv6: %s", selfIP, ipv6)
 
@@ -1400,7 +1402,7 @@ func interfaceIPsEqual(a, b []netip.Prefix) bool {
 func (p *prog) checkUpstreamOnce(upstream string, uc *ctrld.UpstreamConfig) error {
 	mainLog.Load().Debug().Msgf("Starting check for upstream: %s", upstream)
 
-	resolver, err := ctrld.NewResolver(uc)
+	resolver, err := ctrld.NewResolver(ctrld.LoggerCtx(context.Background(), mainLog.Load()), uc)
 	if err != nil {
 		mainLog.Load().Error().Err(err).Msgf("Failed to create resolver for upstream %s", upstream)
 		return err
@@ -1418,7 +1420,7 @@ func (p *prog) checkUpstreamOnce(upstream string, uc *ctrld.UpstreamConfig) erro
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	uc.ReBootstrap()
+	uc.ReBootstrap(ctrld.LoggerCtx(ctx, mainLog.Load()))
 	mainLog.Load().Debug().Msgf("Rebootstrapping resolver for upstream: %s", upstream)
 
 	start := time.Now()
@@ -1474,10 +1476,11 @@ func (p *prog) handleRecovery(reason RecoveryReason) {
 	// will be appended to nameservers from the saved interface values
 	p.resetDNS(false, false)
 
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
 	// For an OS failure, reinitialize OS resolver nameservers immediately.
 	if reason == RecoveryReasonOSFailure {
 		mainLog.Load().Debug().Msg("OS resolver failure detected; reinitializing OS resolver nameservers")
-		ns := ctrld.InitializeOsResolver(true)
+		ns := ctrld.InitializeOsResolver(loggerCtx, true)
 		if len(ns) == 0 {
 			mainLog.Load().Warn().Msg("No nameservers found for OS resolver; using existing values")
 		} else {
@@ -1504,7 +1507,7 @@ func (p *prog) handleRecovery(reason RecoveryReason) {
 
 	// For network changes we also reinitialize the OS resolver.
 	if reason == RecoveryReasonNetworkChange {
-		ns := ctrld.InitializeOsResolver(true)
+		ns := ctrld.InitializeOsResolver(loggerCtx, true)
 		if len(ns) == 0 {
 			mainLog.Load().Warn().Msg("No nameservers found for OS resolver during network-change recovery; using existing values")
 		} else {
@@ -1564,7 +1567,7 @@ func (p *prog) waitForUpstreamRecovery(ctx context.Context, upstreams map[string
 					// we should try to reinit the OS resolver to ensure we can recover
 					if name == upstreamOS && attempts%3 == 0 {
 						mainLog.Load().Debug().Msgf("UpstreamOS check failed on attempt %d, reinitializing OS resolver", attempts)
-						ns := ctrld.InitializeOsResolver(true)
+						ns := ctrld.InitializeOsResolver(ctrld.LoggerCtx(ctx, mainLog.Load()), true)
 						if len(ns) == 0 {
 							mainLog.Load().Warn().Msg("No nameservers found for OS resolver; using existing values")
 						} else {
@@ -1624,12 +1627,12 @@ func ValidateDefaultLocalIPsFromDelta(newState *netmon.State) {
 	// Check if the default IPv4 is still active.
 	if currentIPv4 != nil && !activeIPs[currentIPv4.String()] {
 		mainLog.Load().Debug().Msgf("DefaultLocalIPv4 %s is no longer active in the new state. Resetting.", currentIPv4)
-		ctrld.SetDefaultLocalIPv4(nil)
+		ctrld.SetDefaultLocalIPv4(ctrld.LoggerCtx(context.Background(), mainLog.Load()), nil)
 	}
 
 	// Check if the default IPv6 is still active.
 	if currentIPv6 != nil && !activeIPs[currentIPv6.String()] {
 		mainLog.Load().Debug().Msgf("DefaultLocalIPv6 %s is no longer active in the new state. Resetting.", currentIPv6)
-		ctrld.SetDefaultLocalIPv6(nil)
+		ctrld.SetDefaultLocalIPv6(ctrld.LoggerCtx(context.Background(), mainLog.Load()), nil)
 	}
 }

cmd/cli/log_writer.go

@@ -137,8 +137,7 @@ func (p *prog) initInternalLogging(writers []io.Writer) {
 	})
 	multi := zerolog.MultiLevelWriter(writers...)
 	l := mainLog.Load().Output(multi).With().Logger()
-	mainLog.Store(&l)
-	ctrld.ProxyLogger.Store(&l)
+	mainLog.Store(&ctrld.Logger{Logger: &l})
 }
 
 // needInternalLogging reports whether prog needs to run internal logging.

cmd/cli/loop.go

@@ -102,6 +102,7 @@ func (p *prog) checkDnsLoop() {
 	}
 	p.loopMu.Unlock()
 
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
 	for uid := range p.loop {
 		msg := loopTestMsg(uid)
 		uc := upstream[uid]
@@ -109,7 +110,7 @@ func (p *prog) checkDnsLoop() {
 		if uc == nil {
 			continue
 		}
-		resolver, err := ctrld.NewResolver(uc)
+		resolver, err := ctrld.NewResolver(loggerCtx, uc)
 		if err != nil {
 			mainLog.Load().Warn().Err(err).Msgf("could not perform loop check for upstream: %q, endpoint: %q", uc.Name, uc.Endpoint)
 			continue

cmd/cli/main.go

@@ -40,7 +40,7 @@ var (
 	cleanup           bool
 	startOnly         bool
 
-	mainLog       atomic.Pointer[zerolog.Logger]
+	mainLog       atomic.Pointer[ctrld.Logger]
 	consoleWriter zerolog.ConsoleWriter
 	noConfigStart bool
 )
@@ -54,7 +54,7 @@ const (
 
 func init() {
 	l := zerolog.New(io.Discard)
-	mainLog.Store(&l)
+	mainLog.Store(&ctrld.Logger{Logger: &l})
 }
 
 func Main() {
@@ -87,16 +87,14 @@ func initConsoleLogging() {
 	})
 	multi := zerolog.MultiLevelWriter(consoleWriter)
 	l := mainLog.Load().Output(multi).With().Timestamp().Logger()
-	mainLog.Store(&l)
+	mainLog.Store(&ctrld.Logger{Logger: &l})
 
 	switch {
 	case silent:
 		zerolog.SetGlobalLevel(zerolog.NoLevel)
 	case verbose == 1:
-		ctrld.ProxyLogger.Store(&l)
 		zerolog.SetGlobalLevel(zerolog.InfoLevel)
 	case verbose > 1:
-		ctrld.ProxyLogger.Store(&l)
 		zerolog.SetGlobalLevel(zerolog.DebugLevel)
 	default:
 		zerolog.SetGlobalLevel(zerolog.NoticeLevel)
@@ -113,8 +111,6 @@ func initInteractiveLogging() {
 	zerolog.TimeFieldFormat = time.RFC3339 + ".000"
 	initLoggingWithBackup(false)
 	cfg.Service.LogPath = old
-	l := zerolog.New(io.Discard)
-	ctrld.ProxyLogger.Store(&l)
 }
 
 // initLoggingWithBackup initializes log setup base on current config.
@@ -153,9 +149,7 @@ func initLoggingWithBackup(doBackup bool) []io.Writer {
 	writers = append(writers, consoleWriter)
 	multi := zerolog.MultiLevelWriter(writers...)
 	l := mainLog.Load().Output(multi).With().Logger()
-	mainLog.Store(&l)
-	// TODO: find a better way.
-	ctrld.ProxyLogger.Store(&l)
+	mainLog.Store(&ctrld.Logger{Logger: &l})
 
 	zerolog.SetGlobalLevel(zerolog.NoticeLevel)
 	logLevel := cfg.Service.LogLevel

cmd/cli/main_test.go

@@ -6,12 +6,14 @@ import (
 	"testing"
 
 	"github.com/rs/zerolog"
+
+	"github.com/Control-D-Inc/ctrld"
 )
 
 var logOutput strings.Builder
 
 func TestMain(m *testing.M) {
 	l := zerolog.New(&logOutput)
-	mainLog.Store(&l)
+	mainLog.Store(&ctrld.Logger{Logger: &l})
 	os.Exit(m.Run())
 }

cmd/cli/netlink_linux.go

@@ -5,6 +5,8 @@ import (
 
 	"github.com/vishvananda/netlink"
 	"golang.org/x/sys/unix"
+
+	"github.com/Control-D-Inc/ctrld"
 )
 
 func (p *prog) watchLinkState(ctx context.Context) {
@@ -26,7 +28,7 @@ func (p *prog) watchLinkState(ctx context.Context) {
 			if lu.Change&unix.IFF_UP != 0 {
 				mainLog.Load().Debug().Msgf("link state changed, re-bootstrapping")
 				for _, uc := range p.cfg.Upstream {
-					uc.ReBootstrap()
+					uc.ReBootstrap(ctrld.LoggerCtx(ctx, mainLog.Load()))
 				}
 			}
 		}

cmd/cli/prog.go

@@ -286,7 +286,7 @@ func (p *prog) postRun() {
 			mainLog.Load().Debug().Msgf("running on domain controller: %t, role: %d", p.runningOnDomainController, roleInt)
 		}
 		p.resetDNS(false, false)
-		ns := ctrld.InitializeOsResolver(false)
+		ns := ctrld.InitializeOsResolver(ctrld.LoggerCtx(context.Background(), mainLog.Load()), false)
 		mainLog.Load().Debug().Msgf("initialized OS resolver with nameservers: %v", ns)
 		p.setDNS()
 		p.csSetDnsDone <- struct{}{}
@@ -319,7 +319,8 @@ func (p *prog) apiConfigReload() {
 	}
 
 	doReloadApiConfig := func(forced bool, logger zerolog.Logger) {
-		resolverConfig, err := controld.FetchResolverConfig(cdUID, rootCmd.Version, cdDev)
+		loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
+		resolverConfig, err := controld.FetchResolverConfig(loggerCtx, cdUID, rootCmd.Version, cdDev)
 		selfUninstallCheck(err, p, logger)
 		if err != nil {
 			logger.Warn().Err(err).Msg("could not fetch resolver config")
@@ -377,7 +378,7 @@ func (p *prog) apiConfigReload() {
 			}
 			if cfgErr != nil {
 				logger.Warn().Err(err).Msg("skipping invalid custom config")
-				if _, err := controld.UpdateCustomLastFailed(cdUID, rootCmd.Version, cdDev, true); err != nil {
+				if _, err := controld.UpdateCustomLastFailed(loggerCtx, cdUID, rootCmd.Version, cdDev, true); err != nil {
 					logger.Error().Err(err).Msg("could not mark custom last update failed")
 				}
 				return
@@ -404,22 +405,23 @@ func (p *prog) setupUpstream(cfg *ctrld.Config) {
 	localUpstreams := make([]string, 0, len(cfg.Upstream))
 	ptrNameservers := make([]string, 0, len(cfg.Upstream))
 	isControlDUpstream := false
+	loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
 	for n := range cfg.Upstream {
 		uc := cfg.Upstream[n]
 		sdns := uc.Type == ctrld.ResolverTypeSDNS
-		uc.Init()
+		uc.Init(loggerCtx)
 		if sdns {
 			mainLog.Load().Debug().Msgf("initialized DNS Stamps with endpoint: %s, type: %s", uc.Endpoint, uc.Type)
 		}
 		isControlDUpstream = isControlDUpstream || uc.IsControlD()
 		if uc.BootstrapIP == "" {
-			uc.SetupBootstrapIP()
+			uc.SetupBootstrapIP(ctrld.LoggerCtx(context.Background(), mainLog.Load()))
 			mainLog.Load().Info().Msgf("bootstrap IPs for upstream.%s: %q", n, uc.BootstrapIPs())
 		} else {
 			mainLog.Load().Info().Str("bootstrap_ip", uc.BootstrapIP).Msgf("using bootstrap IP for upstream.%s", n)
 		}
 		uc.SetCertPool(rootCertPool)
-		go uc.Ping()
+		go uc.Ping(loggerCtx)
 
 		if canBeLocalUpstream(uc.Domain) {
 			localUpstreams = append(localUpstreams, upstreamPrefix+n)
@@ -601,7 +603,7 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
 
 // setupClientInfoDiscover performs necessary works for running client info discover.
 func (p *prog) setupClientInfoDiscover(selfIP string) {
-	p.ciTable = clientinfo.NewTable(&cfg, selfIP, cdUID, p.ptrNameservers)
+	p.ciTable = clientinfo.NewTable(&cfg, selfIP, cdUID, p.ptrNameservers, mainLog.Load())
 	if leaseFile := p.cfg.Service.DHCPLeaseFile; leaseFile != "" {
 		mainLog.Load().Debug().Msgf("watching custom lease file: %s", leaseFile)
 		format := ctrld.LeaseFileFormat(p.cfg.Service.DHCPLeaseFileFormat)