feat: pass log level to shadow pod

xyz-li · Feb 1, 2022 · 3564fc0 · 3564fc0
1 parent 631ebe3
commit 3564fc0
Show file tree

Hide file tree

Showing 5 changed files with 35 additions and 12 deletions.
diff --git a/cmd/shadow/main.go b/cmd/shadow/main.go
@@ -1,14 +1,16 @@
 package main
 
 import (
+	"github.com/alibaba/kt-connect/pkg/common"
 	"github.com/alibaba/kt-connect/pkg/proxy/dnsserver"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"os"
 )
 
 func init() {
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	level, _ := zerolog.ParseLevel(os.Getenv(common.EnvVarLogLevel))
+	zerolog.SetGlobalLevel(level)
 	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
 }
 

diff --git a/pkg/common/const.go b/pkg/common/const.go
@@ -24,6 +24,8 @@ const (
 	EnvVarLocalDomains = "LOCAL_DOMAIN"
 	// EnvVarDnsProtocol environment variable for shadow pod dns protocol
 	EnvVarDnsProtocol = "DNS_PROTOCOL"
+	// EnvVarLogLevel environment variable for shadow pod log level
+	EnvVarLogLevel = "LOG_LEVEL"
 	// ControlBy label used for mark shadow pod
 	ControlBy = "control-by"
 	// KtName label used for wait shadow pod ready

diff --git a/pkg/kt/command/connect/common.go b/pkg/kt/command/connect/common.go
@@ -76,33 +76,38 @@ func getServiceHosts(k cluster.KubernetesInterface, namespace string) map[string
 	return hosts
 }
 
-func getOrCreateShadow(kubernetes cluster.KubernetesInterface, options *options.DaemonOptions) (string, string, *util.SSHCredential, error) {
+func getOrCreateShadow(kubernetes cluster.KubernetesInterface, opt *options.DaemonOptions) (string, string, *util.SSHCredential, error) {
 	shadowPodName := fmt.Sprintf("kt-connect-shadow-%s", strings.ToLower(util.RandomString(5)))
-	if options.ConnectOptions.SharedShadow {
+	if opt.ConnectOptions.SharedShadow {
 		shadowPodName = fmt.Sprintf("kt-connect-shadow-daemon")
 	}
 
 	endPointIP, podName, credential, err := cluster.GetOrCreateShadow(context.TODO(), kubernetes,
-		shadowPodName, options, getLabels(shadowPodName), make(map[string]string), getEnvs(options.ConnectOptions))
+		shadowPodName, opt, getLabels(shadowPodName), make(map[string]string), getEnvs(opt))
 	if err != nil {
 		return "", "", nil, err
 	}
 
 	return endPointIP, podName, credential, nil
 }
 
-func getEnvs(opt *options.ConnectOptions) map[string]string {
+func getEnvs(opt *options.DaemonOptions) map[string]string {
 	envs := make(map[string]string)
 	localDomains := dns.GetLocalDomains()
 	if localDomains != "" {
 		log.Debug().Msgf("Found local domains: %s", localDomains)
 		envs[common.EnvVarLocalDomains] = localDomains
 	}
-	if opt.DnsMode == common.DnsModeLocalDns {
+	if opt.ConnectOptions.DnsMode == common.DnsModeLocalDns {
 		envs[common.EnvVarDnsProtocol] = "tcp"
 	} else {
 		envs[common.EnvVarDnsProtocol] = "udp"
 	}
+	if opt.Debug {
+		envs[common.EnvVarLogLevel] = "debug"
+	} else {
+		envs[common.EnvVarLogLevel] = "info"
+	}
 	return envs
 }
 

diff --git a/pkg/kt/dns/dnsserver.go b/pkg/kt/dns/dnsserver.go
@@ -33,18 +33,25 @@ func (s *DnsServer) ServeDNS(w dns.ResponseWriter, req *dns.Msg) {
 	msg := (&dns.Msg{}).SetReply(req)
 	msg.Authoritative = true
 	domain := req.Question[0].Name
-	log.Debug().Msgf("Looking up domain %s", domain)
 	res, err := common.NsLookup(domain, req.Question[0].Qtype, "tcp", s.clusterDnsAddr)
-	if err != nil {
+	if err != nil && !common.IsDomainNotExist(err) {
 		log.Warn().Err(err).Msgf("Failed to lookup %s in cluster dns (%s)", domain, s.clusterDnsAddr)
-	} else if len(res.Answer) > 0 {
+	} else if res != nil && len(res.Answer) > 0 {
+		log.Debug().Msgf("Found domain %s in cluster dns (%s)", domain, s.clusterDnsAddr)
 		msg.Answer = res.Answer
 	} else {
 		res, err = common.NsLookup(domain, req.Question[0].Qtype, "udp", s.upstreamDnsAddr)
 		if err != nil {
-			log.Warn().Err(err).Msgf("Failed to lookup %s in upstream dns (%s)", domain, s.upstreamDnsAddr)
+			if common.IsDomainNotExist(err) {
+				log.Debug().Msgf(err.Error())
+			} else {
+				log.Warn().Err(err).Msgf("Failed to lookup %s in upstream dns (%s)", domain, s.upstreamDnsAddr)
+			}
 		} else if len(res.Answer) > 0 {
+			log.Debug().Msgf("Found domain %s in upstream dns (%s)", domain, s.upstreamDnsAddr)
 			msg.Answer = res.Answer
+		} else {
+			log.Debug().Msgf("Empty answer for domain lookup %s", domain)
 		}
 	}
 	if err = w.WriteMsg(msg); err != nil {

diff --git a/pkg/proxy/dnsserver/dnsserver.go b/pkg/proxy/dnsserver/dnsserver.go
@@ -164,12 +164,19 @@ func (s *DnsServer) lookup(domain string, qtype uint16, name string) (rr []dns.R
 
 	res, err := common.NsLookup(domain, qtype, "udp", address)
 	if err != nil {
-		log.Error().Err(err).Msgf("Failed to answer name %s after %d query for %s", name, qtype, domain)
+		if common.IsDomainNotExist(err) {
+			log.Debug().Msgf(err.Error())
+		} else {
+			log.Warn().Err(err).Msgf("Failed to answer name %s (type %d) query for %s", name, qtype, domain)
+		}
 		return
 	}
 
+	if len(res.Answer) == 0 {
+		log.Debug().Msgf("Empty answer")
+	}
 	for _, item := range res.Answer {
-		log.Info().Msgf("Response: %s", item.String())
+		log.Debug().Msgf("Response: %s", item.String())
 		r, errInLoop := s.convertAnswer(name, domain, item)
 		if errInLoop != nil {
 			err = errInLoop