refactor: divide log to session and backend (#487)

* refactor: divide log to session and backend

cmd/kubevpn/cmds/alias_test.go

@@ -1,9 +1,11 @@
 package cmds
 
 import (
-	"log"
+	"context"
 	"reflect"
 	"testing"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func TestAlias(t *testing.T) {
@@ -22,7 +24,7 @@ Flags:
   - --extra-hosts=xxx.com`
 	_, err := ParseConfig([]byte(str))
 	if err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 }
 
@@ -42,7 +44,7 @@ Flags:
   - --extra-hosts=xxx.com`
 	_, err := ParseConfig([]byte(str))
 	if err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 }
 
@@ -206,11 +208,11 @@ Flags:
 	for _, datum := range data {
 		configs, err := ParseConfig([]byte(datum.Config))
 		if err != nil {
-			log.Fatal(err)
+			plog.G(context.Background()).Fatal(err)
 		}
 		getConfigs, err := GetConfigs(configs, datum.Run)
 		if err != nil && !datum.ExpectError {
-			log.Fatal(err)
+			plog.G(context.Background()).Fatal(err)
 		} else if err != nil {
 		}
 		if datum.ExpectError {
@@ -221,7 +223,7 @@ Flags:
 			c = append(c, config.Name)
 		}
 		if !reflect.DeepEqual(c, datum.ExpectOrder) {
-			log.Fatalf("Not match, expect: %v, real: %v", datum.ExpectOrder, c)
+			plog.G(context.Background()).Fatalf("Not match, expect: %v, real: %v", datum.ExpectOrder, c)
 		}
 	}
 }

cmd/kubevpn/cmds/clone.go

@@ -19,6 +19,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util/regctl"
@@ -76,7 +77,7 @@ func CmdClone(f cmdutil.Factory) *cobra.Command {
         kubevpn clone service/productpage --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) (err error) {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			// startup daemon process and sudo process
 			err = daemon.StartupDaemon(cmd.Context())
 			if err != nil {
@@ -120,10 +121,6 @@ func CmdClone(f cmdutil.Factory) *cobra.Command {
 					extraRoute.ExtraCIDR = append(extraRoute.ExtraCIDR, ip.String())
 				}
 			}
-			logLevel := log.InfoLevel
-			if config.Debug {
-				logLevel = log.DebugLevel
-			}
 			req := &rpc.CloneRequest{
 				KubeconfigBytes:        string(bytes),
 				Namespace:              ns,
@@ -142,7 +139,7 @@ func CmdClone(f cmdutil.Factory) *cobra.Command {
 				TransferImage:          transferImage,
 				Image:                  config.Image,
 				ImagePullSecretName:    imagePullSecretName,
-				Level:                  int32(logLevel),
+				Level:                  int32(util.If(config.Debug, log.DebugLevel, log.InfoLevel)),
 				LocalDir:               options.LocalDir,
 				RemoteDir:              options.RemoteDir,
 			}

cmd/kubevpn/cmds/connect.go

@@ -19,6 +19,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util/regctl"
@@ -64,7 +65,7 @@ func CmdConnect(f cmdutil.Factory) *cobra.Command {
 		kubevpn connect --ssh-jump "--ssh-addr jump.naison.org --ssh-username naison --gssapi-password xxx" --ssh-username root --ssh-addr 127.0.0.1:22 --ssh-keyfile ~/.ssh/dst.pem
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			// startup daemon process and sudo process
 			err := daemon.StartupDaemon(cmd.Context())
 			if err != nil {
@@ -85,10 +86,6 @@ func CmdConnect(f cmdutil.Factory) *cobra.Command {
 					extraRoute.ExtraCIDR = append(extraRoute.ExtraCIDR, ip.String())
 				}
 			}
-			logLevel := log.InfoLevel
-			if config.Debug {
-				logLevel = log.DebugLevel
-			}
 			req := &rpc.ConnectRequest{
 				KubeconfigBytes:      string(bytes),
 				Namespace:            ns,
@@ -100,7 +97,7 @@ func CmdConnect(f cmdutil.Factory) *cobra.Command {
 				TransferImage:       transferImage,
 				Image:               config.Image,
 				ImagePullSecretName: imagePullSecretName,
-				Level:               int32(logLevel),
+				Level:               int32(util.If(config.Debug, log.DebugLevel, log.InfoLevel)),
 			}
 			// if is foreground, send to sudo daemon server
 			cli := daemon.GetClient(false)
@@ -150,7 +147,7 @@ func disconnect(cli rpc.DaemonClient, bytes []byte, ns string, sshConf *pkgssh.S
 		SshJump:         sshConf.ToRPC(),
 	})
 	if err != nil {
-		log.Errorf("Disconnect error: %v", err)
+		plog.G(context.Background()).Errorf("Disconnect error: %v", err)
 		return err
 	}
 	err = util.PrintGRPCStream[rpc.DisconnectResponse](resp)

cmd/kubevpn/cmds/controlplane.go

@@ -1,9 +1,10 @@
 package cmds
 
 import (
+	"context"
+
 	"github.com/docker/docker/libnetwork/resolvconf"
 	miekgdns "github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"k8s.io/kubectl/pkg/util/i18n"
@@ -12,6 +13,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dns"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -28,16 +30,15 @@ func CmdControlPlane(_ cmdutil.Factory) *cobra.Command {
 		Control-plane is a envoy xds server, distribute envoy route configuration
 		`)),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForServer(config.Debug)
 			go util.StartupPProfForServer(0)
 			go func() {
 				conf, err := miekgdns.ClientConfigFromFile(resolvconf.Path())
 				if err != nil {
-					log.Fatal(err)
+					plog.G(context.Background()).Fatal(err)
 				}
-				log.Fatal(dns.ListenAndServe("udp", ":53", conf))
+				plog.G(context.Background()).Fatal(dns.ListenAndServe("udp", ":53", conf))
 			}()
-			err := controlplane.Main(cmd.Context(), watchDirectoryFilename, port, log.StandardLogger())
+			err := controlplane.Main(cmd.Context(), watchDirectoryFilename, port, plog.G(context.Background()))
 			return err
 		},
 	}

cmd/kubevpn/cmds/dev.go

@@ -1,11 +1,11 @@
 package cmds
 
 import (
+	"context"
 	"fmt"
 	"os"
 
 	"github.com/docker/cli/cli/command"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"k8s.io/kubectl/pkg/util/completion"
@@ -16,8 +16,8 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dev"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util/regctl"
 )
 
@@ -89,7 +89,7 @@ func CmdDev(f cmdutil.Factory) *cobra.Command {
 			if err != nil {
 				return err
 			}
-			util.InitLoggerForClient(config.Debug)
+			plog.InitLoggerForClient()
 			err = daemon.StartupDaemon(cmd.Context())
 			if err != nil {
 				return err
@@ -115,7 +115,7 @@ func CmdDev(f cmdutil.Factory) *cobra.Command {
 				for _, function := range options.GetRollbackFuncList() {
 					if function != nil {
 						if err := function(); err != nil {
-							log.Errorf("Rollback failed, error: %s", err.Error())
+							plog.G(context.Background()).Errorf("Rollback failed, error: %s", err.Error())
 						}
 					}
 				}

cmd/kubevpn/cmds/disconnect.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -37,7 +38,7 @@ func CmdDisconnect(f cmdutil.Factory) *cobra.Command {
         kubevpn disconnect
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) (err error) {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			err = daemon.StartupDaemon(cmd.Context())
 			return err
 		},

cmd/kubevpn/cmds/imagecopy.go

@@ -4,7 +4,7 @@ import (
 	"github.com/spf13/cobra"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util/regctl"
 )
 
@@ -30,7 +30,7 @@ kubevpn image copy ghcr.io/kubenetworks/kubevpn:latest registry.example.org/kube
 kubevpn image copy ghcr.io/kubenetworks/kubevpn:latest ghcr.io/kubenetworks/kubevpn:v2.3.4`,
 		Args: cobra.MatchAll(cobra.ExactArgs(2), cobra.OnlyValidArgs),
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {

cmd/kubevpn/cmds/logs.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -28,7 +29,7 @@ func CmdLogs(f cmdutil.Factory) *cobra.Command {
         kubevpn logs -f
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) (err error) {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			// startup daemon process and sudo process
 			return daemon.StartupDaemon(cmd.Context())
 		},

cmd/kubevpn/cmds/proxy.go

@@ -18,6 +18,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util/regctl"
@@ -88,7 +89,7 @@ func CmdProxy(f cmdutil.Factory) *cobra.Command {
 		kubevpn proxy deployment/productpage
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) (err error) {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			if err = daemon.StartupDaemon(cmd.Context()); err != nil {
 				return err
 			}
@@ -119,10 +120,6 @@ func CmdProxy(f cmdutil.Factory) *cobra.Command {
 			}
 			// todo 将 doConnect 方法封装？内部使用 client 发送到daemon？
 			cli := daemon.GetClient(false)
-			logLevel := log.InfoLevel
-			if config.Debug {
-				logLevel = log.DebugLevel
-			}
 			client, err := cli.Proxy(
 				cmd.Context(),
 				&rpc.ConnectRequest{
@@ -137,7 +134,7 @@ func CmdProxy(f cmdutil.Factory) *cobra.Command {
 					TransferImage:        transferImage,
 					Image:                config.Image,
 					ImagePullSecretName:  imagePullSecretName,
-					Level:                int32(logLevel),
+					Level:                int32(util.If(config.Debug, log.DebugLevel, log.InfoLevel)),
 					OriginKubeconfigPath: util.GetKubeConfigPath(f),
 				},
 			)

cmd/kubevpn/cmds/reset.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -46,7 +47,7 @@ func CmdReset(f cmdutil.Factory) *cobra.Command {
         kubevpn reset deployment/productpage --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			return daemon.StartupDaemon(cmd.Context())
 		},
 		Args: cobra.MatchAll(cobra.ExactArgs(1)),

cmd/kubevpn/cmds/serve.go

@@ -6,7 +6,6 @@ import (
 	"runtime"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"go.uber.org/automaxprocs/maxprocs"
 	glog "gvisor.dev/gvisor/pkg/log"
@@ -17,6 +16,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/core"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -34,10 +34,9 @@ func CmdServe(_ cmdutil.Factory) *cobra.Command {
         kubevpn serve -L "tcp://:10800" -L "tun://127.0.0.1:8422?net=198.19.0.123/32"
 		`)),
 		PreRun: func(*cobra.Command, []string) {
-			util.InitLoggerForServer(config.Debug)
 			runtime.GOMAXPROCS(0)
 			go util.StartupPProfForServer(config.PProfPort)
-			glog.SetTarget(util.ServerEmitter{Writer: &glog.Writer{Next: os.Stderr}})
+			glog.SetTarget(plog.ServerEmitter{Writer: &glog.Writer{Next: os.Stderr}})
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			rand.Seed(time.Now().UnixNano())
@@ -49,7 +48,7 @@ func CmdServe(_ cmdutil.Factory) *cobra.Command {
 			}
 			servers, err := handler.Parse(*route)
 			if err != nil {
-				log.Errorf("Parse server failed: %v", err)
+				plog.G(ctx).Errorf("Parse server failed: %v", err)
 				return err
 			}
 			return handler.Run(ctx, servers)

cmd/kubevpn/cmds/ssh.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/containerd/containerd/platforms"
 	"github.com/google/uuid"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"golang.org/x/crypto/ssh/terminal"
 	"golang.org/x/net/websocket"
@@ -21,6 +20,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -54,7 +54,7 @@ func CmdSSH(_ cmdutil.Factory) *cobra.Command {
         kubevpn ssh --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			return daemon.StartupDaemon(cmd.Context())
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -120,7 +120,7 @@ func CmdSSH(_ cmdutil.Factory) *cobra.Command {
 				case <-readyCtx.Done():
 				}
 				if state, err = terminal.MakeRaw(fd); err != nil {
-					log.Errorf("terminal make raw: %s", err)
+					plog.G(context.Background()).Errorf("terminal make raw: %s", err)
 				}
 			}()
 
@@ -187,7 +187,7 @@ func monitorSize(ctx context.Context, sessionID string) error {
 			return nil
 		}
 		if err = encoder.Encode(&size); err != nil {
-			log.Errorf("Encode resize: %s", err)
+			plog.G(ctx).Errorf("Encode resize: %s", err)
 			return err
 		}
 	}

cmd/kubevpn/cmds/status.go

@@ -21,6 +21,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -60,7 +61,7 @@ func CmdStatus(f cmdutil.Factory) *cobra.Command {
 		kubevpn status -o yaml
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) (err error) {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			return daemon.StartupDaemon(cmd.Context())
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {

cmd/kubevpn/cmds/uninstall.go

@@ -1,7 +1,6 @@
 package cmds
 
 import (
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -12,6 +11,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -50,7 +50,7 @@ func CmdUninstall(f cmdutil.Factory) *cobra.Command {
         kubevpn uninstall --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
 		`)),
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			return daemon.StartupDaemon(cmd.Context())
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -65,7 +65,7 @@ func CmdUninstall(f cmdutil.Factory) *cobra.Command {
 				SshJump:         sshConf.ToRPC(),
 			})
 			if err != nil {
-				log.Warnf("Failed to disconnect from cluter: %v", err)
+				plog.G(cmd.Context()).Warnf("Failed to disconnect from cluter: %v", err)
 			} else {
 				_ = util.PrintGRPCStream[rpc.DisconnectResponse](disconnect)
 			}

cmd/kubevpn/cmds/upgrade.go

@@ -12,8 +12,8 @@ import (
 	"k8s.io/kubectl/pkg/util/templates"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/upgrade"
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func CmdUpgrade(_ cmdutil.Factory) *cobra.Command {
@@ -29,7 +29,7 @@ func CmdUpgrade(_ cmdutil.Factory) *cobra.Command {
 			const (
 				envLatestUrl = "KUBEVPN_LATEST_VERSION_URL"
 			)
-			util.InitLoggerForClient(false)
+			plog.InitLoggerForClient()
 			var client = http.DefaultClient
 			if config.GitHubOAuthToken != "" {
 				client = oauth2.NewClient(cmd.Context(), oauth2.StaticTokenSource(&oauth2.Token{AccessToken: config.GitHubOAuthToken, TokenType: "Bearer"}))

cmd/kubevpn/cmds/webhook.go

@@ -22,7 +22,6 @@ func CmdWebhook(f cmdutil.Factory) *cobra.Command {
 		`)),
 		Args: cobra.MaximumNArgs(0),
 		PreRun: func(cmd *cobra.Command, args []string) {
-			util.InitLoggerForServer(true)
 			go util.StartupPProfForServer(0)
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {

pkg/controlplane/cache.go

@@ -26,7 +26,7 @@ import (
 	"github.com/envoyproxy/go-control-plane/pkg/cache/types"
 	"github.com/envoyproxy/go-control-plane/pkg/resource/v3"
 	"github.com/envoyproxy/go-control-plane/pkg/wellknown"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 	"google.golang.org/protobuf/types/known/durationpb"
@@ -90,7 +90,7 @@ type Rule struct {
 	PortMap map[int32]string
 }
 
-func (a *Virtual) To(enableIPv6 bool) (
+func (a *Virtual) To(enableIPv6 bool, logger *log.Logger) (
 	listeners []types.Resource,
 	clusters []types.Resource,
 	routes []types.Resource,
@@ -117,7 +117,7 @@ func (a *Virtual) To(enableIPv6 bool) (
 				if strings.Index(ports, ":") > 0 {
 					ports = strings.Split(ports, ":")[0]
 				} else {
-					logrus.Errorf("fargate mode port should have two pair")
+					logger.Errorf("fargate mode port should have two pair: %s", ports)
 				}
 			}
 			envoyRulePort, _ := strconv.Atoi(ports)

pkg/controlplane/main.go

@@ -8,6 +8,8 @@ import (
 	serverv3 "github.com/envoyproxy/go-control-plane/pkg/server/v3"
 	"github.com/fsnotify/fsnotify"
 	log "github.com/sirupsen/logrus"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func Main(ctx context.Context, filename string, port uint, logger *log.Logger) error {
@@ -46,7 +48,7 @@ func Main(ctx context.Context, filename string, port uint, logger *log.Logger) e
 		case msg := <-notifyCh:
 			err = proc.ProcessFile(msg)
 			if err != nil {
-				log.Errorf("Failed to process file: %v", err)
+				plog.G(ctx).Errorf("Failed to process file: %v", err)
 				return err
 			}
 		case err = <-errChan:

pkg/controlplane/processor.go

@@ -65,7 +65,7 @@ func (p *Processor) ProcessFile(file NotifyMessage) error {
 		}
 		p.logger.Debugf("update config, version %d, config %v", p.version, config)
 
-		listeners, clusters, routes, endpoints := config.To(enableIPv6)
+		listeners, clusters, routes, endpoints := config.To(enableIPv6, p.logger)
 		resources := map[resource.Type][]types.Resource{
 			resource.ListenerType: listeners, // listeners
 			resource.RouteType:    routes,    // routes

pkg/controlplane/server.go

@@ -13,8 +13,9 @@ import (
 	runtimeservice "github.com/envoyproxy/go-control-plane/envoy/service/runtime/v3"
 	secretservice "github.com/envoyproxy/go-control-plane/envoy/service/secret/v3"
 	serverv3 "github.com/envoyproxy/go-control-plane/pkg/server/v3"
-	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 const (
@@ -38,6 +39,6 @@ func RunServer(ctx context.Context, server serverv3.Server, port uint) error {
 	secretservice.RegisterSecretDiscoveryServiceServer(grpcServer, server)
 	runtimeservice.RegisterRuntimeDiscoveryServiceServer(grpcServer, server)
 
-	log.Infof("Management server listening on %d", port)
+	plog.G(ctx).Infof("Management server listening on %d", port)
 	return grpcServer.Serve(listener)
 }

pkg/core/gvisoricmpforwarder.go

@@ -3,22 +3,22 @@ package core
 import (
 	"context"
 
-	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func ICMPForwarder(s *stack.Stack, ctx context.Context) func(stack.TransportEndpointID, *stack.PacketBuffer) bool {
 	return func(id stack.TransportEndpointID, buffer *stack.PacketBuffer) bool {
-		log.Debugf("[TUN-ICMP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
+		plog.G(ctx).Debugf("[TUN-ICMP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
 			id.LocalPort, id.LocalAddress.String(), id.RemotePort, id.RemoteAddress.String(),
 		)
 		ctx1, cancelFunc := context.WithCancel(ctx)
 		defer cancelFunc()
 		ok, err := util.PingOnce(ctx1, id.RemoteAddress.String(), id.LocalAddress.String())
 		if err != nil {
-			log.Debugf("[TUN-ICMP] Failed to ping dst %s from src %s",
+			plog.G(ctx).Debugf("[TUN-ICMP] Failed to ping dst %s from src %s",
 				id.LocalAddress.String(), id.RemoteAddress.String(),
 			)
 		}

pkg/core/gvisorstack.go

@@ -3,7 +3,6 @@ package core
 import (
 	"context"
 
-	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/packetsocket"
@@ -13,6 +12,8 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/transport/raw"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
@@ -61,7 +62,7 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.TCPSACKEnabled(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
-			log.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
+			plog.G(ctx).Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
 		}
 	}
 
@@ -69,10 +70,10 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.DefaultTTLOption(64)
 		if err := s.SetNetworkProtocolOption(ipv4.ProtocolNumber, &opt); err != nil {
-			log.Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv4.ProtocolNumber, opt, opt, err)
+			plog.G(ctx).Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv4.ProtocolNumber, opt, opt, err)
 		}
 		if err := s.SetNetworkProtocolOption(ipv6.ProtocolNumber, &opt); err != nil {
-			log.Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv6.ProtocolNumber, opt, opt, err)
+			plog.G(ctx).Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv6.ProtocolNumber, opt, opt, err)
 		}
 	}
 
@@ -80,23 +81,23 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.TCPModerateReceiveBufferOption(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
-			log.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
+			plog.G(ctx).Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
 		}
 	}
 
 	{
 		if err := s.SetForwardingDefaultAndAllNICs(ipv4.ProtocolNumber, true); err != nil {
-			log.Fatalf("Set IPv4 forwarding: %v", err)
+			plog.G(ctx).Fatalf("Set IPv4 forwarding: %v", err)
 		}
 		if err := s.SetForwardingDefaultAndAllNICs(ipv6.ProtocolNumber, true); err != nil {
-			log.Fatalf("Set IPv6 forwarding: %v", err)
+			plog.G(ctx).Fatalf("Set IPv6 forwarding: %v", err)
 		}
 	}
 
 	{
 		option := tcpip.TCPModerateReceiveBufferOption(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &option); err != nil {
-			log.Fatalf("Set TCP moderate receive buffer: %v", err)
+			plog.G(ctx).Fatalf("Set TCP moderate receive buffer: %v", err)
 		}
 	}
 	return s

pkg/core/gvisortcpforwarder.go

@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/adapters/gonet"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
@@ -18,13 +17,14 @@ import (
 	"gvisor.dev/gvisor/pkg/waiter"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func TCPForwarder(s *stack.Stack, ctx context.Context) func(stack.TransportEndpointID, *stack.PacketBuffer) bool {
 	return tcp.NewForwarder(s, 0, 100000, func(request *tcp.ForwarderRequest) {
 		defer request.Complete(false)
 		id := request.ID()
-		log.Debugf("[TUN-TCP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
+		plog.G(ctx).Debugf("[TUN-TCP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
 			id.LocalPort, id.LocalAddress.String(), id.RemotePort, id.RemoteAddress.String(),
 		)
 
@@ -35,14 +35,14 @@ func TCPForwarder(s *stack.Stack, ctx context.Context) func(stack.TransportEndpo
 		var d = net.Dialer{Timeout: time.Second * 5}
 		remote, err := d.DialContext(ctx, "tcp", net.JoinHostPort(host, port))
 		if err != nil {
-			log.Errorf("[TUN-TCP] Failed to connect addr %s: %v", net.JoinHostPort(host, port), err)
+			plog.G(ctx).Errorf("[TUN-TCP] Failed to connect addr %s: %v", net.JoinHostPort(host, port), err)
 			return
 		}
 
 		w := &waiter.Queue{}
 		endpoint, tErr := request.CreateEndpoint(w)
 		if tErr != nil {
-			log.Debugf("[TUN-TCP] Failed to create endpoint: %v", tErr)
+			plog.G(ctx).Debugf("[TUN-TCP] Failed to create endpoint: %v", tErr)
 			return
 		}
 		conn := gonet.NewTCPConn(w, endpoint)
@@ -54,19 +54,19 @@ func TCPForwarder(s *stack.Stack, ctx context.Context) func(stack.TransportEndpo
 			buf := config.LPool.Get().([]byte)[:]
 			defer config.LPool.Put(buf[:])
 			written, err2 := io.CopyBuffer(remote, conn, buf)
-			log.Debugf("[TUN-TCP] Write length %d data to remote", written)
+			plog.G(ctx).Debugf("[TUN-TCP] Write length %d data to remote", written)
 			errChan <- err2
 		}()
 		go func() {
 			buf := config.LPool.Get().([]byte)[:]
 			defer config.LPool.Put(buf[:])
 			written, err2 := io.CopyBuffer(conn, remote, buf)
-			log.Debugf("[TUN-TCP] Read length %d data from remote", written)
+			plog.G(ctx).Debugf("[TUN-TCP] Read length %d data from remote", written)
 			errChan <- err2
 		}()
 		err = <-errChan
 		if err != nil && !errors.Is(err, io.EOF) {
-			log.Debugf("[TUN-TCP] Disconnect: %s >-<: %s: %v", conn.LocalAddr(), remote.RemoteAddr(), err)
+			plog.G(ctx).Debugf("[TUN-TCP] Disconnect: %s >-<: %s: %v", conn.LocalAddr(), remote.RemoteAddr(), err)
 		}
 	}).HandlePacket
 }

pkg/core/gvisortcphandler.go

@@ -5,13 +5,13 @@ import (
 	"net"
 	"sync"
 
-	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/sniffer"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -32,7 +32,7 @@ func (h *gvisorTCPHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 	defer tcpConn.Close()
 	cancel, cancelFunc := context.WithCancel(ctx)
 	defer cancelFunc()
-	log.Debugf("[TCP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
+	plog.G(ctx).Debugf("[TCP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
 	h.handle(cancel, tcpConn)
 }
 
@@ -60,7 +60,7 @@ func (h *gvisorTCPHandler) handle(ctx context.Context, tcpConn net.Conn) {
 }
 
 func GvisorTCPListener(addr string) (net.Listener, error) {
-	log.Debugf("Gvisor TCP listening addr: %s", addr)
+	plog.G(context.Background()).Debugf("Gvisor TCP listening addr: %s", addr)
 	laddr, err := net.ResolveTCPAddr("tcp", addr)
 	if err != nil {
 		return nil, err

pkg/core/gvisortunendpoint.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	"github.com/google/gopacket/layers"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/net/ipv4"
 	"golang.org/x/net/ipv6"
 	"gvisor.dev/gvisor/pkg/buffer"
@@ -16,6 +15,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -34,7 +34,7 @@ func (h *gvisorTCPHandler) readFromEndpointWriteToTCPConn(ctx context.Context, c
 			buf := pktBuffer.ToView().AsSlice()
 			_, err := tcpConn.Write(buf)
 			if err != nil {
-				log.Errorf("[TUN] Failed to write data to tun device: %v", err)
+				plog.G(ctx).Errorf("[TUN] Failed to write data to tun device: %v", err)
 			}
 		}
 	}
@@ -53,12 +53,12 @@ func (h *gvisorTCPHandler) readFromTCPConnWriteToEndpoint(ctx context.Context, c
 		buf := config.LPool.Get().([]byte)[:]
 		read, err := tcpConn.Read(buf[:])
 		if err != nil {
-			log.Errorf("[TUN] Failed to read from tcp conn: %v", err)
+			plog.G(ctx).Errorf("[TUN] Failed to read from tcp conn: %v", err)
 			config.LPool.Put(buf[:])
 			return
 		}
 		if read == 0 {
-			log.Warnf("[TUN] Read from tcp conn length is %d", read)
+			plog.G(ctx).Warnf("[TUN] Read from tcp conn length is %d", read)
 			config.LPool.Put(buf[:])
 			continue
 		}
@@ -72,7 +72,7 @@ func (h *gvisorTCPHandler) readFromTCPConnWriteToEndpoint(ctx context.Context, c
 			protocol = header.IPv4ProtocolNumber
 			ipHeader, err := ipv4.ParseHeader(buf[:read])
 			if err != nil {
-				log.Errorf("Failed to parse IPv4 header: %v", err)
+				plog.G(ctx).Errorf("Failed to parse IPv4 header: %v", err)
 				config.LPool.Put(buf[:])
 				continue
 			}
@@ -83,7 +83,7 @@ func (h *gvisorTCPHandler) readFromTCPConnWriteToEndpoint(ctx context.Context, c
 			protocol = header.IPv6ProtocolNumber
 			ipHeader, err := ipv6.ParseHeader(buf[:read])
 			if err != nil {
-				log.Errorf("Failed to parse IPv6 header: %s", err.Error())
+				plog.G(ctx).Errorf("Failed to parse IPv6 header: %s", err.Error())
 				config.LPool.Put(buf[:])
 				continue
 			}
@@ -91,15 +91,15 @@ func (h *gvisorTCPHandler) readFromTCPConnWriteToEndpoint(ctx context.Context, c
 			src = ipHeader.Src
 			dst = ipHeader.Dst
 		} else {
-			log.Debugf("[TUN-GVISOR] Unknown packet")
+			plog.G(ctx).Debugf("[TUN-GVISOR] Unknown packet")
 			config.LPool.Put(buf[:])
 			continue
 		}
 
-		h.addRoute(src, conn)
+		h.addRoute(ctx, src, conn)
 		// inner ip like 198.19.0.100/102/103 connect each other
 		if config.CIDR.Contains(dst) || config.CIDR6.Contains(dst) {
-			log.Tracef("[TUN-RAW] Forward to TUN device, SRC: %s, DST: %s, Length: %d", src.String(), dst.String(), read)
+			plog.G(ctx).Debugf("[TUN-RAW] Forward to TUN device, SRC: %s, DST: %s, Length: %d", src.String(), dst.String(), read)
 			util.SafeWrite(h.packetChan, &datagramPacket{
 				DataLength: uint16(read),
 				Data:       buf[:],
@@ -115,18 +115,18 @@ func (h *gvisorTCPHandler) readFromTCPConnWriteToEndpoint(ctx context.Context, c
 		sniffer.LogPacket("[gVISOR] ", sniffer.DirectionRecv, protocol, pkt)
 		endpoint.InjectInbound(protocol, pkt)
 		pkt.DecRef()
-		log.Tracef("[TUN-%s] Write to Gvisor IP-Protocol: %s, SRC: %s, DST: %s, Length: %d", layers.IPProtocol(ipProtocol).String(), layers.IPProtocol(ipProtocol).String(), src.String(), dst, read)
+		plog.G(ctx).Debugf("[TUN-%s] Write to Gvisor IP-Protocol: %s, SRC: %s, DST: %s, Length: %d", layers.IPProtocol(ipProtocol).String(), layers.IPProtocol(ipProtocol).String(), src.String(), dst, read)
 	}
 }
 
-func (h *gvisorTCPHandler) addRoute(src net.IP, tcpConn net.Conn) {
+func (h *gvisorTCPHandler) addRoute(ctx context.Context, src net.IP, tcpConn net.Conn) {
 	value, loaded := h.routeMapTCP.LoadOrStore(src.String(), tcpConn)
 	if loaded {
 		if tcpConn != value.(net.Conn) {
 			h.routeMapTCP.Store(src.String(), tcpConn)
-			log.Debugf("[TCP] Replace route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
+			plog.G(ctx).Debugf("[TCP] Replace route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
 		}
 	} else {
-		log.Debugf("[TCP] Add new route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
+		plog.G(ctx).Debugf("[TCP] Add new route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
 	}
 }

pkg/core/gvisorudpforwarder.go

@@ -7,20 +7,20 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip/adapters/gonet"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func UDPForwarder(s *stack.Stack, ctx context.Context) func(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool {
 	return udp.NewForwarder(s, func(request *udp.ForwarderRequest) {
 		id := request.ID()
-		log.Debugf("[TUN-UDP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
+		plog.G(ctx).Debugf("[TUN-UDP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
 			id.LocalPort, id.LocalAddress.String(), id.RemotePort, id.RemoteAddress.String(),
 		)
 		src := &net.UDPAddr{
@@ -35,14 +35,14 @@ func UDPForwarder(s *stack.Stack, ctx context.Context) func(id stack.TransportEn
 		w := &waiter.Queue{}
 		endpoint, tErr := request.CreateEndpoint(w)
 		if tErr != nil {
-			log.Debugf("[TUN-UDP] Failed to create endpoint to dst: %s: %v", dst.String(), tErr)
+			plog.G(ctx).Debugf("[TUN-UDP] Failed to create endpoint to dst: %s: %v", dst.String(), tErr)
 			return
 		}
 
 		// dial dst
 		remote, err1 := net.DialUDP("udp", nil, dst)
 		if err1 != nil {
-			log.Errorf("[TUN-UDP] Failed to connect dst: %s: %v", dst.String(), err1)
+			plog.G(ctx).Errorf("[TUN-UDP] Failed to connect dst: %s: %v", dst.String(), err1)
 			return
 		}
 
@@ -78,7 +78,7 @@ func UDPForwarder(s *stack.Stack, ctx context.Context) func(id stack.TransportEn
 						break
 					}
 				}
-				log.Debugf("[TUN-UDP] Write length %d data from src: %s -> dst: %s", written, src.String(), dst.String())
+				plog.G(ctx).Debugf("[TUN-UDP] Write length %d data from src: %s -> dst: %s", written, src.String(), dst.String())
 				errChan <- err
 			}()
 			go func() {
@@ -108,12 +108,12 @@ func UDPForwarder(s *stack.Stack, ctx context.Context) func(id stack.TransportEn
 						break
 					}
 				}
-				log.Debugf("[TUN-UDP] Read length %d data from dst: %s -> src: %s", written, dst.String(), src.String())
+				plog.G(ctx).Debugf("[TUN-UDP] Read length %d data from dst: %s -> src: %s", written, dst.String(), src.String())
 				errChan <- err
 			}()
 			err1 = <-errChan
 			if err1 != nil && !errors.Is(err1, io.EOF) {
-				log.Debugf("[TUN-UDP] Disconnect: %s >-<: %s: %v", conn.LocalAddr(), remote.RemoteAddr(), err1)
+				plog.G(ctx).Debugf("[TUN-UDP] Disconnect: %s >-<: %s: %v", conn.LocalAddr(), remote.RemoteAddr(), err1)
 			}
 		}()
 	}).HandlePacket

pkg/core/gvisorudphandler.go

@@ -6,8 +6,8 @@ import (
 	"net"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -19,14 +19,14 @@ func GvisorUDPHandler() Handler {
 
 func (h *gvisorUDPHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 	defer tcpConn.Close()
-	log.Debugf("[TUN-UDP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
+	plog.G(ctx).Debugf("[TUN-UDP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
 	// 1, get proxy info
 	endpointID, err := ParseProxyInfo(tcpConn)
 	if err != nil {
-		log.Errorf("[TUN-UDP] Failed to parse proxy info: %v", err)
+		plog.G(ctx).Errorf("[TUN-UDP] Failed to parse proxy info: %v", err)
 		return
 	}
-	log.Debugf("[TUN-UDP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
+	plog.G(ctx).Debugf("[TUN-UDP] LocalPort: %d, LocalAddress: %s, RemotePort: %d, RemoteAddress %s",
 		endpointID.LocalPort, endpointID.LocalAddress.String(), endpointID.RemotePort, endpointID.RemoteAddress.String(),
 	)
 	// 2, dial proxy
@@ -37,7 +37,7 @@ func (h *gvisorUDPHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 	var remote *net.UDPConn
 	remote, err = net.DialUDP("udp", nil, addr)
 	if err != nil {
-		log.Errorf("[TUN-UDP] Failed to connect addr %s: %v", addr.String(), err)
+		plog.G(ctx).Errorf("[TUN-UDP] Failed to connect addr %s: %v", addr.String(), err)
 		return
 	}
 	handle(ctx, tcpConn, remote)
@@ -86,7 +86,7 @@ func (c *gvisorFakeUDPTunnelConn) Close() error {
 }
 
 func GvisorUDPListener(addr string) (net.Listener, error) {
-	log.Debugf("Gvisor UDP over TCP listening addr: %s", addr)
+	plog.G(context.Background()).Debugf("Gvisor UDP over TCP listening addr: %s", addr)
 	laddr, err := net.ResolveTCPAddr("tcp", addr)
 	if err != nil {
 		return nil, err
@@ -100,7 +100,7 @@ func GvisorUDPListener(addr string) (net.Listener, error) {
 
 func handle(ctx context.Context, tcpConn net.Conn, udpConn *net.UDPConn) {
 	defer udpConn.Close()
-	log.Debugf("[TUN-UDP] %s <-> %s", tcpConn.RemoteAddr(), udpConn.LocalAddr())
+	plog.G(ctx).Debugf("[TUN-UDP] %s <-> %s", tcpConn.RemoteAddr(), udpConn.LocalAddr())
 	errChan := make(chan error, 2)
 	go func() {
 		defer util.HandleCrash()
@@ -116,34 +116,34 @@ func handle(ctx context.Context, tcpConn net.Conn, udpConn *net.UDPConn) {
 
 			err := tcpConn.SetReadDeadline(time.Now().Add(time.Second * 30))
 			if err != nil {
-				log.Errorf("[TUN-UDP] Failed to set read deadline: %v", err)
+				plog.G(ctx).Errorf("[TUN-UDP] Failed to set read deadline: %v", err)
 				errChan <- err
 				return
 			}
 			dgram, err := readDatagramPacket(tcpConn, buf[:])
 			if err != nil {
-				log.Errorf("[TUN-UDP] %s -> %s: %v", tcpConn.RemoteAddr(), udpConn.LocalAddr(), err)
+				plog.G(ctx).Errorf("[TUN-UDP] %s -> %s: %v", tcpConn.RemoteAddr(), udpConn.LocalAddr(), err)
 				errChan <- err
 				return
 			}
 			if dgram.DataLength == 0 {
-				log.Errorf("[TUN-UDP] Length is zero")
+				plog.G(ctx).Errorf("[TUN-UDP] Length is zero")
 				errChan <- fmt.Errorf("length of read packet is zero")
 				return
 			}
 
 			err = udpConn.SetWriteDeadline(time.Now().Add(time.Second * 30))
 			if err != nil {
-				log.Errorf("[TUN-UDP] Failed to set write deadline: %v", err)
+				plog.G(ctx).Errorf("[TUN-UDP] Failed to set write deadline: %v", err)
 				errChan <- err
 				return
 			}
 			if _, err = udpConn.Write(dgram.Data); err != nil {
-				log.Errorf("[TUN-UDP] %s -> %s : %s", tcpConn.RemoteAddr(), "localhost:8422", err)
+				plog.G(ctx).Errorf("[TUN-UDP] %s -> %s : %s", tcpConn.RemoteAddr(), "localhost:8422", err)
 				errChan <- err
 				return
 			}
-			log.Debugf("[TUN-UDP] %s >>> %s length: %d", tcpConn.RemoteAddr(), "localhost:8422", dgram.DataLength)
+			plog.G(ctx).Debugf("[TUN-UDP] %s >>> %s length: %d", tcpConn.RemoteAddr(), "localhost:8422", dgram.DataLength)
 		}
 	}()
 
@@ -161,18 +161,18 @@ func handle(ctx context.Context, tcpConn net.Conn, udpConn *net.UDPConn) {
 
 			err := udpConn.SetReadDeadline(time.Now().Add(time.Second * 30))
 			if err != nil {
-				log.Errorf("[TUN-UDP] Failed to set read deadline failed: %v", err)
+				plog.G(ctx).Errorf("[TUN-UDP] Failed to set read deadline failed: %v", err)
 				errChan <- err
 				return
 			}
 			n, _, err := udpConn.ReadFrom(buf[:])
 			if err != nil {
-				log.Errorf("[TUN-UDP] %s : %s", tcpConn.RemoteAddr(), err)
+				plog.G(ctx).Errorf("[TUN-UDP] %s : %s", tcpConn.RemoteAddr(), err)
 				errChan <- err
 				return
 			}
 			if n == 0 {
-				log.Errorf("[TUN-UDP] Length is zero")
+				plog.G(ctx).Errorf("[TUN-UDP] Length is zero")
 				errChan <- fmt.Errorf("length of read packet is zero")
 				return
 			}
@@ -180,23 +180,23 @@ func handle(ctx context.Context, tcpConn net.Conn, udpConn *net.UDPConn) {
 			// pipe from peer to tunnel
 			err = tcpConn.SetWriteDeadline(time.Now().Add(time.Second * 30))
 			if err != nil {
-				log.Errorf("[TUN-UDP] Error: set write deadline failed: %v", err)
+				plog.G(ctx).Errorf("[TUN-UDP] Error: set write deadline failed: %v", err)
 				errChan <- err
 				return
 			}
 			dgram := newDatagramPacket(buf[:n])
 			if err = dgram.Write(tcpConn); err != nil {
-				log.Errorf("[TUN-UDP] Error: %s <- %s : %s", tcpConn.RemoteAddr(), dgram.Addr(), err)
+				plog.G(ctx).Errorf("[TUN-UDP] Error: %s <- %s : %s", tcpConn.RemoteAddr(), dgram.Addr(), err)
 				errChan <- err
 				return
 			}
-			log.Debugf("[TUN-UDP] %s <<< %s length: %d", tcpConn.RemoteAddr(), dgram.Addr(), len(dgram.Data))
+			plog.G(ctx).Debugf("[TUN-UDP] %s <<< %s length: %d", tcpConn.RemoteAddr(), dgram.Addr(), len(dgram.Data))
 		}
 	}()
 	err := <-errChan
 	if err != nil {
-		log.Errorf("[TUN-UDP] %v", err)
+		plog.G(ctx).Errorf("[TUN-UDP] %v", err)
 	}
-	log.Debugf("[TUN-UDP] %s >-< %s", tcpConn.RemoteAddr(), udpConn.LocalAddr())
+	plog.G(ctx).Debugf("[TUN-UDP] %s >-< %s", tcpConn.RemoteAddr(), udpConn.LocalAddr())
 	return
 }

pkg/core/route.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"os"
@@ -9,9 +10,9 @@ import (
 
 	"github.com/containernetworking/cni/pkg/types"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/tun"
 )
 
@@ -59,7 +60,7 @@ func parseChainNode(ns string) (*Node, error) {
 func (r *Route) GenerateServers() ([]Server, error) {
 	chain, err := r.parseChain()
 	if err != nil && !errors.Is(err, ErrorInvalidNode) {
-		log.Errorf("Failed to parse chain: %v", err)
+		plog.G(context.Background()).Errorf("Failed to parse chain: %v", err)
 		return nil, err
 	}
 
@@ -68,7 +69,7 @@ func (r *Route) GenerateServers() ([]Server, error) {
 		var node *Node
 		node, err = ParseNode(serveNode)
 		if err != nil {
-			log.Errorf("Failed to parse node %s: %v", serveNode, err)
+			plog.G(context.Background()).Errorf("Failed to parse node %s: %v", serveNode, err)
 			return nil, err
 		}
 
@@ -87,39 +88,39 @@ func (r *Route) GenerateServers() ([]Server, error) {
 				Gateway: node.Get("gw"),
 			})
 			if err != nil {
-				log.Errorf("Failed to create tun listener: %v", err)
+				plog.G(context.Background()).Errorf("Failed to create tun listener: %v", err)
 				return nil, err
 			}
 		case "tcp":
 			handler = TCPHandler()
 			ln, err = TCPListener(node.Addr)
 			if err != nil {
-				log.Errorf("Failed to create tcp listener: %v", err)
+				plog.G(context.Background()).Errorf("Failed to create tcp listener: %v", err)
 				return nil, err
 			}
 		case "gtcp":
 			handler = GvisorTCPHandler()
 			ln, err = GvisorTCPListener(node.Addr)
 			if err != nil {
-				log.Errorf("Failed to create gvisor tcp listener: %v", err)
+				plog.G(context.Background()).Errorf("Failed to create gvisor tcp listener: %v", err)
 				return nil, err
 			}
 		case "gudp":
 			handler = GvisorUDPHandler()
 			ln, err = GvisorUDPListener(node.Addr)
 			if err != nil {
-				log.Errorf("Failed to create gvisor udp listener: %v", err)
+				plog.G(context.Background()).Errorf("Failed to create gvisor udp listener: %v", err)
 				return nil, err
 			}
 		case "ssh":
 			handler = SSHHandler()
 			ln, err = SSHListener(node.Addr)
 			if err != nil {
-				log.Errorf("Failed to create ssh listener: %v", err)
+				plog.G(context.Background()).Errorf("Failed to create ssh listener: %v", err)
 				return nil, err
 			}
 		default:
-			log.Errorf("Not support protocol %s", node.Protocol)
+			plog.G(context.Background()).Errorf("Not support protocol %s", node.Protocol)
 			return nil, fmt.Errorf("not support protocol %s", node.Protocol)
 		}
 		servers = append(servers, Server{Listener: ln, Handler: handler})

pkg/core/ssh.go

@@ -8,8 +8,9 @@ import (
 	"net"
 
 	"github.com/gliderlabs/ssh"
-	log "github.com/sirupsen/logrus"
 	gossh "golang.org/x/crypto/ssh"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func SSHListener(addr string) (net.Listener, error) {
@@ -17,7 +18,7 @@ func SSHListener(addr string) (net.Listener, error) {
 	if err != nil {
 		return nil, err
 	}
-	log.Debugf("starting ssh server on port %s...", addr)
+	plog.G(context.Background()).Debugf("starting ssh server on port %s...", addr)
 	return ln, err
 }
 
@@ -32,7 +33,7 @@ func (s *sshHandler) Handle(ctx context.Context, conn net.Conn) {
 	forwardHandler := &ssh.ForwardedTCPHandler{}
 	server := ssh.Server{
 		LocalPortForwardingCallback: ssh.LocalPortForwardingCallback(func(ctx ssh.Context, dhost string, dport uint32) bool {
-			log.Println("Accepted forward", dhost, dport)
+			plog.G(ctx).Infoln("Accepted forward", dhost, dport)
 			return true
 		}),
 		Handler: ssh.Handler(func(s ssh.Session) {
@@ -40,7 +41,7 @@ func (s *sshHandler) Handle(ctx context.Context, conn net.Conn) {
 			select {}
 		}),
 		ReversePortForwardingCallback: ssh.ReversePortForwardingCallback(func(ctx ssh.Context, host string, port uint32) bool {
-			log.Println("attempt to bind", host, port, "granted")
+			plog.G(ctx).Infoln("attempt to bind", host, port, "granted")
 			return true
 		}),
 		RequestHandlers: map[string]ssh.RequestHandler{

pkg/core/tcphandler.go

@@ -7,9 +7,8 @@ import (
 	"sync"
 	"time"
 
-	log "github.com/sirupsen/logrus"
-
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -55,7 +54,7 @@ func TCPHandler() Handler {
 
 func (h *fakeUdpHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 	defer tcpConn.Close()
-	log.Debugf("[TCP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
+	plog.G(ctx).Debugf("[TCP] %s -> %s", tcpConn.RemoteAddr(), tcpConn.LocalAddr())
 
 	defer func(addr net.Addr) {
 		var keys []string
@@ -68,7 +67,7 @@ func (h *fakeUdpHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 		for _, key := range keys {
 			h.routeMapTCP.Delete(key)
 		}
-		log.Debugf("[TCP] To %s by conn %s from globle route map TCP", strings.Join(keys, " "), addr)
+		plog.G(ctx).Debugf("[TCP] To %s by conn %s from globle route map TCP", strings.Join(keys, " "), addr)
 	}(tcpConn.LocalAddr())
 
 	for {
@@ -81,7 +80,7 @@ func (h *fakeUdpHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 		buf := config.LPool.Get().([]byte)[:]
 		dgram, err := readDatagramPacketServer(tcpConn, buf[:])
 		if err != nil {
-			log.Errorf("[TCP] %s -> %s : %v", tcpConn.RemoteAddr(), tcpConn.LocalAddr(), err)
+			plog.G(ctx).Errorf("[TCP] %s -> %s : %v", tcpConn.RemoteAddr(), tcpConn.LocalAddr(), err)
 			config.LPool.Put(buf[:])
 			return
 		}
@@ -89,7 +88,7 @@ func (h *fakeUdpHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 		var src net.IP
 		src, _, err = util.ParseIP(dgram.Data[:dgram.DataLength])
 		if err != nil {
-			log.Errorf("[TCP] Unknown packet")
+			plog.G(ctx).Errorf("[TCP] Unknown packet")
 			config.LPool.Put(buf[:])
 			continue
 		}
@@ -97,10 +96,10 @@ func (h *fakeUdpHandler) Handle(ctx context.Context, tcpConn net.Conn) {
 		if loaded {
 			if tcpConn != value.(net.Conn) {
 				h.routeMapTCP.Store(src.String(), tcpConn)
-				log.Debugf("[TCP] Replace route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
+				plog.G(ctx).Debugf("[TCP] Replace route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
 			}
 		} else {
-			log.Debugf("[TCP] Add new route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
+			plog.G(ctx).Debugf("[TCP] Add new route map TCP: %s -> %s-%s", src, tcpConn.LocalAddr(), tcpConn.RemoteAddr())
 		}
 		util.SafeWrite(h.packetChan, dgram)
 	}

pkg/core/tunhandler.go

@@ -6,9 +6,8 @@ import (
 	"sync"
 	"time"
 
-	log "github.com/sirupsen/logrus"
-
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -101,24 +100,24 @@ func (d *Device) readFromTun() {
 		n, err := d.tun.Read(buf[:])
 		if err != nil {
 			config.LPool.Put(buf[:])
-			log.Errorf("[TUN] Failed to read from tun: %v", err)
+			plog.G(context.Background()).Errorf("[TUN] Failed to read from tun: %v", err)
 			util.SafeWrite(d.chExit, err)
 			return
 		}
 		if n == 0 {
-			log.Errorf("[TUN] Read packet length 0")
+			plog.G(context.Background()).Errorf("[TUN] Read packet length 0")
 			config.LPool.Put(buf[:])
 			continue
 		}
 
 		src, dst, err := util.ParseIP(buf[:n])
 		if err != nil {
-			log.Errorf("[TUN] Unknown packet")
+			plog.G(context.Background()).Errorf("[TUN] Unknown packet")
 			config.LPool.Put(buf[:])
 			continue
 		}
 
-		log.Debugf("[TUN] SRC: %s --> DST: %s, length: %d", src, dst, n)
+		plog.G(context.Background()).Debugf("[TUN] SRC: %s --> DST: %s, length: %d", src, dst, n)
 		util.SafeWrite(d.tunInbound, &DataElem{
 			data:   buf[:],
 			length: n,
@@ -150,7 +149,7 @@ func (d *Device) Close() {
 func heartbeats(ctx context.Context, tun net.Conn) {
 	tunIfi, err := util.GetTunDeviceByConn(tun)
 	if err != nil {
-		log.Errorf("Failed to get tun device: %s", err.Error())
+		plog.G(ctx).Errorf("Failed to get tun device: %s", err.Error())
 		return
 	}
 	srcIPv4, srcIPv6, dockerSrcIPv4, err := util.GetTunDeviceIP(tunIfi.Name)
@@ -187,7 +186,7 @@ func (d *Device) Start(ctx context.Context) {
 
 	select {
 	case err := <-d.chExit:
-		log.Errorf("Device exit: %v", err)
+		plog.G(ctx).Errorf("Device exit: %v", err)
 		return
 	case <-ctx.Done():
 		return
@@ -209,12 +208,12 @@ func (h *tunHandler) HandleServer(ctx context.Context, tun net.Conn) {
 		for ctx.Err() == nil {
 			packetConn, err := (&net.ListenConfig{}).ListenPacket(ctx, "udp", h.node.Addr)
 			if err != nil {
-				log.Errorf("[UDP] Failed to listen %s: %v", h.node.Addr, err)
+				plog.G(ctx).Errorf("[UDP] Failed to listen %s: %v", h.node.Addr, err)
 				return
 			}
 			err = transportTunServer(ctx, tunInbound, tunOutbound, packetConn, h.routeMapUDP, h.routeMapTCP)
 			if err != nil {
-				log.Errorf("[TUN] %s: %v", tun.LocalAddr(), err)
+				plog.G(ctx).Errorf("[TUN] %s: %v", tun.LocalAddr(), err)
 			}
 		}
 	})
@@ -292,16 +291,16 @@ func (p *Peer) readFromConn() {
 		src, dst, err := util.ParseIP(buf[:n])
 		if err != nil {
 			config.LPool.Put(buf[:])
-			log.Errorf("[TUN] Unknown packet: %v", err)
+			plog.G(context.Background()).Errorf("[TUN] Unknown packet: %v", err)
 			continue
 		}
 		if addr, loaded := p.routeMapUDP.LoadOrStore(src, from); loaded {
 			if addr.String() != from.String() {
 				p.routeMapUDP.Store(src, from)
-				log.Debugf("[TUN] Replace route map UDP: %s -> %s", src, from)
+				plog.G(context.Background()).Debugf("[TUN] Replace route map UDP: %s -> %s", src, from)
 			}
 		} else {
-			log.Debugf("[TUN] Add new route map UDP: %s -> %s", src, from)
+			plog.G(context.Background()).Debugf("[TUN] Add new route map UDP: %s -> %s", src, from)
 		}
 
 		p.connInbound <- &udpElem{
@@ -319,7 +318,7 @@ func (p *Peer) readFromTCPConn() {
 	for packet := range TCPPacketChan {
 		src, dst, err := util.ParseIP(packet.Data)
 		if err != nil {
-			log.Errorf("[TUN] Unknown packet")
+			plog.G(context.Background()).Errorf("[TUN] Unknown packet")
 			config.LPool.Put(packet.Data[:])
 			continue
 		}
@@ -329,7 +328,7 @@ func (p *Peer) readFromTCPConn() {
 			src:    src,
 			dst:    dst,
 		}
-		log.Debugf("[TCP] udp-tun %s >>> %s length: %d", u.src, u.dst, u.length)
+		plog.G(context.Background()).Debugf("[TCP] udp-tun %s >>> %s length: %d", u.src, u.dst, u.length)
 		p.connInbound <- u
 	}
 }
@@ -338,7 +337,7 @@ func (p *Peer) routePeer() {
 	defer util.HandleCrash()
 	for e := range p.connInbound {
 		if routeToAddr := p.routeMapUDP.RouteTo(e.dst); routeToAddr != nil {
-			log.Debugf("[UDP] Find UDP route to dst: %s -> %s", e.dst, routeToAddr)
+			plog.G(context.Background()).Debugf("[UDP] Find UDP route to dst: %s -> %s", e.dst, routeToAddr)
 			_, err := p.conn.WriteTo(e.data[:e.length], routeToAddr)
 			config.LPool.Put(e.data[:])
 			if err != nil {
@@ -346,17 +345,17 @@ func (p *Peer) routePeer() {
 				return
 			}
 		} else if conn, ok := p.routeMapTCP.Load(e.dst.String()); ok {
-			log.Debugf("[TCP] Find TCP route to dst: %s -> %s", e.dst.String(), conn.(net.Conn).RemoteAddr())
+			plog.G(context.Background()).Debugf("[TCP] Find TCP route to dst: %s -> %s", e.dst.String(), conn.(net.Conn).RemoteAddr())
 			dgram := newDatagramPacket(e.data[:e.length])
 			err := dgram.Write(conn.(net.Conn))
 			config.LPool.Put(e.data[:])
 			if err != nil {
-				log.Errorf("[TCP] udp-tun %s <- %s : %s", conn.(net.Conn).RemoteAddr(), dgram.Addr(), err)
+				plog.G(context.Background()).Errorf("[TCP] udp-tun %s <- %s : %s", conn.(net.Conn).RemoteAddr(), dgram.Addr(), err)
 				p.sendErr(err)
 				return
 			}
 		} else {
-			log.Debugf("[TUN] Not found route to dst: %s, write to TUN device", e.dst.String())
+			plog.G(context.Background()).Debugf("[TUN] Not found route to dst: %s, write to TUN device", e.dst.String())
 			p.tunOutbound <- &DataElem{
 				data:   e.data,
 				length: e.length,
@@ -371,26 +370,26 @@ func (p *Peer) routeTUN() {
 	defer util.HandleCrash()
 	for e := range p.tunInbound {
 		if addr := p.routeMapUDP.RouteTo(e.dst); addr != nil {
-			log.Debugf("[TUN] Find UDP route to dst: %s -> %s", e.dst, addr)
+			plog.G(context.Background()).Debugf("[TUN] Find UDP route to dst: %s -> %s", e.dst, addr)
 			_, err := p.conn.WriteTo(e.data[:e.length], addr)
 			config.LPool.Put(e.data[:])
 			if err != nil {
-				log.Debugf("[TUN] Failed wirte to route dst: %s -> %s", e.dst, addr)
+				plog.G(context.Background()).Debugf("[TUN] Failed wirte to route dst: %s -> %s", e.dst, addr)
 				p.sendErr(err)
 				return
 			}
 		} else if conn, ok := p.routeMapTCP.Load(e.dst.String()); ok {
-			log.Debugf("[TUN] Find TCP route to dst: %s -> %s", e.dst.String(), conn.(net.Conn).RemoteAddr())
+			plog.G(context.Background()).Debugf("[TUN] Find TCP route to dst: %s -> %s", e.dst.String(), conn.(net.Conn).RemoteAddr())
 			dgram := newDatagramPacket(e.data[:e.length])
 			err := dgram.Write(conn.(net.Conn))
 			config.LPool.Put(e.data[:])
 			if err != nil {
-				log.Errorf("[TUN] Failed to write TCP %s <- %s : %s", conn.(net.Conn).RemoteAddr(), dgram.Addr(), err)
+				plog.G(context.Background()).Errorf("[TUN] Failed to write TCP %s <- %s : %s", conn.(net.Conn).RemoteAddr(), dgram.Addr(), err)
 				p.sendErr(err)
 				return
 			}
 		} else {
-			log.Errorf("[TUN] No route for src: %s -> dst: %s, drop it", e.src, e.dst)
+			plog.G(context.Background()).Errorf("[TUN] No route for src: %s -> dst: %s, drop it", e.src, e.dst)
 			config.LPool.Put(e.data[:])
 		}
 	}
@@ -423,7 +422,7 @@ func transportTunServer(ctx context.Context, tunInbound <-chan *DataElem, tunOut
 
 	select {
 	case err := <-p.errChan:
-		log.Errorf(err.Error())
+		plog.G(ctx).Errorf(err.Error())
 		return err
 	case <-ctx.Done():
 		return nil

pkg/core/tunhandlerclient.go

@@ -7,9 +7,8 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
-
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -17,7 +16,7 @@ func (h *tunHandler) HandleClient(ctx context.Context, tun net.Conn) {
 	defer tun.Close()
 	remoteAddr, err := net.ResolveUDPAddr("udp", h.node.Remote)
 	if err != nil {
-		log.Errorf("[TUN-CLIENT] Failed to resolve udp addr %s: %v", h.node.Remote, err)
+		plog.G(ctx).Errorf("[TUN-CLIENT] Failed to resolve udp addr %s: %v", h.node.Remote, err)
 		return
 	}
 	in := make(chan *DataElem, MaxSize)
@@ -35,13 +34,13 @@ func (h *tunHandler) HandleClient(ctx context.Context, tun net.Conn) {
 		for ctx.Err() == nil {
 			packetConn, err := getRemotePacketConn(ctx, h.chain)
 			if err != nil {
-				log.Debugf("[TUN-CLIENT] Failed to get remote conn from %s -> %s: %s", tun.LocalAddr(), remoteAddr, err)
+				plog.G(ctx).Debugf("[TUN-CLIENT] Failed to get remote conn from %s -> %s: %s", tun.LocalAddr(), remoteAddr, err)
 				time.Sleep(time.Millisecond * 200)
 				continue
 			}
 			err = transportTunClient(ctx, tunInbound, tunOutbound, packetConn, remoteAddr)
 			if err != nil {
-				log.Debugf("[TUN-CLIENT] %s: %v", tun.LocalAddr(), err)
+				plog.G(ctx).Debugf("[TUN-CLIENT] %s: %v", tun.LocalAddr(), err)
 			}
 		}
 	})
@@ -135,7 +134,7 @@ func (d *ClientDevice) Start(ctx context.Context) {
 
 	select {
 	case err := <-d.chExit:
-		log.Errorf("[TUN-CLIENT]: %v", err)
+		plog.G(ctx).Errorf("[TUN-CLIENT]: %v", err)
 		return
 	case <-ctx.Done():
 		return
@@ -165,11 +164,11 @@ func (d *ClientDevice) readFromTun() {
 		var src, dst net.IP
 		src, dst, err = util.ParseIP(buf[:n])
 		if err != nil {
-			log.Debugf("[TUN-GVISOR] Unknown packet: %v", err)
+			plog.G(context.Background()).Debugf("[TUN-GVISOR] Unknown packet: %v", err)
 			config.LPool.Put(buf[:])
 			continue
 		}
-		log.Tracef("[TUN-RAW] SRC: %s, DST: %s, Length: %d", src.String(), dst, n)
+		plog.G(context.Background()).Debugf("[TUN-RAW] SRC: %s, DST: %s, Length: %d", src.String(), dst, n)
 		util.SafeWrite(d.tunInbound, NewDataElem(buf[:], n, src, dst))
 	}
 }

pkg/cp/cp.go

@@ -3,14 +3,15 @@ package cp
 import (
 	"archive/tar"
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"io"
 	"os"
 	"runtime"
 	"strings"
 
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"k8s.io/cli-runtime/pkg/genericiooptions"
 	"k8s.io/client-go/kubernetes"
@@ -183,7 +184,7 @@ func (o *CopyOptions) copyToPod(src, dest fileSpec, options *exec.ExecOptions) e
 	go func(src localPath, dest remotePath, writer io.WriteCloser) {
 		defer writer.Close()
 		if err := makeTar(src, dest, writer); err != nil {
-			log.Errorf("Error making tar: %v", err)
+			plog.G(context.Background()).Errorf("Error making tar: %v", err)
 		}
 	}(srcFile, destFile, writer)
 	var cmdArr []string
@@ -266,7 +267,7 @@ func (t *TarPipe) initReadFrom(n uint64) {
 	go func() {
 		defer t.outStream.Close()
 		if err := t.o.execute(options); err != nil {
-			log.Errorf("Error executing command: %v", err)
+			plog.G(context.Background()).Errorf("Error executing command: %v", err)
 		}
 	}()
 }

pkg/daemon/action/clone.go

@@ -4,26 +4,19 @@ import (
 	"context"
 	"io"
 
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Clone(req *rpc.CloneRequest, resp rpc.Daemon_CloneServer) (err error) {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	config.Debug = req.Level == int32(log.DebugLevel)
-	out := io.MultiWriter(newCloneWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(req.Level, io.MultiWriter(newCloneWarp(resp), svr.LogFile))
+
 	var sshConf = ssh.ParseSshFromRPC(req.SshJump)
 	connReq := &rpc.ConnectRequest{
 		KubeconfigBytes:      req.KubeconfigBytes,
@@ -42,12 +35,10 @@ func (svr *Server) Clone(req *rpc.CloneRequest, resp rpc.Daemon_CloneServer) (er
 	if err != nil {
 		return err
 	}
-	err = util.PrintGRPCStream[rpc.ConnectResponse](connResp, out)
+	err = util.PrintGRPCStream[rpc.ConnectResponse](connResp, io.MultiWriter(newCloneWarp(resp), svr.LogFile))
 	if err != nil {
 		return err
 	}
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
 
 	options := &handler.CloneOptions{
 		Namespace:            req.Namespace,
@@ -79,7 +70,7 @@ func (svr *Server) Clone(req *rpc.CloneRequest, resp rpc.Daemon_CloneServer) (er
 	sshCtx, sshFunc := context.WithCancel(context.Background())
 	defer func() {
 		if err != nil {
-			_ = options.Cleanup()
+			_ = options.Cleanup(sshCtx)
 			sshFunc()
 		}
 	}()
@@ -95,15 +86,15 @@ func (svr *Server) Clone(req *rpc.CloneRequest, resp rpc.Daemon_CloneServer) (er
 	f := util.InitFactoryByPath(path, req.Namespace)
 	err = options.InitClient(f)
 	if err != nil {
-		log.Errorf("Failed to init client: %v", err)
+		plog.G(context.Background()).Errorf("Failed to init client: %v", err)
 		return err
 	}
 	config.Image = req.Image
-	log.Infof("Clone workloads...")
+	logger.Infof("Clone workloads...")
 	options.SetContext(sshCtx)
-	err = options.DoClone(resp.Context(), []byte(req.KubeconfigBytes))
+	err = options.DoClone(plog.WithLogger(resp.Context(), logger), []byte(req.KubeconfigBytes))
 	if err != nil {
-		log.Errorf("Clone workloads failed: %v", err)
+		plog.G(context.Background()).Errorf("Clone workloads failed: %v", err)
 		return err
 	}
 	svr.clone = options

pkg/daemon/action/connect-fork.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	defaultlog "log"
 
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
@@ -12,22 +11,15 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectForkServer) (err error) {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	config.Debug = req.Level == int32(log.DebugLevel)
-	out := io.MultiWriter(newConnectForkWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(req.Level, io.MultiWriter(newConnectForkWarp(resp), svr.LogFile))
 	if !svr.IsSudo {
-		return svr.redirectConnectForkToSudoDaemon(req, resp)
+		return svr.redirectConnectForkToSudoDaemon(req, resp, logger)
 	}
 
 	ctx := resp.Context()
@@ -41,7 +33,6 @@ func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectF
 		Lock:                 &svr.Lock,
 		ImagePullSecretName:  req.ImagePullSecretName,
 	}
-	defaultlog.Default().SetOutput(io.Discard)
 	file, err := util.ConvertToTempKubeconfigFile([]byte(req.KubeconfigBytes))
 	if err != nil {
 		return err
@@ -57,9 +48,11 @@ func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectF
 		sshCancel()
 		return nil
 	})
+	sshCtx = plog.WithLogger(sshCtx, logger)
+	defer plog.WithoutLogger(sshCtx)
 	defer func() {
 		if err != nil {
-			connect.Cleanup()
+			connect.Cleanup(plog.WithLogger(context.Background(), logger))
 			sshCancel()
 		}
 	}()
@@ -73,7 +66,7 @@ func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectF
 	if err != nil {
 		return err
 	}
-	err = connect.GetIPFromContext(ctx)
+	err = connect.GetIPFromContext(ctx, logger)
 	if err != nil {
 		return err
 	}
@@ -81,7 +74,7 @@ func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectF
 	config.Image = req.Image
 	err = connect.DoConnect(sshCtx, true, ctx.Done())
 	if err != nil {
-		log.Errorf("Failed to connect: %v", err)
+		logger.Errorf("Failed to connect: %v", err)
 		return err
 	}
 
@@ -92,7 +85,7 @@ func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectF
 	return nil
 }
 
-func (svr *Server) redirectConnectForkToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer) (err error) {
+func (svr *Server) redirectConnectForkToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer, logger *log.Logger) (err error) {
 	cli := svr.GetClient(true)
 	if cli == nil {
 		return fmt.Errorf("sudo daemon not start")
@@ -122,7 +115,7 @@ func (svr *Server) redirectConnectForkToSudoDaemon(req *rpc.ConnectRequest, resp
 	})
 	defer func() {
 		if err != nil {
-			connect.Cleanup()
+			connect.Cleanup(plog.WithLogger(context.Background(), logger))
 			sshCancel()
 		}
 	}()
@@ -144,7 +137,7 @@ func (svr *Server) redirectConnectForkToSudoDaemon(req *rpc.ConnectRequest, resp
 		)
 		if isSameCluster {
 			// same cluster, do nothing
-			log.Infof("Connected with cluster")
+			logger.Infof("Connected with cluster")
 			return nil
 		}
 	}

pkg/daemon/action/connect.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	golog "log"
 	"time"
 
 	log "github.com/sirupsen/logrus"
@@ -15,35 +14,28 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Connect(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer) (e error) {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	config.Debug = req.Level == int32(log.DebugLevel)
-	out := io.MultiWriter(newWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(req.Level, io.MultiWriter(newWarp(resp), svr.LogFile))
 	if !svr.IsSudo {
-		return svr.redirectToSudoDaemon(req, resp)
+		return svr.redirectToSudoDaemon(req, resp, logger)
 	}
 
 	ctx := resp.Context()
 	if !svr.t.IsZero() {
 		s := "Already connected to cluster in full mode, you can use options `--lite` to connect to another cluster"
-		log.Debugf(s)
+		logger.Debugf(s)
 		// todo define already connect error?
 		return status.Error(codes.AlreadyExists, s)
 	}
 	defer func() {
 		if e != nil || ctx.Err() != nil {
 			if svr.connect != nil {
-				svr.connect.Cleanup()
+				svr.connect.Cleanup(plog.WithLogger(context.Background(), logger))
 				svr.connect = nil
 			}
 			svr.t = time.Time{}
@@ -61,7 +53,6 @@ func (svr *Server) Connect(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServe
 		Lock:                 &svr.Lock,
 		ImagePullSecretName:  req.ImagePullSecretName,
 	}
-	golog.Default().SetOutput(io.Discard)
 	file, err := util.ConvertToTempKubeconfigFile([]byte(req.KubeconfigBytes))
 	if err != nil {
 		return err
@@ -77,9 +68,11 @@ func (svr *Server) Connect(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServe
 		sshCancel()
 		return nil
 	})
+	sshCtx = plog.WithLogger(sshCtx, logger)
+	defer plog.WithoutLogger(sshCtx)
 	defer func() {
 		if e != nil {
-			svr.connect.Cleanup()
+			svr.connect.Cleanup(sshCtx)
 			svr.connect = nil
 			svr.t = time.Time{}
 			sshCancel()
@@ -94,7 +87,7 @@ func (svr *Server) Connect(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServe
 	if err != nil {
 		return err
 	}
-	err = svr.connect.GetIPFromContext(ctx)
+	err = svr.connect.GetIPFromContext(ctx, nil)
 	if err != nil {
 		return err
 	}
@@ -102,13 +95,13 @@ func (svr *Server) Connect(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServe
 	config.Image = req.Image
 	err = svr.connect.DoConnect(sshCtx, false, ctx.Done())
 	if err != nil {
-		log.Errorf("Failed to connect: %v", err)
+		logger.Errorf("Failed to connect: %v", err)
 		return err
 	}
 	return nil
 }
 
-func (svr *Server) redirectToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer) (e error) {
+func (svr *Server) redirectToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer, logger *log.Logger) (e error) {
 	cli := svr.GetClient(true)
 	if cli == nil {
 		return fmt.Errorf("sudo daemon not start")
@@ -139,7 +132,7 @@ func (svr *Server) redirectToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon
 	})
 	defer func() {
 		if e != nil {
-			connect.Cleanup()
+			connect.Cleanup(plog.WithLogger(context.Background(), logger))
 			sshCancel()
 		}
 	}()
@@ -161,7 +154,7 @@ func (svr *Server) redirectToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon
 		)
 		if isSameCluster {
 			// same cluster, do nothing
-			log.Infof("Connected to cluster")
+			logger.Infof("Connected to cluster")
 			return nil
 		}
 	}

pkg/daemon/action/disconnect.go

@@ -10,34 +10,28 @@ import (
 	"github.com/spf13/pflag"
 	"k8s.io/apimachinery/pkg/util/sets"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dns"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Disconnect(req *rpc.DisconnectRequest, resp rpc.Daemon_DisconnectServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newDisconnectWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newDisconnectWarp(resp), svr.LogFile))
+	ctx := plog.WithLogger(resp.Context(), logger)
 	switch {
 	case req.GetAll():
 		if svr.clone != nil {
-			_ = svr.clone.Cleanup()
+			_ = svr.clone.Cleanup(ctx)
 		}
 		svr.clone = nil
 
 		connects := handler.Connects(svr.secondaryConnect).Append(svr.connect)
 		for _, connect := range connects.Sort() {
 			if connect != nil {
-				connect.Cleanup()
+				connect.Cleanup(ctx)
 			}
 		}
 		svr.secondaryConnect = nil
@@ -45,22 +39,22 @@ func (svr *Server) Disconnect(req *rpc.DisconnectRequest, resp rpc.Daemon_Discon
 		svr.t = time.Time{}
 	case req.ID != nil && req.GetID() == 0:
 		if svr.connect != nil {
-			svr.connect.Cleanup()
+			svr.connect.Cleanup(ctx)
 		}
 		svr.connect = nil
 		svr.t = time.Time{}
 
 		if svr.clone != nil {
-			_ = svr.clone.Cleanup()
+			_ = svr.clone.Cleanup(ctx)
 		}
 		svr.clone = nil
 	case req.ID != nil:
 		index := req.GetID() - 1
 		if index < int32(len(svr.secondaryConnect)) {
-			svr.secondaryConnect[index].Cleanup()
+			svr.secondaryConnect[index].Cleanup(ctx)
 			svr.secondaryConnect = append(svr.secondaryConnect[:index], svr.secondaryConnect[index+1:]...)
 		} else {
-			log.Errorf("Index %d out of range", req.GetID())
+			plog.G(ctx).Errorf("Index %d out of range", req.GetID())
 		}
 	case req.KubeconfigBytes != nil && req.Namespace != nil:
 		err := disconnectByKubeConfig(
@@ -90,14 +84,14 @@ func (svr *Server) Disconnect(req *rpc.DisconnectRequest, resp rpc.Daemon_Discon
 		}
 		for _, connect := range connects.Sort() {
 			if connect != nil {
-				connect.Cleanup()
+				connect.Cleanup(ctx)
 			}
 		}
 		if foundModeFull {
 			svr.connect = nil
 			svr.t = time.Time{}
 			if svr.clone != nil {
-				_ = svr.clone.Cleanup()
+				_ = svr.clone.Cleanup(ctx)
 			}
 			svr.clone = nil
 		}
@@ -166,8 +160,8 @@ func disconnect(ctx context.Context, svr *Server, connect *handler.ConnectOption
 			connect.GetClientset().CoreV1().ConfigMaps(connect.Namespace), connect.Namespace,
 		)
 		if isSameCluster {
-			log.Infof("Disconnecting from the cluster...")
-			svr.connect.Cleanup()
+			plog.G(ctx).Infof("Disconnecting from the cluster...")
+			svr.connect.Cleanup(ctx)
 			svr.connect = nil
 			svr.t = time.Time{}
 		}
@@ -180,8 +174,8 @@ func disconnect(ctx context.Context, svr *Server, connect *handler.ConnectOption
 			connect.GetClientset().CoreV1().ConfigMaps(connect.Namespace), connect.Namespace,
 		)
 		if isSameCluster {
-			log.Infof("Disconnecting from the cluster...")
-			options.Cleanup()
+			plog.G(ctx).Infof("Disconnecting from the cluster...")
+			options.Cleanup(ctx)
 			svr.secondaryConnect = append(svr.secondaryConnect[:i], svr.secondaryConnect[i+1:]...)
 			i--
 		}

pkg/daemon/action/leave.go

@@ -8,26 +8,20 @@ import (
 	log "github.com/sirupsen/logrus"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Leave(req *rpc.LeaveRequest, resp rpc.Daemon_LeaveServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newLeaveWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newLeaveWarp(resp), svr.LogFile))
 	if svr.connect == nil {
-		log.Infof("Not proxy any resource in cluster")
+		logger.Infof("Not proxy any resource in cluster")
 		return fmt.Errorf("not proxy any resource in cluster")
 	}
+	ctx := plog.WithLogger(resp.Context(), logger)
 
 	factory := svr.connect.GetFactory()
 	namespace := svr.connect.Namespace
@@ -36,32 +30,32 @@ func (svr *Server) Leave(req *rpc.LeaveRequest, resp rpc.Daemon_LeaveServer) err
 	for _, workload := range req.GetWorkloads() {
 		object, err := util.GetUnstructuredObject(factory, namespace, workload)
 		if err != nil {
-			log.Errorf("Failed to get unstructured object: %v", err)
+			logger.Errorf("Failed to get unstructured object: %v", err)
 			return err
 		}
 		u := object.Object.(*unstructured.Unstructured)
 		templateSpec, _, err := util.GetPodTemplateSpecPath(u)
 		if err != nil {
-			log.Errorf("Failed to get template spec path: %v", err)
+			logger.Errorf("Failed to get template spec path: %v", err)
 			return err
 		}
 		// add rollback func to remove envoy config
 		var empty bool
-		empty, err = inject.UnPatchContainer(factory, maps, object, func(isFargateMode bool, rule *controlplane.Rule) bool {
+		empty, err = inject.UnPatchContainer(ctx, factory, maps, object, func(isFargateMode bool, rule *controlplane.Rule) bool {
 			if isFargateMode {
 				return svr.connect.IsMe(util.ConvertWorkloadToUid(workload), rule.Headers)
 			}
 			return rule.LocalTunIPv4 == v4
 		})
 		if err != nil {
-			log.Errorf("Leaving workload %s failed: %v", workload, err)
+			plog.G(ctx).Errorf("Leaving workload %s failed: %v", workload, err)
 			continue
 		}
 		if empty {
-			err = inject.ModifyServiceTargetPort(resp.Context(), svr.connect.GetClientset(), namespace, templateSpec.Labels, map[int32]int32{})
+			err = inject.ModifyServiceTargetPort(ctx, svr.connect.GetClientset(), namespace, templateSpec.Labels, map[int32]int32{})
 		}
 		svr.connect.LeavePortMap(workload)
-		err = util.RolloutStatus(resp.Context(), factory, namespace, workload, time.Minute*60)
+		err = util.RolloutStatus(ctx, factory, namespace, workload, time.Minute*60)
 	}
 	return nil
 }

pkg/daemon/action/proxy.go

@@ -12,6 +12,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -24,17 +25,9 @@ import (
 //     2.1 disconnect from cluster
 //     2.2 same as step 1
 func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) (e error) {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newProxyWarp(resp), svr.LogFile)
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newProxyWarp(resp), svr.LogFile))
 	config.Image = req.Image
-	config.Debug = req.Level == int32(log.DebugLevel)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
-	ctx := resp.Context()
+	ctx := plog.WithLogger(resp.Context(), logger)
 	connect := &handler.ConnectOptions{
 		Namespace:            req.Namespace,
 		Headers:              req.Headers,
@@ -73,7 +66,7 @@ func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) (
 
 	defer func() {
 		if e != nil && svr.connect != nil {
-			_ = svr.connect.LeaveAllProxyResources(context.Background())
+			_ = svr.connect.LeaveAllProxyResources(plog.WithLogger(context.Background(), logger))
 		}
 	}()
 
@@ -89,9 +82,9 @@ func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) (
 		)
 		if isSameCluster {
 			// same cluster, do nothing
-			log.Infof("Connected to cluster")
+			plog.G(ctx).Infof("Connected to cluster")
 		} else {
-			log.Infof("Disconnecting from another cluster...")
+			plog.G(ctx).Infof("Disconnecting from another cluster...")
 			var disconnectResp rpc.Daemon_DisconnectClient
 			disconnectResp, err = daemonClient.Disconnect(ctx, &rpc.DisconnectRequest{
 				KubeconfigBytes: ptr.To(req.KubeconfigBytes),
@@ -111,13 +104,11 @@ func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) (
 			if err != nil {
 				return err
 			}
-			util.InitLoggerForClient(config.Debug)
-			log.SetOutput(out)
 		}
 	}
 
 	if svr.connect == nil {
-		log.Debugf("Connectting to cluster")
+		plog.G(ctx).Debugf("Connectting to cluster")
 		var connResp rpc.Daemon_ConnectClient
 		connResp, err = daemonClient.Connect(ctx, req)
 		if err != nil {
@@ -127,13 +118,11 @@ func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) (
 		if err != nil {
 			return err
 		}
-		util.InitLoggerForClient(config.Debug)
-		log.SetOutput(out)
 	}
 
 	err = svr.connect.CreateRemoteInboundPod(ctx, workloads, req.Headers, req.PortMap)
 	if err != nil {
-		log.Errorf("Failed to inject inbound sidecar: %v", err)
+		plog.G(ctx).Errorf("Failed to inject inbound sidecar: %v", err)
 		return err
 	}
 	return nil

pkg/daemon/action/quit.go

@@ -7,26 +7,25 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dns"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Quit(req *rpc.QuitRequest, resp rpc.Daemon_QuitServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(io.MultiWriter(newQuitWarp(resp), svr.LogFile))
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newQuitWarp(resp), svr.LogFile))
+	ctx := context.Background()
+	if resp != nil {
+		ctx = resp.Context()
+	}
+	ctx = plog.WithLogger(ctx, logger)
 
 	if svr.clone != nil {
-		err := svr.clone.Cleanup()
+		err := svr.clone.Cleanup(ctx)
 		if err != nil {
-			log.Errorf("Cleanup clone failed: %v", err)
+			plog.G(ctx).Errorf("Cleanup clone failed: %v", err)
 		}
 		svr.clone = nil
 	}
@@ -34,7 +33,7 @@ func (svr *Server) Quit(req *rpc.QuitRequest, resp rpc.Daemon_QuitServer) error
 	connects := handler.Connects(svr.secondaryConnect).Append(svr.connect)
 	for _, conn := range connects.Sort() {
 		if conn != nil {
-			conn.Cleanup()
+			conn.Cleanup(ctx)
 		}
 	}
 	svr.secondaryConnect = nil

pkg/daemon/action/remove.go

@@ -5,27 +5,19 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func (svr *Server) Remove(req *rpc.RemoveRequest, resp rpc.Daemon_RemoveServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newRemoveWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
-
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newRemoveWarp(resp), svr.LogFile))
+	ctx := plog.WithLogger(resp.Context(), logger)
 	if svr.clone != nil {
-		err := svr.clone.Cleanup(req.Workloads...)
+		err := svr.clone.Cleanup(ctx, req.Workloads...)
 		svr.clone = nil
 		return err
 	} else {
-		log.Info("No clone resource found")
+		logger.Info("No clone resource found")
 	}
 	return nil
 }

pkg/daemon/action/reset.go

@@ -6,23 +6,15 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Reset(req *rpc.ResetRequest, resp rpc.Daemon_ResetServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newResetWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
-
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newResetWarp(resp), svr.LogFile))
 	connect := &handler.ConnectOptions{
 		Namespace: req.Namespace,
 	}
@@ -37,7 +29,7 @@ func (svr *Server) Reset(req *rpc.ResetRequest, resp rpc.Daemon_ResetServer) err
 		DefValue: file,
 	})
 	var sshConf = ssh.ParseSshFromRPC(req.SshJump)
-	var ctx = resp.Context()
+	var ctx = plog.WithLogger(resp.Context(), logger)
 	var path string
 	path, err = ssh.SshJump(ctx, sshConf, flags, false)
 	if err != nil {

pkg/daemon/action/sshdaemon.go

@@ -2,12 +2,11 @@ package action
 
 import (
 	"context"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"net"
 	"sync"
 
 	"github.com/containernetworking/cni/pkg/types"
-	log "github.com/sirupsen/logrus"
-
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/core"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
@@ -31,7 +30,7 @@ func (svr *Server) SshStart(ctx context.Context, req *rpc.SshStartRequest) (resp
 	var clientCIDR *net.IPNet
 	clientIP, clientCIDR, err = net.ParseCIDR(req.ClientIP)
 	if err != nil {
-		log.Errorf("Failed to parse network CIDR: %v", err)
+		plog.G(ctx).Errorf("Failed to parse network CIDR: %v", err)
 		return
 	}
 	if serverIP == "" {
@@ -54,7 +53,7 @@ func (svr *Server) SshStart(ctx context.Context, req *rpc.SshStartRequest) (resp
 		var servers []core.Server
 		servers, err = handler.Parse(r)
 		if err != nil {
-			log.Errorf("Failed to parse route: %v", err)
+			plog.G(ctx).Errorf("Failed to parse route: %v", err)
 			return
 		}
 		var ctx1 context.Context
@@ -62,7 +61,7 @@ func (svr *Server) SshStart(ctx context.Context, req *rpc.SshStartRequest) (resp
 		go func() {
 			err := handler.Run(ctx1, servers)
 			if err != nil {
-				log.Errorf("Failed to run route: %v", err)
+				plog.G(ctx).Errorf("Failed to run route: %v", err)
 			}
 		}()
 		serverIP = DefaultServerIP
@@ -86,7 +85,7 @@ func (svr *Server) SshStart(ctx context.Context, req *rpc.SshStartRequest) (resp
 		GW: nil,
 	})
 	if err != nil {
-		log.Errorf("Failed to add route: %v", err)
+		plog.G(ctx).Errorf("Failed to add route: %v", err)
 		return
 	}
 

pkg/daemon/action/stop.go

@@ -6,27 +6,19 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func (svr *Server) Stop(req *rpc.QuitRequest, resp rpc.Daemon_QuitServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newStopWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
-
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newStopWarp(resp), svr.LogFile))
+	ctx := plog.WithLogger(resp.Context(), logger)
 	if svr.connect == nil {
-		log.Info("No connect")
+		plog.G(ctx).Info("No connect")
 		return nil
 	}
 
-	svr.connect.Cleanup()
+	svr.connect.Cleanup(ctx)
 	svr.t = time.Time{}
 	svr.connect = nil
 	return nil

pkg/daemon/action/uninstall.go

@@ -6,22 +6,15 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 
-	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
 func (svr *Server) Uninstall(req *rpc.UninstallRequest, resp rpc.Daemon_UninstallServer) error {
-	defer func() {
-		util.InitLoggerForServer(true)
-		log.SetOutput(svr.LogFile)
-		config.Debug = false
-	}()
-	out := io.MultiWriter(newUninstallWarp(resp), svr.LogFile)
-	util.InitLoggerForClient(config.Debug)
-	log.SetOutput(out)
+	logger := plog.GetLoggerForClient(int32(log.InfoLevel), io.MultiWriter(newUninstallWarp(resp), svr.LogFile))
 
 	connect := &handler.ConnectOptions{
 		Namespace: req.Namespace,
@@ -38,7 +31,7 @@ func (svr *Server) Uninstall(req *rpc.UninstallRequest, resp rpc.Daemon_Uninstal
 		DefValue: file,
 	})
 	var sshConf = ssh.ParseSshFromRPC(req.SshJump)
-	var ctx = resp.Context()
+	var ctx = plog.WithLogger(resp.Context(), logger)
 	var path string
 	path, err = ssh.SshJump(ctx, sshConf, flags, false)
 	if err != nil {

pkg/daemon/action/upgrade.go

@@ -4,10 +4,10 @@ import (
 	"context"
 
 	goversion "github.com/hashicorp/go-version"
-	log "github.com/sirupsen/logrus"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func (svr *Server) Upgrade(ctx context.Context, req *rpc.UpgradeRequest) (*rpc.UpgradeResponse, error) {
@@ -22,7 +22,7 @@ func (svr *Server) Upgrade(ctx context.Context, req *rpc.UpgradeRequest) (*rpc.U
 		return nil, err
 	}
 	if clientVersion.GreaterThan(daemonVersion) {
-		log.Info("Daemon version is less than client, needs to upgrade")
+		plog.G(context.Background()).Info("Daemon version is less than client, needs to upgrade")
 		return &rpc.UpgradeResponse{NeedUpgrade: true}, nil
 	}
 	return &rpc.UpgradeResponse{NeedUpgrade: false}, nil

pkg/daemon/daemon.go

@@ -2,6 +2,7 @@ package daemon
 
 import (
 	"context"
+	golog "log"
 	"net"
 	"net/http"
 	"os"
@@ -27,7 +28,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/action"
 	_ "github.com/wencaiwulue/kubevpn/v2/pkg/daemon/handler"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
-	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 type SvrOption struct {
@@ -55,10 +56,11 @@ func (o *SvrOption) Start(ctx context.Context) error {
 	// c.LibDefaults.DNSLookupKDC = true
 	// c.LibDefaults.DNSLookupRealm = true
 
-	util.InitLoggerForServer(true)
 	log.SetOutput(l)
+	golog.Default().SetOutput(l)
 	klog.SetOutput(l)
 	klog.LogToStderr(false)
+	plog.L.SetOutput(l)
 	rest.SetDefaultWarningHandler(rest.NoWarnings{})
 	// every day 00:00:00 rotate log
 	go rotateLog(l, o.IsSudo)
@@ -93,7 +95,7 @@ func (o *SvrOption) Start(ctx context.Context) error {
 	svr := grpc.NewServer(unaryPanicInterceptor, streamPanicInterceptor)
 	cleanup, err := admin.Register(svr)
 	if err != nil {
-		log.Errorf("Failed to register admin: %v", err)
+		plog.G(ctx).Errorf("Failed to register admin: %v", err)
 		return err
 	}
 	grpc_health_v1.RegisterHealthServer(svr, health.NewServer())
@@ -108,7 +110,7 @@ func (o *SvrOption) Start(ctx context.Context) error {
 	var h2Server http2.Server
 	err = http2.ConfigureServer(downgradingServer, &h2Server)
 	if err != nil {
-		log.Errorf("Failed to configure http2: %v", err)
+		plog.G(ctx).Errorf("Failed to configure http2: %v", err)
 		return err
 	}
 	handler := CreateDowngradingHandler(svr, http.HandlerFunc(http.DefaultServeMux.ServeHTTP))

pkg/daemon/elevate/elevate_others.go

@@ -3,16 +3,17 @@
 package elevate
 
 import (
+	"context"
 	"flag"
 	"os"
 	"os/exec"
 	"runtime"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sys/unix"
 	"k8s.io/client-go/tools/clientcmd"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func RunCmdWithElevated(exe string, args []string) error {
@@ -24,7 +25,7 @@ func RunCmdWithElevated(exe string, args []string) error {
 		}
 	}
 	cmd := exec.Command("sudo", append([]string{"--preserve-env", "--background", exe}, args...)...)
-	log.Debug(cmd.Args)
+	plog.G(context.Background()).Debug(cmd.Args)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	cmd.Stdin = os.Stdin
@@ -52,7 +53,7 @@ func RunCmd(exe string, args []string) error {
 	cmd.SysProcAttr = &unix.SysProcAttr{
 		Setpgid: true,
 	}
-	log.Debug(cmd.Args)
+	plog.G(context.Background()).Debug(cmd.Args)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	cmd.Stdin = os.Stdin

pkg/daemon/elevate/elevate_windows.go

@@ -3,16 +3,17 @@
 package elevate
 
 import (
+	"context"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 	"syscall"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sys/windows"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // ref https://stackoverflow.com/questions/31558066/how-to-ask-for-administer-privileges-on-windows-with-go
@@ -47,7 +48,7 @@ func RunCmdWithElevated(exe string, arg []string) error {
 	os.Setenv(config.EnvDisableSyncthingLog, "1")
 	err = windows.ShellExecute(0, verbPtr, exePtr, argPtr, cwdPtr, showCmd)
 	if err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 	return err
 }
@@ -82,7 +83,7 @@ func RunCmd(exe string, arg []string) error {
 
 	err = windows.ShellExecute(0, verbPtr, exePtr, argPtr, cwdPtr, showCmd)
 	if err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 	return err
 }

pkg/daemon/elevate/elevatecheck_others.go

@@ -3,6 +3,7 @@
 package elevate
 
 import (
+	"context"
 	"flag"
 	"os"
 	"os/exec"
@@ -10,10 +11,10 @@ import (
 	"runtime"
 	"syscall"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/client-go/tools/clientcmd"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func RunWithElevated() {
@@ -25,7 +26,7 @@ func RunWithElevated() {
 		}
 	}
 	cmd := exec.Command("sudo", append([]string{"--preserve-env"}, os.Args...)...)
-	log.Debug(cmd.Args)
+	plog.G(context.Background()).Debug(cmd.Args)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	cmd.Stdin = os.Stdin
@@ -39,7 +40,7 @@ func RunWithElevated() {
 	}()
 	err := cmd.Run()
 	if err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 }
 

pkg/daemon/elevate/elevatecheck_windows.go

@@ -3,16 +3,17 @@
 package elevate
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"strings"
 	"syscall"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sys/windows"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // ref https://stackoverflow.com/questions/31558066/how-to-ask-for-administer-privileges-on-windows-with-go
@@ -32,7 +33,7 @@ func RunWithElevated() {
 	os.Setenv(config.EnvDisableSyncthingLog, "1")
 	err := windows.ShellExecute(0, verbPtr, exePtr, argPtr, cwdPtr, showCmd)
 	if err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 }
 

pkg/daemon/handler/ssh.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/containerd/containerd/platforms"
 	specs "github.com/opencontainers/image-spec/specs-go/v1"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/net/websocket"
 	"golang.org/x/oauth2"
@@ -29,6 +28,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/core"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -117,7 +117,7 @@ func (w *wsHandler) createTwoWayTUNTunnel(ctx context.Context, cli *ssh.Client)
 	cmd := fmt.Sprintf(`kubevpn ssh-daemon --client-ip %s`, clientIP.String())
 	serverIP, stderr, err := pkgssh.RemoteRun(cli, cmd, nil)
 	if err != nil {
-		log.Errorf("Failed to run remote command: %v, stdout: %s, stderr: %s", err, string(serverIP), string(stderr))
+		plog.G(ctx).Errorf("Failed to run remote command: %v, stdout: %s, stderr: %s", err, string(serverIP), string(stderr))
 		w.Log("Start kubevpn server error: %v", err)
 		return err
 	}
@@ -138,16 +138,16 @@ func (w *wsHandler) createTwoWayTUNTunnel(ctx context.Context, cli *ssh.Client)
 	}
 	servers, err := handler.Parse(r)
 	if err != nil {
-		log.Errorf("Failed to parse route: %v", err)
+		plog.G(ctx).Errorf("Failed to parse route: %v", err)
 		w.Log("Failed to parse route: %v", err)
 		return err
 	}
 	go func() {
 		err := handler.Run(ctx, servers)
-		log.Errorf("Failed to run: %v", err)
+		plog.G(ctx).Errorf("Failed to run: %v", err)
 		w.Log("Failed to run: %v", err)
 	}()
-	log.Info("Connected tunnel")
+	plog.G(ctx).Info("Connected tunnel")
 	go func() {
 		for ctx.Err() == nil {
 			util.Ping(ctx, clientIP.IP.String(), ip.String())
@@ -280,7 +280,7 @@ func (w *wsHandler) installKubevpnOnRemote(ctx context.Context, sshClient *ssh.C
 		w.Log("Found command kubevpn command on remote")
 		return nil
 	}
-	log.Infof("Install command kubevpn...")
+	plog.G(ctx).Infof("Install command kubevpn...")
 	w.Log("Install kubevpn on remote server...")
 	var client = http.DefaultClient
 	if config.GitHubOAuthToken != "" {
@@ -328,13 +328,13 @@ func (w *wsHandler) installKubevpnOnRemote(ctx context.Context, sshClient *ssh.C
 	if err != nil {
 		return err
 	}
-	log.Infof("Upgrade daemon...")
+	plog.G(ctx).Infof("Upgrade daemon...")
 	w.Log("Scp kubevpn to remote server ~/.kubevpn/kubevpn")
 	cmds := []string{
 		"chmod +x ~/.kubevpn/kubevpn",
 		"sudo mv ~/.kubevpn/kubevpn /usr/local/bin/kubevpn",
 	}
-	err = pkgssh.SCPAndExec(w.conn, w.conn, sshClient, tempBin.Name(), "kubevpn", cmds...)
+	err = pkgssh.SCPAndExec(ctx, w.conn, w.conn, sshClient, tempBin.Name(), "kubevpn", cmds...)
 	return err
 }
 
@@ -344,7 +344,7 @@ func (w *wsHandler) Log(format string, a ...any) {
 		str = fmt.Sprintf(format, a...)
 	}
 	w.conn.Write([]byte(str + "\r\n"))
-	log.Infof(format, a...)
+	plog.G(context.Background()).Infof(format, a...)
 }
 
 func (w *wsHandler) PrintLine(msg string) {
@@ -397,7 +397,7 @@ func init() {
 	}))
 	http.Handle("/resize", websocket.Handler(func(conn *websocket.Conn) {
 		sessionID := conn.Request().Header.Get("session-id")
-		log.Infof("Resize: %s", sessionID)
+		plog.G(context.Background()).Infof("Resize: %s", sessionID)
 
 		defer conn.Close()
 
@@ -422,21 +422,21 @@ func init() {
 			if errors.Is(err, io.EOF) {
 				return
 			} else if err != nil {
-				log.Errorf("Failed to read session %s window resize event: %v", sessionID, err)
+				plog.G(context.Background()).Errorf("Failed to read session %s window resize event: %v", sessionID, err)
 				return
 			}
 			var r remotecommand.TerminalSize
 			err = json.Unmarshal([]byte(readString), &r)
 			if err != nil {
-				log.Errorf("Unmarshal into terminal size failed: %v", err)
+				plog.G(context.Background()).Errorf("Unmarshal into terminal size failed: %v", err)
 				continue
 			}
-			log.Debugf("Session %s change termianl size to w: %d h:%d", sessionID, r.Width, r.Height)
+			plog.G(context.Background()).Debugf("Session %s change termianl size to w: %d h:%d", sessionID, r.Width, r.Height)
 			err = session.WindowChange(int(r.Height), int(r.Width))
 			if errors.Is(err, io.EOF) {
 				return
 			} else if err != nil {
-				log.Errorf("Session %s windos change w: %d h: %d failed: %v", sessionID, r.Width, r.Height, err)
+				plog.G(context.Background()).Errorf("Session %s windos change w: %d h: %d failed: %v", sessionID, r.Width, r.Height, err)
 			}
 		}
 	}))

pkg/daemon/rpc/panicinterceptor.go

@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"runtime/debug"
 
-	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 var _ grpc.UnaryServerInterceptor = UnaryPanicHandler
@@ -19,7 +20,7 @@ func UnaryPanicHandler(ctx context.Context, req any, info *grpc.UnaryServerInfo,
 		if r := recover(); r != nil {
 			str := fmt.Sprintf("Panic: `%s` %s", info.FullMethod, string(debug.Stack()))
 			err = status.Error(codes.Internal, str)
-			logrus.Panic(str)
+			plog.G(context.Background()).Panic(str)
 		}
 	}()
 	return handler(ctx, req)
@@ -30,7 +31,7 @@ func StreamPanicHandler(srv any, ss grpc.ServerStream, info *grpc.StreamServerIn
 		if r := recover(); r != nil {
 			str := fmt.Sprintf("Panic: `%s` %s", info.FullMethod, string(debug.Stack()))
 			err = status.Error(codes.Internal, str)
-			logrus.Panic(str)
+			plog.G(context.Background()).Panic(str)
 		}
 	}()
 	return handler(srv, ss)

pkg/dev/docker_utils.go

@@ -14,10 +14,10 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stdcopy"
-	log "github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // Pull constants
@@ -136,17 +136,17 @@ func RunContainer(ctx context.Context, runConfig *RunConfig) error {
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
-	log.Debugf("Run container with cmd: %v", cmd.Args)
+	plog.G(ctx).Debugf("Run container with cmd: %v", cmd.Args)
 	err := cmd.Start()
 	if err != nil {
-		log.Errorf("Failed to run container with cmd: %v: %v", cmd.Args, err)
+		plog.G(ctx).Errorf("Failed to run container with cmd: %v: %v", cmd.Args, err)
 		return err
 	}
 	return cmd.Wait()
 }
 
 func WaitDockerContainerRunning(ctx context.Context, name string) error {
-	log.Infof("Wait container %s to be running...", name)
+	plog.G(ctx).Infof("Wait container %s to be running...", name)
 
 	for ctx.Err() == nil {
 		time.Sleep(time.Second * 1)
@@ -163,14 +163,14 @@ func WaitDockerContainerRunning(ctx context.Context, name string) error {
 		}
 	}
 
-	log.Infof("Container %s is running now", name)
+	plog.G(ctx).Infof("Container %s is running now", name)
 	return nil
 }
 
 func ContainerInspect(ctx context.Context, name string) (types.ContainerJSON, error) {
 	output, err := exec.CommandContext(ctx, "docker", "inspect", name).CombinedOutput()
 	if err != nil {
-		log.Errorf("Failed to wait container to be ready output: %s: %v", string(output), err)
+		plog.G(ctx).Errorf("Failed to wait container to be ready output: %s: %v", string(output), err)
 		_ = RunLogsSinceNow(name, false)
 		return types.ContainerJSON{}, err
 	}
@@ -192,7 +192,7 @@ func NetworkInspect(ctx context.Context, name string) (types.NetworkResource, er
 	//cli.NetworkInspect()
 	output, err := exec.CommandContext(ctx, "docker", "network", "inspect", name).CombinedOutput()
 	if err != nil {
-		log.Errorf("Failed to wait container to be ready: %v", err)
+		plog.G(ctx).Errorf("Failed to wait container to be ready: %v", err)
 		_ = RunLogsSinceNow(name, false)
 		return types.NetworkResource{}, err
 	}

pkg/dev/options.go

@@ -25,6 +25,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/handler"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgssh "github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -64,13 +65,13 @@ type Options struct {
 func (option *Options) Main(ctx context.Context, sshConfig *pkgssh.SshConfig, config *Config, hostConfig *HostConfig, imagePullSecretName string) error {
 	mode := typescontainer.NetworkMode(option.ContainerOptions.netMode.NetworkMode())
 	if mode.IsContainer() {
-		log.Infof("Network mode container is %s", mode.ConnectedContainer())
+		plog.G(ctx).Infof("Network mode container is %s", mode.ConnectedContainer())
 	} else if mode.IsDefault() && util.RunningInContainer() {
 		hostname, err := os.Hostname()
 		if err != nil {
 			return err
 		}
-		log.Infof("Hostname is %s", hostname)
+		plog.G(ctx).Infof("Hostname is %s", hostname)
 		err = option.ContainerOptions.netMode.Set(fmt.Sprintf("container:%s", hostname))
 		if err != nil {
 			return err
@@ -80,7 +81,7 @@ func (option *Options) Main(ctx context.Context, sshConfig *pkgssh.SshConfig, co
 	// Connect to cluster, in container or host
 	err := option.Connect(ctx, sshConfig, imagePullSecretName, hostConfig.PortBindings)
 	if err != nil {
-		log.Errorf("Connect to cluster failed, err: %v", err)
+		plog.G(ctx).Errorf("Connect to cluster failed, err: %v", err)
 		return err
 	}
 
@@ -103,10 +104,6 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 				option.ExtraRouteInfo.ExtraCIDR = append(option.ExtraRouteInfo.ExtraCIDR, ip.String())
 			}
 		}
-		logLevel := log.InfoLevel
-		if config.Debug {
-			logLevel = log.DebugLevel
-		}
 		// not needs to ssh jump in daemon, because dev mode will hang up until user exit,
 		// so just ssh jump in client is enough
 		req := &rpc.ConnectRequest{
@@ -119,7 +116,7 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 			OriginKubeconfigPath: util.GetKubeConfigPath(option.factory),
 			Image:                config.Image,
 			ImagePullSecretName:  imagePullSecretName,
-			Level:                int32(logLevel),
+			Level:                int32(util.If(config.Debug, log.DebugLevel, log.InfoLevel)),
 			SshJump:              sshConfig.ToRPC(),
 		}
 		option.AddRollbackFunc(func() error {
@@ -137,7 +134,7 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 		var resp rpc.Daemon_ConnectClient
 		resp, err = daemonCli.Proxy(ctx, req)
 		if err != nil {
-			log.Errorf("Connect to cluster error: %s", err.Error())
+			plog.G(ctx).Errorf("Connect to cluster error: %s", err.Error())
 			return err
 		}
 		err = util.PrintGRPCStream[rpc.CloneResponse](resp)
@@ -149,7 +146,7 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 		if err != nil {
 			return err
 		}
-		log.Infof("Starting connect to cluster in container")
+		plog.G(ctx).Infof("Starting connect to cluster in container")
 		err = WaitDockerContainerRunning(ctx, *name)
 		if err != nil {
 			return err
@@ -168,7 +165,7 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 			}
 			return err
 		}
-		log.Infof("Connected to cluster in container")
+		plog.G(ctx).Infof("Connected to cluster in container")
 		err = option.ContainerOptions.netMode.Set(fmt.Sprintf("container:%s", *name))
 		return err
 	}
@@ -179,7 +176,7 @@ func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig,
 func (option *Options) Dev(ctx context.Context, config *Config, hostConfig *HostConfig) error {
 	templateSpec, err := option.GetPodTemplateSpec()
 	if err != nil {
-		log.Errorf("Failed to get unstructured object error: %v", err)
+		plog.G(ctx).Errorf("Failed to get unstructured object error: %v", err)
 		return err
 	}
 
@@ -187,13 +184,13 @@ func (option *Options) Dev(ctx context.Context, config *Config, hostConfig *Host
 	var list []v1.Pod
 	list, err = util.GetRunningPodList(ctx, option.clientset, option.Namespace, label)
 	if err != nil {
-		log.Errorf("Failed to get first running pod from k8s: %v", err)
+		plog.G(ctx).Errorf("Failed to get first running pod from k8s: %v", err)
 		return err
 	}
 
 	env, err := util.GetEnv(ctx, option.clientset, option.config, option.Namespace, list[0].Name)
 	if err != nil {
-		log.Errorf("Failed to get env from k8s: %v", err)
+		plog.G(ctx).Errorf("Failed to get env from k8s: %v", err)
 		return err
 	}
 	option.AddRollbackFunc(func() error {
@@ -204,7 +201,7 @@ func (option *Options) Dev(ctx context.Context, config *Config, hostConfig *Host
 	})
 	volume, err := util.GetVolume(ctx, option.clientset, option.factory, option.Namespace, list[0].Name)
 	if err != nil {
-		log.Errorf("Failed to get volume from k8s: %v", err)
+		plog.G(ctx).Errorf("Failed to get volume from k8s: %v", err)
 		return err
 	}
 	option.AddRollbackFunc(func() error {
@@ -212,7 +209,7 @@ func (option *Options) Dev(ctx context.Context, config *Config, hostConfig *Host
 	})
 	dns, err := util.GetDNS(ctx, option.clientset, option.config, option.Namespace, list[0].Name)
 	if err != nil {
-		log.Errorf("Failed to get DNS from k8s: %v", err)
+		plog.G(ctx).Errorf("Failed to get DNS from k8s: %v", err)
 		return err
 	}
 	configList, err := option.ConvertPodToContainerConfigList(ctx, *templateSpec, config, hostConfig, env, volume, dns)
@@ -319,7 +316,7 @@ func (option *Options) GetRollbackFuncList() []func() error {
 func (option *Options) GetExposePort(portBinds nat.PortMap) (nat.PortMap, nat.PortSet, error) {
 	templateSpec, err := option.GetPodTemplateSpec()
 	if err != nil {
-		log.Errorf("Failed to get unstructured object error: %v", err)
+		plog.G(context.Background()).Errorf("Failed to get unstructured object error: %v", err)
 		return nil, nil, err
 	}
 

pkg/dev/runconfig.go

@@ -13,12 +13,12 @@ import (
 	"github.com/docker/go-connections/nat"
 	"github.com/google/uuid"
 	"github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/utils/ptr"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -42,12 +42,12 @@ func (l ConfigList) Remove(ctx context.Context, userAnotherContainerNet bool) er
 		if !userAnotherContainerNet && index == len(l)-1 {
 			output, err := NetworkDisconnect(ctx, runConfig.name)
 			if err != nil {
-				log.Warnf("Failed to disconnect container network: %s: %v", string(output), err)
+				plog.G(ctx).Warnf("Failed to disconnect container network: %s: %v", string(output), err)
 			}
 		}
 		output, err := ContainerRemove(ctx, runConfig.name)
 		if err != nil {
-			log.Warnf("Failed to remove container: %s: %v", string(output), err)
+			plog.G(ctx).Warnf("Failed to remove container: %s: %v", string(output), err)
 		}
 	}
 	name := config.ConfigMapPodTrafficManager
@@ -192,17 +192,17 @@ func (option *Options) ConvertPodToContainerConfigList(
 				}
 				_, err = CreateNetwork(ctx, config.ConfigMapPodTrafficManager)
 				if err != nil {
-					log.Errorf("Failed to create network: %v", err)
+					plog.G(ctx).Errorf("Failed to create network: %v", err)
 					return nil, err
 				}
-				log.Infof("Create docker network %s", config.ConfigMapPodTrafficManager)
+				plog.G(ctx).Infof("Create docker network %s", config.ConfigMapPodTrafficManager)
 				options = append(options, "--network", config.ConfigMapPodTrafficManager)
 			} else { // set 0 to last-1 container to use last container network
 				options = append(options, "--network", util.ContainerNet(lastContainerRandomName))
 				options = append(options, "--pid", util.ContainerNet(lastContainerRandomName))
 			}
 		} else { // set all containers to use network mode
-			log.Infof("Network mode is %s", option.ContainerOptions.netMode.NetworkMode())
+			plog.G(ctx).Infof("Network mode is %s", option.ContainerOptions.netMode.NetworkMode())
 			options = append(options, "--network", option.ContainerOptions.netMode.NetworkMode())
 			if typescontainer.NetworkMode(option.ContainerOptions.netMode.NetworkMode()).IsContainer() {
 				options = append(options, "--pid", option.ContainerOptions.netMode.NetworkMode())

pkg/dhcp/dhcp.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"encoding/base64"
 	"fmt"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"net"
 
 	"github.com/cilium/ipam/service/allocator"
 	"github.com/cilium/ipam/service/ipallocator"
-	log "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -65,7 +65,7 @@ func (m *Manager) InitDHCP(ctx context.Context) error {
 	}
 	cm, err = m.client.Create(ctx, cm, metav1.CreateOptions{})
 	if err != nil {
-		return fmt.Errorf("create DHCP error, err: %v", err)
+		return fmt.Errorf("failed to create configmap: %v", err)
 	}
 	m.clusterID = util.GetClusterIDByCM(cm)
 	return nil
@@ -107,7 +107,7 @@ func (m *Manager) RentIP(ctx context.Context) (*net.IPNet, *net.IPNet, error) {
 		return
 	})
 	if err != nil {
-		log.Errorf("Failed to rent IP from DHCP server, err: %v", err)
+		plog.G(ctx).Errorf("Failed to rent IP from DHCP server: %v", err)
 		return nil, nil, err
 	}
 	return &net.IPNet{IP: v4, Mask: m.cidr.Mask}, &net.IPNet{IP: v6, Mask: m.cidr6.Mask}, nil
@@ -191,7 +191,7 @@ func (m *Manager) updateDHCPConfigMap(ctx context.Context, f func(ipv4 *ipalloca
 	cm.Data[config.KeyDHCP6] = base64.StdEncoding.EncodeToString(bytes)
 	_, err = m.client.Update(ctx, cm, metav1.UpdateOptions{})
 	if err != nil {
-		return fmt.Errorf("update DHCP failed, err: %v", err)
+		return fmt.Errorf("failed to update DHCP: %v", err)
 	}
 	return nil
 }
@@ -205,7 +205,7 @@ func (m *Manager) Set(ctx context.Context, key, value string) error {
 			return err
 		})
 	if err != nil {
-		log.Errorf("Failed to update configmap: %v", err)
+		plog.G(ctx).Errorf("Failed to update configmap: %v", err)
 		return err
 	}
 	return nil

pkg/dhcp/server.go

@@ -5,10 +5,10 @@ import (
 	"net"
 	"sync"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/client-go/kubernetes"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dhcp/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 type Server struct {
@@ -28,12 +28,12 @@ func (s *Server) RentIP(ctx context.Context, req *rpc.RentIPRequest) (*rpc.RentI
 	s.Lock()
 	defer s.Unlock()
 
-	log.Infof("Handling rent IP request, pod name: %s, ns: %s", req.PodName, req.PodNamespace)
+	plog.G(ctx).Infof("Handling rent IP request, pod name: %s, ns: %s", req.PodName, req.PodNamespace)
 	cmi := s.clientset.CoreV1().ConfigMaps(req.PodNamespace)
 	manager := NewDHCPManager(cmi, req.PodNamespace)
 	v4, v6, err := manager.RentIP(ctx)
 	if err != nil {
-		log.Errorf("Failed to rent IP: %v", err)
+		plog.G(ctx).Errorf("Failed to rent IP: %v", err)
 		return nil, err
 	}
 	// todo patch annotation
@@ -48,12 +48,12 @@ func (s *Server) ReleaseIP(ctx context.Context, req *rpc.ReleaseIPRequest) (*rpc
 	s.Lock()
 	defer s.Unlock()
 
-	log.Infof("Handling release IP request, pod name: %s, ns: %s, IPv4: %s, IPv6: %s", req.PodName, req.PodNamespace, req.IPv4CIDR, req.IPv6CIDR)
+	plog.G(ctx).Infof("Handling release IP request, pod name: %s, ns: %s, IPv4: %s, IPv6: %s", req.PodName, req.PodNamespace, req.IPv4CIDR, req.IPv6CIDR)
 	var ips []net.IP
 	for _, ipStr := range []string{req.IPv4CIDR, req.IPv6CIDR} {
 		ip, _, err := net.ParseCIDR(ipStr)
 		if err != nil {
-			log.Errorf("IP %s is invailed, err: %v", ipStr, err)
+			plog.G(ctx).Errorf("IP %s is invailed: %v", ipStr, err)
 			continue
 		}
 		ips = append(ips, ip)
@@ -62,7 +62,7 @@ func (s *Server) ReleaseIP(ctx context.Context, req *rpc.ReleaseIPRequest) (*rpc
 	cmi := s.clientset.CoreV1().ConfigMaps(req.PodNamespace)
 	manager := NewDHCPManager(cmi, req.PodNamespace)
 	if err := manager.ReleaseIP(ctx, ips...); err != nil {
-		log.Errorf("Failed to release IP: %v", err)
+		plog.G(ctx).Errorf("Failed to release IP: %v", err)
 		return nil, err
 	}
 	return &rpc.ReleaseIPResponse{}, nil

pkg/dns/dns.go

@@ -16,7 +16,6 @@ import (
 
 	miekgdns "github.com/miekg/dns"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	v12 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -27,6 +26,7 @@ import (
 	"tailscale.com/net/dns"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -67,7 +67,7 @@ func (c *Config) AddServiceNameToHosts(ctx context.Context, serviceInterface v13
 	appendHosts := c.generateAppendHosts(serviceList, hosts)
 	err := c.appendHosts(appendHosts)
 	if err != nil {
-		log.Errorf("Failed to add hosts(%s): %v", entryList2String(appendHosts), err)
+		plog.G(ctx).Errorf("Failed to add hosts(%s): %v", entryList2String(appendHosts), err)
 		return err
 	}
 
@@ -114,7 +114,7 @@ func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v1
 						}}
 						err = c.removeHosts(list)
 						if err != nil {
-							log.Errorf("Failed to remove hosts(%s) to hosts: %v", entryList2String(list), err)
+							plog.G(ctx).Errorf("Failed to remove hosts(%s) to hosts: %v", entryList2String(list), err)
 						}
 					}
 					if event.Type == watch.Added {
@@ -123,7 +123,7 @@ func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v1
 						err = c.appendHosts(appendHosts)
 						c.Lock.Unlock()
 						if err != nil {
-							log.Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
+							plog.G(ctx).Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
 						}
 					}
 				case <-ticker.C:
@@ -137,7 +137,7 @@ func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v1
 					err = c.appendHosts(appendHosts)
 					c.Lock.Unlock()
 					if err != nil {
-						log.Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
+						plog.G(ctx).Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
 					}
 				case <-immediate:
 					var list *v12.ServiceList
@@ -150,7 +150,7 @@ func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v1
 					err = c.appendHosts(appendHosts)
 					c.Lock.Unlock()
 					if err != nil {
-						log.Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
+						plog.G(ctx).Errorf("Failed to add hosts(%s) to hosts: %v", entryList2String(appendHosts), err)
 					}
 				}
 			}
@@ -159,7 +159,7 @@ func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v1
 			return
 		}
 		if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, ErrChanDone) {
-			log.Debugf("Failed to watch service to add route table: %v", err)
+			plog.G(ctx).Debugf("Failed to watch service to add route table: %v", err)
 		}
 		if utilnet.IsConnectionRefused(err) || apierrors.IsTooManyRequests(err) || apierrors.IsForbidden(err) {
 			time.Sleep(time.Second * 1)
@@ -243,7 +243,7 @@ func (c *Config) removeHosts(hosts []Entry) error {
 	}
 
 	if len(retain) == 0 {
-		log.Errorf("Hosts files retain line is empty, should not happened")
+		plog.G(context.Background()).Errorf("Hosts files retain line is empty, should not happened")
 		return nil
 	}
 

pkg/dns/dns_linux.go

@@ -18,10 +18,11 @@ import (
 	_ "github.com/coredns/coredns/core/plugin"
 	"github.com/docker/docker/libnetwork/resolvconf"
 	miekgdns "github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"tailscale.com/net/dns"
 	"tailscale.com/util/dnsname"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // SetupDNS
@@ -31,24 +32,24 @@ func (c *Config) SetupDNS(ctx context.Context) error {
 	tunName := c.TunName
 
 	// 1) setup dns by magicDNS
-	log.Debugf("Use library to setup DNS...")
+	plog.G(ctx).Debugf("Use library to setup DNS...")
 	// https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#default-environment-variables
 	if _, found := os.LookupEnv("GITHUB_ACTIONS"); !found {
 		err := c.UseLibraryDNS(tunName, config)
 		if err == nil {
-			log.Debugf("Use library to setup DNS done")
+			plog.G(ctx).Debugf("Use library to setup DNS done")
 			return nil
 		} else if errors.Is(err, ErrorNotSupportSplitDNS) {
-			log.Debugf("Library not support on current OS")
+			plog.G(ctx).Debugf("Library not support on current OS")
 			err = nil
 		} else {
-			log.Errorf("Setup DNS by library failed: %v", err)
+			plog.G(ctx).Errorf("Setup DNS by library failed: %v", err)
 			err = nil
 		}
 	}
 
 	// 2) use systemctl or resolvectl to setup dns
-	log.Debugf("Use systemd to setup DNS...")
+	plog.G(ctx).Debugf("Use systemd to setup DNS...")
 	// TODO consider use https://wiki.debian.org/NetworkManager and nmcli to config DNS
 	// try to solve:
 	// sudo systemd-resolve --set-dns 172.28.64.10 --interface tun0 --set-domain=vke-system.svc.cluster.local --set-domain=svc.cluster.local --set-domain=cluster.local
@@ -60,13 +61,13 @@ func (c *Config) SetupDNS(ctx context.Context) error {
 	_ = exec.Command("systemctl", "start", "systemd-resolved.service").Run()
 	//systemctl status systemd-resolved.service
 	_ = exec.Command("systemctl", "status", "systemd-resolved.service").Run()
-	log.Debugf("Enable service systemd resolved...")
+	plog.G(ctx).Debugf("Enable service systemd resolved...")
 	var exists = func(cmd string) bool {
 		_, err := exec.LookPath(cmd)
 		return err == nil
 	}
 	var success bool
-	log.Debugf("Try to setup DNS by resolvectl or systemd-resolve...")
+	plog.G(ctx).Debugf("Try to setup DNS by resolvectl or systemd-resolve...")
 	if exists("resolvectl") {
 		if setupDnsByCmdResolvectl(ctx, tunName, config) == nil {
 			success = true
@@ -82,7 +83,7 @@ func (c *Config) SetupDNS(ctx context.Context) error {
 	}
 
 	// 3) write dns info to file: /etc/resolv.conf
-	log.Debugf("Use resolv.conf to setup DNS...")
+	plog.G(ctx).Debugf("Use resolv.conf to setup DNS...")
 	filename := resolvconf.Path()
 	readFile, err := os.ReadFile(filename)
 	if err != nil {
@@ -104,13 +105,13 @@ func setupDnsByCmdResolvectl(ctx context.Context, tunName string, config *miekgd
 	cmd := exec.CommandContext(ctx, "resolvectl", "dns", tunName, config.Servers[0])
 	output, err := cmd.CombinedOutput()
 	if err != nil {
-		log.Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
+		plog.G(ctx).Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
 		return err
 	}
 	cmd = exec.CommandContext(ctx, "resolvectl", "domain", tunName, config.Search[0], config.Search[1], config.Search[2])
 	output, err = cmd.CombinedOutput()
 	if err != nil {
-		log.Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
+		plog.G(ctx).Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
 		return err
 	}
 	return nil
@@ -128,7 +129,7 @@ func setupDNSbyCmdSystemdResolve(ctx context.Context, tunName string, config *mi
 	}...)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
-		log.Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
+		plog.G(ctx).Debugf("Failed to exec cmd '%s': %s", strings.Join(cmd.Args, " "), string(output))
 	}
 	return err
 }
@@ -136,7 +137,7 @@ func setupDNSbyCmdSystemdResolve(ctx context.Context, tunName string, config *mi
 var ErrorNotSupportSplitDNS = errors.New("not support split DNS")
 
 func (c *Config) UseLibraryDNS(tunName string, clientConfig *miekgdns.ClientConfig) error {
-	configurator, err := dns.NewOSConfigurator(log.Debugf, nil, nil, tunName)
+	configurator, err := dns.NewOSConfigurator(plog.G(context.Background()).Debugf, nil, nil, tunName)
 	if err != nil {
 		return err
 	}
@@ -159,7 +160,7 @@ func (c *Config) UseLibraryDNS(tunName string, clientConfig *miekgdns.ClientConf
 		}
 		config.SearchDomains = append(config.SearchDomains, fqdn)
 	}
-	log.Debugf("Setting up DNS...")
+	plog.G(context.Background()).Debugf("Setting up DNS...")
 	return c.OSConfigurator.SetDNS(config)
 }
 
@@ -172,7 +173,7 @@ func SetupLocalDNS(ctx context.Context, clientConfig *miekgdns.ClientConfig, exi
 		return err
 	}
 
-	log.Debugf("Corefile content: %s", string(corefile.Body()))
+	plog.G(ctx).Debugf("Corefile content: %s", string(corefile.Body()))
 
 	// Start your engines
 	instance, err := caddy.Start(corefile)
@@ -213,7 +214,7 @@ func (c *Config) CancelDNS() {
 	}
 	err = WriteResolvConf(resolvconf.Path(), *resolvConf)
 	if err != nil {
-		log.Warnf("Failed to remove DNS from resolv conf file: %v", err)
+		plog.G(context.Background()).Warnf("Failed to remove DNS from resolv conf file: %v", err)
 	}
 }
 

pkg/dns/dns_unix.go

@@ -6,6 +6,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -14,7 +15,6 @@ import (
 
 	"github.com/fsnotify/fsnotify"
 	miekgdns "github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
 	v12 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 )
@@ -42,10 +42,10 @@ func (c *Config) usingResolver(ctx context.Context) {
 	path := "/etc/resolver"
 	if _, err := os.Stat(path); os.IsNotExist(err) {
 		if err = os.MkdirAll(path, 0755); err != nil {
-			log.Errorf("Create resolver error: %v", err)
+			plog.G(ctx).Errorf("Create resolver error: %v", err)
 		}
 		if err = os.Chmod(path, 0755); err != nil {
-			log.Errorf("Chmod resolver error: %v", err)
+			plog.G(ctx).Errorf("Chmod resolver error: %v", err)
 		}
 	}
 	newConfig := miekgdns.ClientConfig{
@@ -62,21 +62,21 @@ func (c *Config) usingResolver(ctx context.Context) {
 			continue
 		}
 		if err != nil {
-			log.Errorf("Failed to read resovler %s error: %v", filename, err)
+			plog.G(ctx).Errorf("Failed to read resovler %s error: %v", filename, err)
 			continue
 		}
 
 		var conf *miekgdns.ClientConfig
 		conf, err = miekgdns.ClientConfigFromReader(bytes.NewBufferString(string(content)))
 		if err != nil {
-			log.Errorf("Parse resolver %s error: %v", filename, err)
+			plog.G(ctx).Errorf("Parse resolver %s error: %v", filename, err)
 			continue
 		}
 		// insert current name server to first location
 		conf.Servers = append([]string{clientConfig.Servers[0]}, conf.Servers...)
 		err = os.WriteFile(filename, []byte(toString(*conf)), 0644)
 		if err != nil {
-			log.Errorf("Failed to write resovler %s error: %v", filename, err)
+			plog.G(ctx).Errorf("Failed to write resovler %s error: %v", filename, err)
 		}
 	}
 }
@@ -188,7 +188,7 @@ func (c *Config) CancelDNS() {
 		}
 		err = os.WriteFile(filename, []byte(toString(*conf)), 0644)
 		if err != nil {
-			log.Errorf("Failed to write resovler %s error: %v", filename, err)
+			plog.G(context.Background()).Errorf("Failed to write resovler %s error: %v", filename, err)
 		}
 	}
 	//networkCancel()
@@ -267,7 +267,7 @@ func networkSetup(ip string, namespace string) {
 			args := []string{"-setdnsservers", s}
 			output, err = exec.Command("networksetup", append(args, nameservers...)...).Output()
 			if err != nil {
-				log.Warnf("Failed to set DNS server for %s, err: %v, output: %s\n", s, err, string(output))
+				plog.G(context.Background()).Warnf("Failed to set DNS server for %s, err: %v, output: %s\n", s, err, string(output))
 			}
 		}
 		output, err = exec.Command("networksetup", "-getsearchdomains", s).Output()
@@ -287,7 +287,7 @@ func networkSetup(ip string, namespace string) {
 			args := []string{"-setsearchdomains", s}
 			bytes, err := exec.Command("networksetup", append(args, newSearchDomains...)...).Output()
 			if err != nil {
-				log.Warnf("Failed to set search domain for %s, err: %v, output: %s\n", s, err, string(bytes))
+				plog.G(context.Background()).Warnf("Failed to set search domain for %s, err: %v, output: %s\n", s, err, string(bytes))
 			}
 		}
 	}
@@ -306,7 +306,7 @@ func networkCancel() {
 			if i[1] == "svc.cluster.local" && i[2] == "cluster.local" {
 				bytes, err := exec.Command("networksetup", "-setsearchdomains", s, strings.Join(i[3:], " ")).Output()
 				if err != nil {
-					log.Warnf("Failed to remove search domain for %s, err: %v, output: %s\n", s, err, string(bytes))
+					plog.G(context.Background()).Warnf("Failed to remove search domain for %s, err: %v, output: %s\n", s, err, string(bytes))
 				}
 
 				output, err := exec.Command("networksetup", "-getdnsservers", s).Output()
@@ -322,7 +322,7 @@ func networkCancel() {
 					args := []string{"-setdnsservers", s}
 					combinedOutput, err := exec.Command("networksetup", append(args, dnsServers...)...).Output()
 					if err != nil {
-						log.Warnf("Failed to remove DNS server for %s, err: %v, output: %s", s, err, string(combinedOutput))
+						plog.G(context.Background()).Warnf("Failed to remove DNS server for %s, err: %v, output: %s", s, err, string(combinedOutput))
 					}
 				}
 			}

pkg/dns/dns_windows.go

@@ -9,10 +9,11 @@ import (
 	"net/netip"
 	"os/exec"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sys/windows"
 	"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
 	"k8s.io/apimachinery/pkg/util/sets"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func (c *Config) SetupDNS(ctx context.Context) error {
@@ -32,19 +33,19 @@ func (c *Config) SetupDNS(ctx context.Context) error {
 		var addr netip.Addr
 		addr, err = netip.ParseAddr(s)
 		if err != nil {
-			log.Errorf("Parse %s failed: %s", s, err)
+			plog.G(ctx).Errorf("Parse %s failed: %s", s, err)
 			return err
 		}
 		servers = append(servers, addr.Unmap())
 	}
 	err = luid.SetDNS(windows.AF_INET, servers, clientConfig.Search)
 	if err != nil {
-		log.Errorf("Set DNS failed: %s", err)
+		plog.G(ctx).Errorf("Set DNS failed: %s", err)
 		return err
 	}
 	err = luid.SetDNS(windows.AF_INET6, servers, clientConfig.Search)
 	if err != nil {
-		log.Errorf("Set DNS failed: %s", err)
+		plog.G(ctx).Errorf("Set DNS failed: %s", err)
 		return err
 	}
 	//_ = updateNicMetric(tunName)
@@ -78,7 +79,7 @@ func updateNicMetric(name string) error {
 	}...)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		log.Warnf("Failed to update nic metrics, error: %v, output: %s, command: %v", err, string(out), cmd.Args)
+		plog.G(context.Background()).Warnf("Failed to update nic metrics, error: %v, output: %s, command: %v", err, string(out), cmd.Args)
 	}
 	return err
 }
@@ -91,9 +92,9 @@ func addNicSuffixSearchList(search []string) error {
 		fmt.Sprintf("@(\"%s\", \"%s\", \"%s\")", search[0], search[1], search[2]),
 	}...)
 	output, err := cmd.CombinedOutput()
-	log.Debugln(cmd.Args)
+	plog.G(context.Background()).Debugln(cmd.Args)
 	if err != nil {
-		log.Warnf("Failed to set DNS suffix search list, err: %v, output: %s, command: %v", err, string(output), cmd.Args)
+		plog.G(context.Background()).Warnf("Failed to set DNS suffix search list, err: %v, output: %s, command: %v", err, string(output), cmd.Args)
 	}
 	return err
 }

pkg/dns/forwardserver.go

@@ -9,10 +9,11 @@ import (
 	"time"
 
 	miekgdns "github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sync/semaphore"
 	"golang.org/x/time/rate"
 	"k8s.io/apimachinery/pkg/util/cache"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 var (
@@ -59,7 +60,7 @@ func (s *server) ServeDNS(w miekgdns.ResponseWriter, m *miekgdns.Msg) {
 	err := s.fwdSem.Acquire(ctx, 1)
 	if err != nil {
 		s.logInterval.Do(func() {
-			log.Errorf("DNS server more than %v concurrent queries", maxConcurrent)
+			plog.G(ctx).Errorf("DNS server more than %v concurrent queries", maxConcurrent)
 		})
 		m.SetRcode(m, miekgdns.RcodeRefused)
 		return
@@ -72,7 +73,7 @@ func (s *server) ServeDNS(w miekgdns.ResponseWriter, m *miekgdns.Msg) {
 	searchList := fix(originName, s.forwardDNS.Search)
 	if v, ok := s.dnsCache.Get(originName); ok {
 		searchList = []string{v.(string)}
-		log.Infof("Use cache name: %s --> %s", originName, v.(string))
+		plog.G(ctx).Infof("Use cache name: %s --> %s", originName, v.(string))
 	}
 
 	for _, name := range searchList {
@@ -85,16 +86,16 @@ func (s *server) ServeDNS(w miekgdns.ResponseWriter, m *miekgdns.Msg) {
 			var answer *miekgdns.Msg
 			answer, _, err = s.client.ExchangeContext(context.Background(), msg, net.JoinHostPort(dnsAddr, s.forwardDNS.Port))
 			if err != nil {
-				log.Errorf("Failed to found DNS name: %s: %v", name, err)
+				plog.G(ctx).Errorf("Failed to found DNS name: %s: %v", name, err)
 				continue
 			}
 			if len(answer.Answer) == 0 {
-				log.Infof("DNS answer is empty for name: %s", name)
+				plog.G(ctx).Infof("DNS answer is empty for name: %s", name)
 				continue
 			}
 
 			s.dnsCache.Add(originName, name, time.Minute*30)
-			log.Infof("Add cache: %s --> %s", originName, name)
+			plog.G(ctx).Infof("Add cache: %s --> %s", originName, name)
 
 			for i := 0; i < len(answer.Answer); i++ {
 				answer.Answer[i].Header().Name = originName
@@ -105,7 +106,7 @@ func (s *server) ServeDNS(w miekgdns.ResponseWriter, m *miekgdns.Msg) {
 
 			err = w.WriteMsg(answer)
 			if err != nil {
-				log.Errorf("Failed to write response for name: %s: %v", name, err.Error())
+				plog.G(ctx).Errorf("Failed to write response for name: %s: %v", name, err.Error())
 			}
 			return
 		}

pkg/driver/driver.go

@@ -1,15 +1,16 @@
 package driver
 
 import (
+	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/client-go/util/retry"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/driver/openvpn"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/driver/wintun"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func InstallTunTapDriver() {
@@ -18,7 +19,7 @@ func InstallTunTapDriver() {
 	}, func() error {
 		return openvpn.Install()
 	}); err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 }
 
@@ -28,7 +29,7 @@ func InstallWireGuardTunDriver() {
 	}, func() error {
 		return wintun.InstallWintunDriver()
 	}); err != nil {
-		log.Warn(err)
+		plog.G(context.Background()).Warn(err)
 	}
 }
 
@@ -47,9 +48,9 @@ func UninstallTunTapDriver() {
 	cmd := exec.Command(path, "/S")
 	b, e := cmd.CombinedOutput()
 	if e != nil {
-		log.Warn(e)
+		plog.G(context.Background()).Warn(e)
 	}
-	log.Info(string(b))
+	plog.G(context.Background()).Info(string(b))
 }
 
 func getDiskName() string {

pkg/handler/cleaner.go

@@ -8,11 +8,11 @@ import (
 	"syscall"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/utils/pointer"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func (c *ConnectOptions) setupSignalHandler() {
@@ -20,12 +20,12 @@ func (c *ConnectOptions) setupSignalHandler() {
 	signal.Notify(stopChan, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT, syscall.SIGKILL)
 	select {
 	case <-stopChan:
-		c.Cleanup()
+		c.Cleanup(context.Background())
 	case <-c.ctx.Done():
 	}
 }
 
-func (c *ConnectOptions) Cleanup() {
+func (c *ConnectOptions) Cleanup(ctx context.Context) {
 	if c == nil {
 		return
 	}
@@ -37,9 +37,9 @@ func (c *ConnectOptions) Cleanup() {
 
 	c.once.Do(func() {
 		if inUserDaemon {
-			log.Info("Performing cleanup operations")
+			plog.G(ctx).Info("Performing cleanup operations")
 		}
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+		ctx2, cancel := context.WithTimeout(context.Background(), time.Second*10)
 		defer cancel()
 		var ips []net.IP
 		if c.localTunIPv4 != nil && c.localTunIPv4.IP != nil {
@@ -49,24 +49,24 @@ func (c *ConnectOptions) Cleanup() {
 			ips = append(ips, c.localTunIPv6.IP)
 		}
 		if c.dhcp != nil {
-			err := c.dhcp.ReleaseIP(ctx, ips...)
+			err := c.dhcp.ReleaseIP(ctx2, ips...)
 			if err != nil {
-				log.Errorf("Failed to release IP to dhcp, err: %v", err)
+				plog.G(ctx).Errorf("Failed to release IP to DHCP server: %v", err)
 			}
 		}
 		if c.clientset != nil {
-			_ = c.clientset.CoreV1().Pods(c.Namespace).Delete(ctx, config.CniNetName, v1.DeleteOptions{GracePeriodSeconds: pointer.Int64(0)})
+			_ = c.clientset.CoreV1().Pods(c.Namespace).Delete(ctx2, config.CniNetName, v1.DeleteOptions{GracePeriodSeconds: pointer.Int64(0)})
 		}
 		// leave proxy resources
-		err := c.LeaveAllProxyResources(ctx)
+		err := c.LeaveAllProxyResources(ctx2)
 		if err != nil {
-			log.Errorf("Leave proxy resources error: %v", err)
+			plog.G(ctx).Errorf("Leave proxy resources error: %v", err)
 		}
 
 		for _, function := range c.getRolloutFunc() {
 			if function != nil {
 				if err = function(); err != nil {
-					log.Warnf("Rollout function error: %v", err)
+					plog.G(ctx).Warnf("Rollout function error: %v", err)
 				}
 			}
 		}
@@ -75,7 +75,7 @@ func (c *ConnectOptions) Cleanup() {
 		}
 		if c.dnsConfig != nil {
 			if inUserDaemon {
-				log.Infof("Clearing DNS settings")
+				plog.G(ctx2).Infof("Clearing DNS settings")
 			}
 			c.dnsConfig.CancelDNS()
 		}

pkg/handler/clone.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/distribution/reference"
 	"github.com/google/uuid"
-	log "github.com/sirupsen/logrus"
 	libconfig "github.com/syncthing/syncthing/lib/config"
 	"github.com/syncthing/syncthing/lib/netutil"
 	v1 "k8s.io/api/core/v1"
@@ -39,6 +38,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/syncthing"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -138,14 +138,14 @@ func (d *CloneOptions) DoClone(ctx context.Context, kubeconfigJsonBytes []byte)
 		args = append(args, "--headers", labels.Set(d.Headers).String())
 	}
 	for _, workload := range d.Workloads {
-		log.Infof("Clone workload %s", workload)
+		plog.G(ctx).Infof("Clone workload %s", workload)
 		object, err := util.GetUnstructuredObject(d.factory, d.Namespace, workload)
 		if err != nil {
 			return err
 		}
 		u := object.Object.(*unstructured.Unstructured)
 		if err = unstructured.SetNestedField(u.UnstructuredContent(), int64(1), "spec", "replicas"); err != nil {
-			log.Warnf("Failed to set repilcaset to 1: %v", err)
+			plog.G(ctx).Warnf("Failed to set repilcaset to 1: %v", err)
 		}
 		u.SetNamespace(d.TargetNamespace)
 		RemoveUselessInfo(u)
@@ -236,7 +236,7 @@ func (d *CloneOptions) DoClone(ctx context.Context, kubeconfigJsonBytes []byte)
 				}
 			}
 			{
-				container, err := podcmd.FindOrDefaultContainerByName(&v1.Pod{Spec: v1.PodSpec{Containers: containers}}, d.TargetContainer, false, log.StandardLogger().Out)
+				container, err := podcmd.FindOrDefaultContainerByName(&v1.Pod{Spec: v1.PodSpec{Containers: containers}}, d.TargetContainer, false, plog.G(ctx).Out)
 				if err != nil {
 					return err
 				}
@@ -389,7 +389,7 @@ func (d *CloneOptions) DoClone(ctx context.Context, kubeconfigJsonBytes []byte)
 			if err = unstructured.SetNestedField(u.Object, m, path...); err != nil {
 				return err
 			}
-			if err = d.replaceRegistry(u); err != nil {
+			if err = d.replaceRegistry(ctx, u); err != nil {
 				return err
 			}
 
@@ -400,9 +400,9 @@ func (d *CloneOptions) DoClone(ctx context.Context, kubeconfigJsonBytes []byte)
 		if retryErr != nil {
 			return fmt.Errorf("create clone for resource %s failed: %v", workload, retryErr)
 		}
-		log.Infof("Create clone resource %s/%s in target cluster", u.GetObjectKind().GroupVersionKind().GroupKind().String(), u.GetName())
-		log.Infof("Wait for clone resource %s/%s to be ready", u.GetObjectKind().GroupVersionKind().GroupKind().String(), u.GetName())
-		log.Infoln()
+		plog.G(ctx).Infof("Create clone resource %s/%s in target cluster", u.GetObjectKind().GroupVersionKind().GroupKind().String(), u.GetName())
+		plog.G(ctx).Infof("Wait for clone resource %s/%s to be ready", u.GetObjectKind().GroupVersionKind().GroupKind().String(), u.GetName())
+		plog.G(ctx).Infoln()
 		err = util.WaitPodToBeReady(ctx, d.targetClientset.CoreV1().Pods(d.TargetNamespace), metav1.LabelSelector{MatchLabels: labelsMap})
 		if err != nil {
 			return err
@@ -432,7 +432,7 @@ func (d *CloneOptions) SyncDir(ctx context.Context, labels string) error {
 		return err
 	}
 	d.syncthingGUIAddr = (&url.URL{Scheme: "http", Host: localAddr}).String()
-	log.Infof("Access the syncthing GUI via the following URL: %s", d.syncthingGUIAddr)
+	plog.G(ctx).Infof("Access the syncthing GUI via the following URL: %s", d.syncthingGUIAddr)
 	go func() {
 		client := syncthing.NewClient(localAddr)
 		podName := list[0].Name
@@ -444,7 +444,7 @@ func (d *CloneOptions) SyncDir(ctx context.Context, labels string) error {
 				_, _, _ = polymorphichelpers.GetFirstPod(d.targetClientset.CoreV1(), d.TargetNamespace, labels, time.Second*30, sortBy)
 				list, err := util.GetRunningPodList(d.ctx, d.targetClientset, d.TargetNamespace, labels)
 				if err != nil {
-					log.Error(err)
+					plog.G(ctx).Error(err)
 					return
 				}
 				if podName == list[0].Name {
@@ -452,23 +452,23 @@ func (d *CloneOptions) SyncDir(ctx context.Context, labels string) error {
 				}
 
 				podName = list[0].Name
-				log.Debugf("Detect newer pod %s", podName)
+				plog.G(ctx).Debugf("Detect newer pod %s", podName)
 				var conf *libconfig.Configuration
 				conf, err = client.GetConfig(d.ctx)
 				if err != nil {
-					log.Errorf("Failed to get config from syncthing: %v", err)
+					plog.G(ctx).Errorf("Failed to get config from syncthing: %v", err)
 					return
 				}
 				for i := range conf.Devices {
 					if config.RemoteDeviceID.Equals(conf.Devices[i].DeviceID) {
 						addr := netutil.AddressURL("tcp", net.JoinHostPort(list[0].Status.PodIP, strconv.Itoa(libconfig.DefaultTCPPort)))
 						conf.Devices[i].Addresses = []string{addr}
-						log.Debugf("Use newer remote syncthing endpoint: %s", addr)
+						plog.G(ctx).Debugf("Use newer remote syncthing endpoint: %s", addr)
 					}
 				}
 				err = client.PutConfig(d.ctx, conf)
 				if err != nil {
-					log.Errorf("Failed to set config to syncthing: %v", err)
+					plog.G(ctx).Errorf("Failed to set config to syncthing: %v", err)
 				}
 			}()
 		}
@@ -794,7 +794,7 @@ func (d *CloneOptions) setEnv(u *unstructured.Unstructured) error {
 }
 
 // replace origin registry with special registry for pulling image
-func (d *CloneOptions) replaceRegistry(u *unstructured.Unstructured) error {
+func (d *CloneOptions) replaceRegistry(ctx context.Context, u *unstructured.Unstructured) error {
 	// not pass this options, do nothing
 	if !d.IsChangeTargetRegistry {
 		return nil
@@ -814,7 +814,7 @@ func (d *CloneOptions) replaceRegistry(u *unstructured.Unstructured) error {
 		domain := reference.Domain(named)
 		newImage := strings.TrimPrefix(strings.ReplaceAll(oldImage, domain, d.TargetRegistry), "/")
 		temp.Spec.InitContainers[i].Image = newImage
-		log.Debugf("Update init container: %s image: %s --> %s", container.Name, oldImage, newImage)
+		plog.G(ctx).Debugf("Update init container: %s image: %s --> %s", container.Name, oldImage, newImage)
 	}
 
 	for i, container := range temp.Spec.Containers {
@@ -826,7 +826,7 @@ func (d *CloneOptions) replaceRegistry(u *unstructured.Unstructured) error {
 		domain := reference.Domain(named)
 		newImage := strings.TrimPrefix(strings.ReplaceAll(oldImage, domain, d.TargetRegistry), "/")
 		temp.Spec.Containers[i].Image = newImage
-		log.Debugf("Update container: %s image: %s --> %s", container.Name, oldImage, newImage)
+		plog.G(ctx).Debugf("Update container: %s image: %s --> %s", container.Name, oldImage, newImage)
 	}
 
 	var marshal []byte
@@ -844,15 +844,15 @@ func (d *CloneOptions) replaceRegistry(u *unstructured.Unstructured) error {
 	return nil
 }
 
-func (d *CloneOptions) Cleanup(workloads ...string) error {
+func (d *CloneOptions) Cleanup(ctx context.Context, workloads ...string) error {
 	if len(workloads) == 0 {
 		workloads = d.Workloads
 	}
 	for _, workload := range workloads {
-		log.Infof("Cleaning up clone workload: %s", workload)
+		plog.G(ctx).Infof("Cleaning up clone workload: %s", workload)
 		object, err := util.GetUnstructuredObject(d.factory, d.Namespace, workload)
 		if err != nil {
-			log.Errorf("Failed to get unstructured object error: %s", err.Error())
+			plog.G(ctx).Errorf("Failed to get unstructured object error: %s", err.Error())
 			return err
 		}
 		labelsMap := map[string]string{
@@ -862,13 +862,13 @@ func (d *CloneOptions) Cleanup(workloads ...string) error {
 		selector := labels.SelectorFromSet(labelsMap)
 		controller, err := util.GetTopOwnerReferenceBySelector(d.targetFactory, d.TargetNamespace, selector.String())
 		if err != nil {
-			log.Errorf("Failed to get controller error: %s", err.Error())
+			plog.G(ctx).Errorf("Failed to get controller error: %s", err.Error())
 			return err
 		}
 		var client dynamic.Interface
 		client, err = d.targetFactory.DynamicClient()
 		if err != nil {
-			log.Errorf("Failed to get dynamic client error: %s", err.Error())
+			plog.G(ctx).Errorf("Failed to get dynamic client error: %s", err.Error())
 			return err
 		}
 		for _, cloneName := range controller.UnsortedList() {
@@ -878,17 +878,17 @@ func (d *CloneOptions) Cleanup(workloads ...string) error {
 			}
 			err = client.Resource(object.Mapping.Resource).Namespace(d.TargetNamespace).Delete(context.Background(), cloneName, metav1.DeleteOptions{})
 			if err != nil && !apierrors.IsNotFound(err) {
-				log.Errorf("Failed to delete clone object: %v", err)
+				plog.G(ctx).Errorf("Failed to delete clone object: %v", err)
 				return err
 			}
-			log.Infof("Deleted clone object: %s", cloneName)
+			plog.G(ctx).Infof("Deleted clone object: %s", cloneName)
 		}
-		log.Debugf("Cleanup clone workload: %s successfully", workload)
+		plog.G(ctx).Debugf("Cleanup clone workload: %s successfully", workload)
 	}
 	for _, f := range d.rollbackFuncList {
 		if f != nil {
 			if err := f(); err != nil {
-				log.Warnf("Failed to exec rollback function: %s", err)
+				plog.G(ctx).Warnf("Failed to exec rollback function: %s", err)
 			}
 		}
 	}

pkg/handler/connect.go

@@ -52,6 +52,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dns"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/driver"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/tun"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -119,7 +120,7 @@ func (c *ConnectOptions) RentIP(ctx context.Context) (context.Context, error) {
 	return ctx1, nil
 }
 
-func (c *ConnectOptions) GetIPFromContext(ctx context.Context) error {
+func (c *ConnectOptions) GetIPFromContext(ctx context.Context, logger *log.Logger) error {
 	md, ok := metadata.FromIncomingContext(ctx)
 	if !ok {
 		return fmt.Errorf("can not get IOP from context")
@@ -134,7 +135,7 @@ func (c *ConnectOptions) GetIPFromContext(ctx context.Context) error {
 		return fmt.Errorf("cat not convert IPv4 string: %s: %v", ipv4[0], err)
 	}
 	c.localTunIPv4 = &net.IPNet{IP: ip, Mask: ipNet.Mask}
-	log.Debugf("Get IPv4 %s from context", c.localTunIPv4.String())
+	plog.G(ctx).Debugf("Get IPv4 %s from context", c.localTunIPv4.String())
 
 	ipv6 := md.Get(config.HeaderIPv6)
 	if len(ipv6) == 0 {
@@ -145,7 +146,7 @@ func (c *ConnectOptions) GetIPFromContext(ctx context.Context) error {
 		return fmt.Errorf("cat not convert IPv6 string: %s: %v", ipv6[0], err)
 	}
 	c.localTunIPv6 = &net.IPNet{IP: ip, Mask: ipNet.Mask}
-	log.Debugf("Get IPv6 %s from context", c.localTunIPv6.String())
+	plog.G(ctx).Debugf("Get IPv6 %s from context", c.localTunIPv6.String())
 	return nil
 }
 
@@ -158,7 +159,7 @@ func (c *ConnectOptions) CreateRemoteInboundPod(ctx context.Context, workloads [
 	}
 
 	for _, workload := range workloads {
-		log.Infof("Injecting inbound sidecar for %s", workload)
+		plog.G(ctx).Infof("Injecting inbound sidecar for %s", workload)
 		configInfo := util.PodRouteConfig{
 			LocalTunIPv4: c.localTunIPv4.IP.String(),
 			LocalTunIPv6: c.localTunIPv6.IP.String(),
@@ -184,7 +185,7 @@ func (c *ConnectOptions) CreateRemoteInboundPod(ctx context.Context, workloads [
 			err = inject.InjectVPNSidecar(ctx, c.factory, c.Namespace, workload, object, configInfo)
 		}
 		if err != nil {
-			log.Errorf("Injecting inbound sidecar for %s failed: %s", workload, err.Error())
+			plog.G(ctx).Errorf("Injecting inbound sidecar for %s failed: %s", workload, err.Error())
 			return err
 		}
 		c.proxyWorkloads.Add(&Proxy{
@@ -208,15 +209,15 @@ func (c *ConnectOptions) DoConnect(ctx context.Context, isLite bool, stopChan <-
 		}
 	}()
 
-	log.Info("Starting connect")
+	plog.G(ctx).Info("Starting connect")
 	m := dhcp.NewDHCPManager(c.clientset.CoreV1().ConfigMaps(c.Namespace), c.Namespace)
 	if err = m.InitDHCP(c.ctx); err != nil {
-		log.Errorf("Init DHCP failed: %v", err)
+		plog.G(ctx).Errorf("Init DHCP failed: %v", err)
 		return
 	}
 	go c.setupSignalHandler()
 	if err = c.getCIDR(c.ctx, m); err != nil {
-		log.Errorf("Failed to get network CIDR: %v", err)
+		plog.G(ctx).Errorf("Failed to get network CIDR: %v", err)
 		return
 	}
 	if err = createOutboundPod(c.ctx, c.factory, c.clientset, c.Namespace, c.Engine == config.EngineGvisor, c.ImagePullSecretName); err != nil {
@@ -229,7 +230,7 @@ func (c *ConnectOptions) DoConnect(ctx context.Context, isLite bool, stopChan <-
 	//	return
 	//}
 	if err = c.addExtraNodeIP(c.ctx); err != nil {
-		log.Errorf("Add extra node IP failed: %v", err)
+		plog.G(ctx).Errorf("Add extra node IP failed: %v", err)
 		return
 	}
 	var rawTCPForwardPort, gvisorTCPForwardPort, gvisorUDPForwardPort int
@@ -245,7 +246,7 @@ func (c *ConnectOptions) DoConnect(ctx context.Context, isLite bool, stopChan <-
 	if err != nil {
 		return err
 	}
-	log.Info("Forwarding port...")
+	plog.G(ctx).Info("Forwarding port...")
 	portPair := []string{
 		fmt.Sprintf("%d:10800", rawTCPForwardPort),
 		fmt.Sprintf("%d:10801", gvisorTCPForwardPort),
@@ -262,22 +263,22 @@ func (c *ConnectOptions) DoConnect(ctx context.Context, isLite bool, stopChan <-
 		forward = fmt.Sprintf("tcp://127.0.0.1:%d", gvisorTCPForwardPort)
 	}
 	if err = c.startLocalTunServer(c.ctx, forward, isLite); err != nil {
-		log.Errorf("Start local tun service failed: %v", err)
+		plog.G(ctx).Errorf("Start local tun service failed: %v", err)
 		return
 	}
-	log.Infof("Adding route...")
+	plog.G(ctx).Infof("Adding route...")
 	if err = c.addRouteDynamic(c.ctx); err != nil {
-		log.Errorf("Add route dynamic failed: %v", err)
+		plog.G(ctx).Errorf("Add route dynamic failed: %v", err)
 		return
 	}
 	go c.deleteFirewallRule(c.ctx)
-	log.Infof("Configuring DNS service...")
+	plog.G(ctx).Infof("Configuring DNS service...")
 	if err = c.setupDNS(c.ctx); err != nil {
-		log.Errorf("Configure DNS failed: %v", err)
+		plog.G(ctx).Errorf("Configure DNS failed: %v", err)
 		return
 	}
 	success.Store(true)
-	log.Info("Configured DNS service")
+	plog.G(ctx).Info("Configured DNS service")
 	return
 }
 
@@ -300,7 +301,7 @@ func (c *ConnectOptions) portForward(ctx context.Context, portPair []string) err
 				defer cancelFunc2()
 				podList, err := c.GetRunningPodList(ctx2)
 				if err != nil {
-					log.Debugf("Failed to get running pod: %v", err)
+					plog.G(ctx).Debugf("Failed to get running pod: %v", err)
 					if *first {
 						util.SafeWrite(errChan, err)
 					}
@@ -325,8 +326,7 @@ func (c *ConnectOptions) portForward(ctx context.Context, portPair []string) err
 						}
 					}()
 				}
-				var out = log.StandardLogger().WriterLevel(log.DebugLevel)
-				defer out.Close()
+				var out = plog.G(ctx).Out
 				err = util.PortForwardPod(
 					c.config,
 					c.restclient,
@@ -344,14 +344,16 @@ func (c *ConnectOptions) portForward(ctx context.Context, portPair []string) err
 				first = pointer.Bool(false)
 				// exit normal, let context.err to judge to exit or not
 				if err == nil {
-					log.Debugf("Port forward retrying")
+					plog.G(ctx).Debugf("Port forward retrying")
 					return
+				} else {
+					plog.G(ctx).Debugf("Forward port error: %v", err)
 				}
 				if strings.Contains(err.Error(), "unable to listen on any of the requested ports") ||
 					strings.Contains(err.Error(), "address already in use") {
-					log.Debugf("Port %s already in use, needs to release it manually", portPair)
+					plog.G(ctx).Debugf("Port %s already in use, needs to release it manually", portPair)
 				} else {
-					log.Debugf("Port-forward occurs error: %v", err)
+					plog.G(ctx).Debugf("Port-forward occurs error: %v", err)
 				}
 			}()
 		}
@@ -369,7 +371,7 @@ func (c *ConnectOptions) portForward(ctx context.Context, portPair []string) err
 }
 
 func (c *ConnectOptions) startLocalTunServer(ctx context.Context, forwardAddress string, lite bool) (err error) {
-	log.Debugf("IPv4: %s, IPv6: %s", c.localTunIPv4.IP.String(), c.localTunIPv6.IP.String())
+	plog.G(ctx).Debugf("IPv4: %s, IPv6: %s", c.localTunIPv4.IP.String(), c.localTunIPv6.IP.String())
 
 	var cidrList []*net.IPNet
 	if !lite {
@@ -413,13 +415,13 @@ func (c *ConnectOptions) startLocalTunServer(ctx context.Context, forwardAddress
 	localNode := fmt.Sprintf("tun:/127.0.0.1:8422")
 	node, err := core.ParseNode(localNode)
 	if err != nil {
-		log.Errorf("Failed to parse local node %s: %v", localNode, err)
+		plog.G(ctx).Errorf("Failed to parse local node %s: %v", localNode, err)
 		return err
 	}
 
 	chainNode, err := core.ParseNode(forwardAddress)
 	if err != nil {
-		log.Errorf("Failed to parse forward node %s: %v", forwardAddress, err)
+		plog.G(ctx).Errorf("Failed to parse forward node %s: %v", forwardAddress, err)
 		return err
 	}
 	chainNode.Client = &core.Client{
@@ -431,7 +433,7 @@ func (c *ConnectOptions) startLocalTunServer(ctx context.Context, forwardAddress
 	handler := core.TunHandler(chain, node)
 	listener, err := tun.Listener(tunConfig)
 	if err != nil {
-		log.Errorf("Failed to create tun listener: %v", err)
+		plog.G(ctx).Errorf("Failed to create tun listener: %v", err)
 		return err
 	}
 
@@ -451,14 +453,14 @@ func (c *ConnectOptions) startLocalTunServer(ctx context.Context, forwardAddress
 			conn, err := server.Listener.Accept()
 			if err != nil {
 				if !errors.Is(err, tun.ClosedErr) {
-					log.Errorf("Failed to accept local tun conn: %v", err)
+					plog.G(ctx).Errorf("Failed to accept local tun conn: %v", err)
 				}
 				return
 			}
 			go server.Handler.Handle(ctx, conn)
 		}
 	}()
-	log.Info("Connected tunnel")
+	plog.G(ctx).Info("Connected tunnel")
 
 	c.tunName, err = c.GetTunDeviceName()
 	return err
@@ -579,19 +581,19 @@ func (c *ConnectOptions) setupDNS(ctx context.Context) error {
 	const portTCP = 10800
 	podList, err := c.GetRunningPodList(ctx)
 	if err != nil {
-		log.Errorf("Get running pod list failed, err: %v", err)
+		plog.G(ctx).Errorf("Get running pod list failed, err: %v", err)
 		return err
 	}
 	pod := podList[0]
-	log.Debugf("Get DNS service IP from pod...")
+	plog.G(ctx).Debugf("Get DNS service IP from pod...")
 	relovConf, err := util.GetDNSServiceIPFromPod(ctx, c.clientset, c.config, pod.GetName(), c.Namespace)
 	if err != nil {
-		log.Errorln(err)
+		plog.G(ctx).Errorln(err)
 		return err
 	}
 
 	marshal, _ := json.Marshal(relovConf)
-	log.Debugf("Get DNS service config: %v", string(marshal))
+	plog.G(ctx).Debugf("Get DNS service config: %v", string(marshal))
 	svc, err := c.clientset.CoreV1().Services(c.Namespace).Get(ctx, config.ConfigMapPodTrafficManager, metav1.GetOptions{})
 	if err != nil {
 		return err
@@ -603,16 +605,16 @@ func (c *ConnectOptions) setupDNS(ctx context.Context) error {
 	if err != nil {
 		relovConf.Servers = []string{pod.Status.PodIP}
 		err = nil
-		log.Debugf("DNS service use pod IP %s", pod.Status.PodIP)
+		plog.G(ctx).Debugf("DNS service use pod IP %s", pod.Status.PodIP)
 	} else {
 		relovConf.Servers = []string{svc.Spec.ClusterIP}
 		_ = conn.Close()
-		log.Debugf("DNS service use service IP %s", svc.Spec.ClusterIP)
+		plog.G(ctx).Debugf("DNS service use service IP %s", svc.Spec.ClusterIP)
 	}
 
-	log.Debugf("Adding extra hosts...")
+	plog.G(ctx).Debugf("Adding extra hosts...")
 	if err = c.addExtraRoute(c.ctx, pod.GetName()); err != nil {
-		log.Errorf("Add extra route failed: %v", err)
+		plog.G(ctx).Errorf("Add extra route failed: %v", err)
 		return err
 	}
 
@@ -656,11 +658,11 @@ func (c *ConnectOptions) setupDNS(ctx context.Context) error {
 			)
 		},
 	}
-	log.Debugf("Setup DNS...")
+	plog.G(ctx).Debugf("Setup DNS...")
 	if err = c.dnsConfig.SetupDNS(ctx); err != nil {
 		return err
 	}
-	log.Debugf("Dump service in namespace %s into hosts...", c.Namespace)
+	plog.G(ctx).Debugf("Dump service in namespace %s into hosts...", c.Namespace)
 	// dump service in current namespace for support DNS resolve service:port
 	err = c.dnsConfig.AddServiceNameToHosts(ctx, c.clientset.CoreV1().Services(c.Namespace), c.extraHost...)
 	return err
@@ -772,7 +774,7 @@ func (c *ConnectOptions) getCIDR(ctx context.Context, m *dhcp.Manager) (err erro
 			}
 		}
 		if len(c.cidrs) != 0 {
-			log.Infoln("Got network CIDR from cache")
+			plog.G(ctx).Infoln("Got network CIDR from cache")
 			return nil
 		}
 	}
@@ -829,7 +831,7 @@ func (c *ConnectOptions) addExtraRoute(ctx context.Context, name string) error {
 		}
 		err = c.addRoute(ip)
 		if err != nil {
-			log.Errorf("Failed to add IP: %s to route table: %v", ip, err)
+			plog.G(ctx).Errorf("Failed to add IP: %s to route table: %v", ip, err)
 			return err
 		}
 		c.extraHost = append(c.extraHost, dns.Entry{IP: net.ParseIP(ip).String(), Domain: domain})
@@ -940,7 +942,7 @@ func (c *ConnectOptions) upgradeDeploy(ctx context.Context) error {
 		return err
 	}
 
-	log.Infof("Set image %s --> %s...", serverImg, clientImg)
+	plog.G(ctx).Infof("Set image %s --> %s...", serverImg, clientImg)
 
 	err = upgradeDeploySpec(ctx, c.factory, c.Namespace, deploy.Name, clientImg)
 	if err != nil {
@@ -1050,7 +1052,7 @@ func upgradeDeploySpec(ctx context.Context, f cmdutil.Factory, ns, name string,
 			DryRun(false).
 			Patch(p.Info.Namespace, p.Info.Name, pkgtypes.StrategicMergePatchType, p.Patch, nil)
 		if err != nil {
-			log.Errorf("Failed to patch image update to pod template: %v", err)
+			plog.G(ctx).Errorf("Failed to patch image update to pod template: %v", err)
 			return err
 		}
 		err = util.RolloutStatus(ctx, f, ns, fmt.Sprintf("%s/%s", p.Info.Mapping.Resource.GroupResource().String(), p.Info.Name), time.Minute*60)

pkg/handler/function_test.go

@@ -27,6 +27,7 @@ import (
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"sigs.k8s.io/yaml"
 
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -356,13 +357,13 @@ func Init() {
 	f := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
 
 	if restconfig, err = f.ToRESTConfig(); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	if clientset, err = kubernetes.NewForConfig(restconfig); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	if namespace, _, err = f.ToRawKubeConfigLoader().Namespace(); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 }
 

pkg/handler/proxy.go

@@ -10,7 +10,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/sirupsen/logrus"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/kubernetes"
@@ -18,6 +17,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/ssh"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
@@ -107,7 +107,7 @@ func (m *Mapper) Run() {
 			if errors.Is(err, context.Canceled) {
 				continue
 			}
-			logrus.Errorf("failed to get local port to envoy rule port: %v", err)
+			plog.G(m.ctx).Errorf("failed to get local port to envoy rule port: %v", err)
 			time.Sleep(time.Second * 2)
 			continue
 		}
@@ -125,7 +125,7 @@ func (m *Mapper) Run() {
 			if errors.Is(err, context.Canceled) {
 				continue
 			}
-			logrus.Errorf("failed to list running pod: %v", err)
+			plog.G(m.ctx).Errorf("failed to list running pod: %v", err)
 			time.Sleep(time.Second * 2)
 			continue
 		}
@@ -141,7 +141,7 @@ func (m *Mapper) Run() {
 				containerNames.Insert(container.Name)
 			}
 			if !containerNames.HasAny(config.ContainerSidecarVPN, config.ContainerSidecarEnvoyProxy) {
-				logrus.Infof("Labels with pod have been reset")
+				plog.G(m.ctx).Infof("Labels with pod have been reset")
 				return
 			}
 
@@ -160,7 +160,7 @@ func (m *Mapper) Run() {
 						remote := netip.AddrPortFrom(netip.IPv4Unspecified(), uint16(envoyRulePort))
 						for ctx.Err() == nil {
 							_ = ssh.ExposeLocalPortToRemote(ctx, remoteSSHServer, remote, local)
-							time.Sleep(time.Second * 1)
+							time.Sleep(time.Second * 2)
 						}
 					}(containerPort, envoyRulePort)
 				}

pkg/handler/remote.go

@@ -8,7 +8,6 @@ import (
 	"net"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	admissionv1 "k8s.io/api/admissionregistration/v1"
 	appsv1 "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
@@ -28,6 +27,7 @@ import (
 	"k8s.io/utils/ptr"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -37,7 +37,7 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 		var pod *v1.Pod
 		pod, err = polymorphichelpers.AttachablePodForObjectFn(factory, service, 2*time.Second)
 		if err == nil && pod.DeletionTimestamp.IsZero() && podutils.IsPodReady(pod) {
-			log.Infoln("Use exist traffic manager")
+			plog.G(ctx).Infoln("Use exist traffic manager")
 			return
 		}
 	}
@@ -59,10 +59,10 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	deleteResource(ctx)
 
 	// 1) label namespace
-	log.Infof("Labeling Namespace %s", namespace)
+	plog.G(ctx).Infof("Labeling Namespace %s", namespace)
 	ns, err := clientset.CoreV1().Namespaces().Get(ctx, namespace, metav1.GetOptions{})
 	if err != nil {
-		log.Errorf("Get Namespace error: %s", err.Error())
+		plog.G(ctx).Errorf("Get Namespace error: %s", err.Error())
 		return err
 	}
 	if ns.Labels == nil {
@@ -71,36 +71,36 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	ns.Labels["ns"] = namespace
 	_, err = clientset.CoreV1().Namespaces().Update(ctx, ns, metav1.UpdateOptions{})
 	if err != nil {
-		log.Infof("Labeling Namespace error: %s", err.Error())
+		plog.G(ctx).Infof("Labeling Namespace error: %s", err.Error())
 		return err
 	}
 
 	// 2) create serviceAccount
-	log.Infof("Creating ServiceAccount %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating ServiceAccount %s", config.ConfigMapPodTrafficManager)
 	_, err = clientset.CoreV1().ServiceAccounts(namespace).Create(ctx, genServiceAccount(namespace), metav1.CreateOptions{})
 	if err != nil {
-		log.Infof("Creating ServiceAccount error: %s", err.Error())
+		plog.G(ctx).Infof("Creating ServiceAccount error: %s", err.Error())
 		return err
 	}
 
 	// 3) create roles
-	log.Infof("Creating Roles %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating Roles %s", config.ConfigMapPodTrafficManager)
 	_, err = clientset.RbacV1().Roles(namespace).Create(ctx, genRole(namespace), metav1.CreateOptions{})
 	if err != nil {
-		log.Errorf("Creating Roles error: %s", err.Error())
+		plog.G(ctx).Errorf("Creating Roles error: %s", err.Error())
 		return err
 	}
 
 	// 4) create roleBinding
-	log.Infof("Creating RoleBinding %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating RoleBinding %s", config.ConfigMapPodTrafficManager)
 	_, err = clientset.RbacV1().RoleBindings(namespace).Create(ctx, genRoleBinding(namespace), metav1.CreateOptions{})
 	if err != nil {
-		log.Errorf("Creating RoleBinding error: %s", err.Error())
+		plog.G(ctx).Errorf("Creating RoleBinding error: %s", err.Error())
 		return err
 	}
 
 	// 5) create service
-	log.Infof("Creating Service %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating Service %s", config.ConfigMapPodTrafficManager)
 	udp8422 := "8422-for-udp"
 	tcp10800 := "10800-for-tcp"
 	tcp9002 := "9002-for-envoy"
@@ -109,7 +109,7 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	svcSpec := genService(namespace, udp8422, tcp10800, tcp9002, tcp80, udp53)
 	_, err = clientset.CoreV1().Services(namespace).Create(ctx, svcSpec, metav1.CreateOptions{})
 	if err != nil {
-		log.Errorf("Creating Service error: %s", err.Error())
+		plog.G(ctx).Errorf("Creating Service error: %s", err.Error())
 		return err
 	}
 
@@ -117,7 +117,7 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	var crt, key []byte
 	crt, key, err = cert.GenerateSelfSignedCertKey(domain, nil, nil)
 	if err != nil {
-		log.Errorf("Generate self signed cert and key error: %s", err.Error())
+		plog.G(ctx).Errorf("Generate self signed cert and key error: %s", err.Error())
 		return err
 	}
 	// reason why not use v1.SecretTypeTls is because it needs key called tls.crt and tls.key, but tls.key can not as env variable
@@ -126,12 +126,12 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	secret := genSecret(namespace, crt, key)
 	_, err = clientset.CoreV1().Secrets(namespace).Create(ctx, secret, metav1.CreateOptions{})
 	if err != nil && !k8serrors.IsAlreadyExists(err) {
-		log.Errorf("Creating secret error: %s", err.Error())
+		plog.G(ctx).Errorf("Creating secret error: %s", err.Error())
 		return err
 	}
 
 	// 6) create mutatingWebhookConfigurations
-	log.Infof("Creating MutatingWebhookConfiguration %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating MutatingWebhookConfiguration %s", config.ConfigMapPodTrafficManager)
 	mutatingWebhookConfiguration := genMutatingWebhookConfiguration(namespace, crt)
 	_, err = clientset.AdmissionregistrationV1().MutatingWebhookConfigurations().Create(ctx, mutatingWebhookConfiguration, metav1.CreateOptions{})
 	if err != nil && !k8serrors.IsForbidden(err) && !k8serrors.IsAlreadyExists(err) {
@@ -139,11 +139,11 @@ func createOutboundPod(ctx context.Context, factory cmdutil.Factory, clientset *
 	}
 
 	// 7) create deployment
-	log.Infof("Creating Deployment %s", config.ConfigMapPodTrafficManager)
+	plog.G(ctx).Infof("Creating Deployment %s", config.ConfigMapPodTrafficManager)
 	deploy := genDeploySpec(namespace, udp8422, tcp10800, tcp9002, udp53, tcp80, gvisor, imagePullSecretName)
 	deploy, err = clientset.AppsV1().Deployments(namespace).Create(ctx, deploy, metav1.CreateOptions{})
 	if err != nil {
-		log.Errorf("Failed to create deployment for %s: %v", config.ConfigMapPodTrafficManager, err)
+		plog.G(ctx).Errorf("Failed to create deployment for %s: %v", config.ConfigMapPodTrafficManager, err)
 		return err
 	}
 
@@ -503,13 +503,13 @@ func waitPodReady(ctx context.Context, deploy *appsv1.Deployment, clientset core
 	var lastMessage string
 	ctx2, cancelFunc := context.WithTimeout(ctx, time.Minute*60)
 	defer cancelFunc()
-	log.Infoln()
+	plog.G(ctx).Infoln()
 	wait.UntilWithContext(ctx2, func(ctx context.Context) {
 		podList, err := clientset.List(ctx2, metav1.ListOptions{
 			LabelSelector: selector.String(),
 		})
 		if err != nil {
-			log.Errorf("Failed to list pods for %s: %v", deploy.Name, err)
+			plog.G(ctx).Errorf("Failed to list pods for %s: %v", deploy.Name, err)
 			return
 		}
 
@@ -527,7 +527,7 @@ func waitPodReady(ctx context.Context, deploy *appsv1.Deployment, clientset core
 			}
 			util.PrintStatus(&pod, sb)
 			if lastMessage != sb.String() {
-				log.Infof(sb.String())
+				plog.G(ctx).Infof(sb.String())
 			}
 			lastMessage = sb.String()
 
@@ -547,7 +547,7 @@ func waitPodReady(ctx context.Context, deploy *appsv1.Deployment, clientset core
 	}, time.Second*3)
 
 	if !isPodReady {
-		log.Errorf("Wait pod %s to be ready timeout", deploy.Name)
+		plog.G(ctx).Errorf("Wait pod %s to be ready timeout", deploy.Name)
 		return errors.New(fmt.Sprintf("wait pod %s to be ready timeout", deploy.Name))
 	}
 

pkg/handler/reset.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"strings"
 
-	log "github.com/sirupsen/logrus"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -20,6 +19,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -40,13 +40,13 @@ func (c *ConnectOptions) Reset(ctx context.Context, workloads []string) error {
 
 	err = resetConfigMap(ctx, c.clientset.CoreV1().ConfigMaps(c.Namespace), workloads)
 	if err != nil {
-		log.Error(err)
+		plog.G(ctx).Error(err)
 	}
 
 	for _, workload := range workloads {
 		err = removeInjectContainer(ctx, c.factory, c.clientset, c.Namespace, workload)
 		if err != nil {
-			log.Error(err)
+			plog.G(ctx).Error(err)
 		}
 	}
 
@@ -62,13 +62,13 @@ func resetConfigMap(ctx context.Context, mapInterface v1.ConfigMapInterface, wor
 		return err
 	}
 	if cm == nil || cm.Data == nil || len(cm.Data[config.KeyEnvoy]) == 0 {
-		log.Infof("No proxy resources found")
+		plog.G(ctx).Infof("No proxy resources found")
 		return nil
 	}
 	var v = make([]*controlplane.Virtual, 0)
 	str := cm.Data[config.KeyEnvoy]
 	if err = yaml.Unmarshal([]byte(str), &v); err != nil {
-		log.Errorf("Unmarshal envoy config error: %v", err)
+		plog.G(ctx).Errorf("Unmarshal envoy config error: %v", err)
 		return nil
 	}
 	ws := sets.New[string]()
@@ -95,23 +95,23 @@ func resetConfigMap(ctx context.Context, mapInterface v1.ConfigMapInterface, wor
 func removeInjectContainer(ctx context.Context, factory cmdutil.Factory, clientset *kubernetes.Clientset, namespace, workload string) error {
 	object, err := util.GetUnstructuredObject(factory, namespace, workload)
 	if err != nil {
-		log.Errorf("Failed to get unstructured object: %v", err)
+		plog.G(ctx).Errorf("Failed to get unstructured object: %v", err)
 		return err
 	}
 
 	u := object.Object.(*unstructured.Unstructured)
 	templateSpec, depth, err := util.GetPodTemplateSpecPath(u)
 	if err != nil {
-		log.Errorf("Failed to get template spec path: %v", err)
+		plog.G(ctx).Errorf("Failed to get template spec path: %v", err)
 		return err
 	}
 
-	log.Infof("Leaving workload %s", workload)
+	plog.G(ctx).Infof("Leaving workload %s", workload)
 
 	inject.RemoveContainers(templateSpec)
 
 	helper := pkgresource.NewHelper(object.Client, object.Mapping)
-	log.Debugf("The %s is under controller management", workload)
+	plog.G(ctx).Debugf("The %s is under controller management", workload)
 	// resource with controller, like deployment,statefulset
 	var bytes []byte
 	bytes, err = json.Marshal([]inject.P{
@@ -122,12 +122,12 @@ func removeInjectContainer(ctx context.Context, factory cmdutil.Factory, clients
 		},
 	})
 	if err != nil {
-		log.Errorf("Failed to generate json patch: %v", err)
+		plog.G(ctx).Errorf("Failed to generate json patch: %v", err)
 		return err
 	}
 	_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, bytes, &metav1.PatchOptions{})
 	if err != nil {
-		log.Errorf("Failed to patch resource: %s %s: %v", object.Mapping.Resource.Resource, object.Name, err)
+		plog.G(ctx).Errorf("Failed to patch resource: %s %s: %v", object.Mapping.Resource.Resource, object.Name, err)
 		return err
 	}
 

pkg/handler/tools.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 
-	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/health/grpc_health_v1"
@@ -15,6 +14,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/core"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/dhcp/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -49,19 +49,19 @@ func Complete(ctx context.Context, route *core.Route) error {
 			IPv6CIDR:     os.Getenv(config.EnvInboundPodTunIPv6),
 		})
 		if err2 != nil {
-			log.Errorf("Failed to release IP %s and %s: %v", resp.IPv4CIDR, resp.IPv6CIDR, err2)
+			plog.G(ctx).Errorf("Failed to release IP %s and %s: %v", resp.IPv4CIDR, resp.IPv6CIDR, err2)
 		} else {
-			log.Debugf("Release IP %s and %s", resp.IPv4CIDR, resp.IPv6CIDR)
+			plog.G(ctx).Debugf("Release IP %s and %s", resp.IPv4CIDR, resp.IPv6CIDR)
 		}
 	}()
 
-	log.Infof("Rent an IPv4: %s, IPv6: %s", resp.IPv4CIDR, resp.IPv6CIDR)
+	plog.G(ctx).Infof("Rent an IPv4: %s, IPv6: %s", resp.IPv4CIDR, resp.IPv6CIDR)
 	if err = os.Setenv(config.EnvInboundPodTunIPv4, resp.IPv4CIDR); err != nil {
-		log.Errorf("Failed to set IP: %v", err)
+		plog.G(ctx).Errorf("Failed to set IP: %v", err)
 		return err
 	}
 	if err = os.Setenv(config.EnvInboundPodTunIPv6, resp.IPv6CIDR); err != nil {
-		log.Errorf("Failed to set IP: %v", err)
+		plog.G(ctx).Errorf("Failed to set IP: %v", err)
 		return err
 	}
 	for i := 0; i < len(route.ServeNodes); i++ {

pkg/handler/uninstall.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
-	log "github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -16,6 +15,7 @@ import (
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/inject"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -27,12 +27,12 @@ import (
 func (c *ConnectOptions) Uninstall(ctx context.Context) error {
 	err := c.LeaveAllProxyResources(ctx)
 	if err != nil {
-		log.Errorf("Leave proxy resources error: %v", err)
+		plog.G(ctx).Errorf("Leave proxy resources error: %v", err)
 	} else {
-		log.Debugf("Leave proxy resources successfully")
+		plog.G(ctx).Debugf("Leave proxy resources successfully")
 	}
 
-	log.Infof("Cleaning up resources")
+	plog.G(ctx).Infof("Cleaning up resources")
 	ns := c.Namespace
 	name := config.ConfigMapPodTrafficManager
 	options := metav1.DeleteOptions{GracePeriodSeconds: pointer.Int64(0)}
@@ -47,7 +47,7 @@ func (c *ConnectOptions) Uninstall(ctx context.Context) error {
 	_ = c.clientset.AppsV1().Deployments(ns).Delete(ctx, name, options)
 
 	_ = c.CleanupLocalContainer(ctx)
-	log.Info("Done")
+	plog.G(ctx).Info("Done")
 	return nil
 }
 
@@ -79,13 +79,13 @@ func (c *ConnectOptions) LeaveAllProxyResources(ctx context.Context) (err error)
 		return
 	}
 	if cm == nil || cm.Data == nil || len(cm.Data[config.KeyEnvoy]) == 0 {
-		log.Infof("No proxy resources found")
+		plog.G(ctx).Infof("No proxy resources found")
 		return nil
 	}
 	var v = make([]*controlplane.Virtual, 0)
 	str := cm.Data[config.KeyEnvoy]
 	if err = yaml.Unmarshal([]byte(str), &v); err != nil {
-		log.Errorf("Unmarshal envoy config error: %v", err)
+		plog.G(ctx).Errorf("Unmarshal envoy config error: %v", err)
 		return
 	}
 	v4, _ := c.GetLocalTunIP()
@@ -93,24 +93,24 @@ func (c *ConnectOptions) LeaveAllProxyResources(ctx context.Context) (err error)
 		// deployments.apps.ry-server --> deployments.apps/ry-server
 		object, err := util.GetUnstructuredObject(c.factory, c.Namespace, workload)
 		if err != nil {
-			log.Errorf("Failed to get unstructured object: %v", err)
+			plog.G(ctx).Errorf("Failed to get unstructured object: %v", err)
 			return err
 		}
 		u := object.Object.(*unstructured.Unstructured)
 		templateSpec, _, err := util.GetPodTemplateSpecPath(u)
 		if err != nil {
-			log.Errorf("Failed to get template spec path: %v", err)
+			plog.G(ctx).Errorf("Failed to get template spec path: %v", err)
 			return err
 		}
 		var empty bool
-		empty, err = inject.UnPatchContainer(c.factory, c.clientset.CoreV1().ConfigMaps(c.Namespace), object, func(isFargateMode bool, rule *controlplane.Rule) bool {
+		empty, err = inject.UnPatchContainer(ctx, c.factory, c.clientset.CoreV1().ConfigMaps(c.Namespace), object, func(isFargateMode bool, rule *controlplane.Rule) bool {
 			if isFargateMode {
 				return c.IsMe(util.ConvertWorkloadToUid(workload), rule.Headers)
 			}
 			return rule.LocalTunIPv4 == v4
 		})
 		if err != nil {
-			log.Errorf("Failed to leave workload %s: %v", workload, err)
+			plog.G(ctx).Errorf("Failed to leave workload %s: %v", workload, err)
 			continue
 		}
 		if empty {

pkg/inject/controller.go

@@ -3,6 +3,7 @@ package inject
 import (
 	_ "embed"
 
+	log "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -38,10 +39,6 @@ func AddMeshContainer(spec *v1.PodTemplateSpec, nodeId string, c util.PodRouteCo
 	// remove envoy proxy containers if already exist
 	RemoveContainers(spec)
 
-	envoyLogLevel := "info"
-	if config.Debug {
-		envoyLogLevel = "debug"
-	}
 	spec.Spec.Containers = append(spec.Spec.Containers, v1.Container{
 		Name:    config.ContainerSidecarVPN,
 		Image:   config.Image,
@@ -137,7 +134,7 @@ kubevpn serve -L "tun:/localhost:8422?net=${TunIPv4}&route=${CIDR4}" -F "tcp://$
 		Command: []string{
 			"envoy",
 			"-l",
-			envoyLogLevel,
+			util.If(config.Debug, log.DebugLevel, log.InfoLevel).String(),
 			"--base-id",
 			"1",
 			"--service-node",
@@ -172,10 +169,6 @@ func AddEnvoyContainer(spec *v1.PodTemplateSpec, nodeId string, ipv6 bool) {
 	// remove envoy proxy containers if already exist
 	RemoveContainers(spec)
 
-	envoyLogLevel := "info"
-	if config.Debug {
-		envoyLogLevel = "debug"
-	}
 	spec.Spec.Containers = append(spec.Spec.Containers, v1.Container{
 		Name:    config.ContainerSidecarVPN,
 		Image:   config.Image,
@@ -205,7 +198,7 @@ kubevpn serve -L "ssh://:2222"`,
 		Command: []string{
 			"envoy",
 			"-l",
-			envoyLogLevel,
+			util.If(config.Debug, log.DebugLevel, log.InfoLevel).String(),
 			"--base-id",
 			"1",
 			"--service-node",

pkg/inject/fargate.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -23,6 +22,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -50,7 +50,7 @@ func InjectEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset *kuber
 	}
 	err = addEnvoyConfig(clientset.CoreV1().ConfigMaps(namespace), nodeID, c, headers, port, portmap)
 	if err != nil {
-		log.Errorf("Failed to add envoy config: %v", err)
+		plog.G(ctx).Errorf("Failed to add envoy config: %v", err)
 		return err
 	}
 
@@ -60,7 +60,7 @@ func InjectEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset *kuber
 		containerNames.Insert(container.Name)
 	}
 	if containerNames.HasAll(config.ContainerSidecarVPN, config.ContainerSidecarEnvoyProxy) {
-		log.Infof("Workload %s/%s has already been injected with sidecar", namespace, workload)
+		plog.G(ctx).Infof("Workload %s/%s has already been injected with sidecar", namespace, workload)
 		return
 	}
 
@@ -82,10 +82,10 @@ func InjectEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset *kuber
 	}
 	_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, bytes, &metav1.PatchOptions{})
 	if err != nil {
-		log.Errorf("Failed to patch resource: %s %s, err: %v", object.Mapping.Resource.Resource, object.Name, err)
+		plog.G(ctx).Errorf("Failed to patch resource: %s %s, err: %v", object.Mapping.Resource.Resource, object.Name, err)
 		return err
 	}
-	log.Infof("Patching workload %s", workload)
+	plog.G(ctx).Infof("Patching workload %s", workload)
 	err = util.RolloutStatus(ctx, f, namespace, workload, time.Minute*60)
 	if err != nil {
 		return err

pkg/inject/mesh.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -25,6 +24,7 @@ import (
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -74,7 +74,7 @@ func InjectVPNAndEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset
 
 	err = addEnvoyConfig(clientset, nodeID, c, headers, ports, portmap)
 	if err != nil {
-		log.Errorf("Failed to add envoy config: %v", err)
+		plog.G(ctx).Errorf("Failed to add envoy config: %v", err)
 		return err
 	}
 
@@ -84,7 +84,7 @@ func InjectVPNAndEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset
 		containerNames.Insert(container.Name)
 	}
 	if containerNames.HasAll(config.ContainerSidecarVPN, config.ContainerSidecarEnvoyProxy) {
-		log.Infof("Workload %s/%s has already been injected with sidecar", namespace, workload)
+		plog.G(ctx).Infof("Workload %s/%s has already been injected with sidecar", namespace, workload)
 		return nil
 	}
 
@@ -106,19 +106,19 @@ func InjectVPNAndEnvoySidecar(ctx context.Context, f cmdutil.Factory, clientset
 	}
 	_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, bytes, &metav1.PatchOptions{})
 	if err != nil {
-		log.Errorf("Failed to patch resource: %s %s, err: %v", object.Mapping.Resource.Resource, object.Name, err)
+		plog.G(ctx).Errorf("Failed to patch resource: %s %s, err: %v", object.Mapping.Resource.Resource, object.Name, err)
 		return err
 	}
-	log.Infof("Patching workload %s", workload)
+	plog.G(ctx).Infof("Patching workload %s", workload)
 	err = util.RolloutStatus(ctx, f, namespace, workload, time.Minute*60)
 	return err
 }
 
-func UnPatchContainer(factory cmdutil.Factory, mapInterface v12.ConfigMapInterface, object *runtimeresource.Info, isMeFunc func(isFargateMode bool, rule *controlplane.Rule) bool) (bool, error) {
+func UnPatchContainer(ctx context.Context, factory cmdutil.Factory, mapInterface v12.ConfigMapInterface, object *runtimeresource.Info, isMeFunc func(isFargateMode bool, rule *controlplane.Rule) bool) (bool, error) {
 	u := object.Object.(*unstructured.Unstructured)
 	templateSpec, depth, err := util.GetPodTemplateSpecPath(u)
 	if err != nil {
-		log.Errorf("Failed to get template spec path: %v", err)
+		plog.G(ctx).Errorf("Failed to get template spec path: %v", err)
 		return false, err
 	}
 
@@ -127,15 +127,15 @@ func UnPatchContainer(factory cmdutil.Factory, mapInterface v12.ConfigMapInterfa
 	var empty, found bool
 	empty, found, err = removeEnvoyConfig(mapInterface, nodeID, isMeFunc)
 	if err != nil {
-		log.Errorf("Failed to remove envoy config: %v", err)
+		plog.G(ctx).Errorf("Failed to remove envoy config: %v", err)
 		return false, err
 	}
 	if !found {
-		log.Infof("Not found proxy resource %s", workload)
+		plog.G(ctx).Infof("Not found proxy resource %s", workload)
 		return false, nil
 	}
 
-	log.Infof("Leaving workload %s", workload)
+	plog.G(ctx).Infof("Leaving workload %s", workload)
 
 	RemoveContainers(templateSpec)
 
@@ -143,14 +143,14 @@ func UnPatchContainer(factory cmdutil.Factory, mapInterface v12.ConfigMapInterfa
 		helper := pkgresource.NewHelper(object.Client, object.Mapping)
 		// pod without controller
 		if len(depth) == 0 {
-			log.Debugf("Workload %s is not under controller management", workload)
+			plog.G(ctx).Debugf("Workload %s is not under controller management", workload)
 			pod := &v1.Pod{ObjectMeta: templateSpec.ObjectMeta, Spec: templateSpec.Spec}
 			CleanupUselessInfo(pod)
-			err = CreateAfterDeletePod(factory, pod, helper)
+			err = CreateAfterDeletePod(ctx, factory, pod, helper)
 			return empty, err
 		}
 
-		log.Debugf("The %s is under controller management", workload)
+		plog.G(ctx).Debugf("The %s is under controller management", workload)
 		// resource with controller, like deployment,statefulset
 		var bytes []byte
 		bytes, err = json.Marshal([]P{
@@ -161,12 +161,12 @@ func UnPatchContainer(factory cmdutil.Factory, mapInterface v12.ConfigMapInterfa
 			},
 		})
 		if err != nil {
-			log.Errorf("Failed to generate json patch: %v", err)
+			plog.G(ctx).Errorf("Failed to generate json patch: %v", err)
 			return empty, err
 		}
 		_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, bytes, &metav1.PatchOptions{})
 		if err != nil {
-			log.Errorf("Failed to patch resource: %s %s: %v", object.Mapping.Resource.Resource, object.Name, err)
+			plog.G(ctx).Errorf("Failed to patch resource: %s %s: %v", object.Mapping.Resource.Resource, object.Name, err)
 			return empty, err
 		}
 	}

pkg/inject/proxy.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	v12 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -21,6 +20,7 @@ import (
 	"k8s.io/utils/pointer"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/controlplane"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	util2 "github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -47,7 +47,7 @@ func InjectVPNSidecar(ctx context.Context, f util.Factory, namespace, workload s
 	}
 	err = addEnvoyConfig(clientset.CoreV1().ConfigMaps(namespace), nodeID, c, nil, controlplane.ConvertContainerPort(ports...), portmap)
 	if err != nil {
-		log.Errorf("Failed to add envoy config: %v", err)
+		plog.G(ctx).Errorf("Failed to add envoy config: %v", err)
 		return err
 	}
 
@@ -56,16 +56,16 @@ func InjectVPNSidecar(ctx context.Context, f util.Factory, namespace, workload s
 	helper := resource.NewHelper(object.Client, object.Mapping)
 	// pods without controller
 	if len(path) == 0 {
-		log.Infof("Workload %s/%s is not controlled by any controller", namespace, workload)
+		plog.G(ctx).Infof("Workload %s/%s is not controlled by any controller", namespace, workload)
 		p := &v1.Pod{ObjectMeta: podTempSpec.ObjectMeta, Spec: podTempSpec.Spec}
 		CleanupUselessInfo(p)
-		if err = CreateAfterDeletePod(f, p, helper); err != nil {
+		if err = CreateAfterDeletePod(ctx, f, p, helper); err != nil {
 			return err
 		}
 	} else
 	// controllers
 	{
-		log.Debugf("The %s is under controller management", workload)
+		plog.G(ctx).Debugf("The %s is under controller management", workload)
 		p := []P{
 			{
 				Op:    "replace",
@@ -76,7 +76,7 @@ func InjectVPNSidecar(ctx context.Context, f util.Factory, namespace, workload s
 		marshal, _ := json.Marshal(append(p))
 		_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, marshal, &v12.PatchOptions{})
 		if err != nil {
-			log.Errorf("Failed to inject proxy container: %v, exiting...", err)
+			plog.G(ctx).Errorf("Failed to inject proxy container: %v, exiting...", err)
 			return err
 		}
 	}
@@ -84,12 +84,12 @@ func InjectVPNSidecar(ctx context.Context, f util.Factory, namespace, workload s
 	return err
 }
 
-func CreateAfterDeletePod(factory util.Factory, p *v1.Pod, helper *resource.Helper) error {
+func CreateAfterDeletePod(ctx context.Context, factory util.Factory, p *v1.Pod, helper *resource.Helper) error {
 	_, err := helper.DeleteWithOptions(p.Namespace, p.Name, &v12.DeleteOptions{
 		GracePeriodSeconds: pointer.Int64(0),
 	})
 	if err != nil {
-		log.Errorf("Failed to delete resource: %s %s, ignore, err: %v", p.Namespace, p.Name, err)
+		plog.G(ctx).Errorf("Failed to delete resource: %s %s, ignore, err: %v", p.Namespace, p.Name, err)
 	}
 	err = retry.OnError(wait.Backoff{
 		Steps:    10,
@@ -116,7 +116,7 @@ func CreateAfterDeletePod(factory util.Factory, p *v1.Pod, helper *resource.Help
 		if errors.IsAlreadyExists(err) {
 			return nil
 		}
-		log.Errorf("Failed to create resource: %s %s, err: %v", p.Namespace, p.Name, err)
+		plog.G(ctx).Errorf("Failed to create resource: %s %s, err: %v", p.Namespace, p.Name, err)
 		return err
 	}
 	return nil

pkg/log/context.go

@@ -0,0 +1,44 @@
+package log
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// G is a shorthand for [GetLogger].
+//
+// We may want to define this locally to a package to get package tagged log
+// messages.
+var G = GetLogger
+
+// L is an alias for the standard logger.
+var L = InitLoggerForServer()
+
+type loggerKey struct{}
+
+type loggerValue struct {
+	logger *log.Logger
+}
+
+// WithLogger returns a new context with the provided logger. Use in
+// combination with logger.WithField(s) for great effect.
+func WithLogger(ctx context.Context, logger *log.Logger) context.Context {
+	return context.WithValue(ctx, loggerKey{}, &loggerValue{logger: logger})
+}
+
+func WithoutLogger(ctx context.Context) context.Context {
+	if logger := ctx.Value(loggerKey{}); logger != nil {
+		logger.(*loggerValue).logger = nil
+	}
+	return ctx
+}
+
+// GetLogger retrieves the current logger from the context. If no logger is
+// available, the default logger is returned.
+func GetLogger(ctx context.Context) *log.Logger {
+	if logger := ctx.Value(loggerKey{}); logger != nil && logger.(*loggerValue).logger != nil {
+		return logger.(*loggerValue).logger
+	}
+	return L
+}

pkg/log/context_test.go

@@ -0,0 +1,25 @@
+package log
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestGetLoggerFromContext(t *testing.T) {
+	logger := InitLoggerForServer()
+	ctx := WithLogger(context.Background(), logger)
+	cancel, cancelFunc := context.WithCancel(ctx)
+	defer cancelFunc()
+	timeout, c := context.WithTimeout(cancel, time.Second*10)
+	defer c()
+	l := GetLogger(timeout)
+	if logger != l {
+		panic("not same")
+	}
+	cancel = WithoutLogger(cancel)
+	defaultLogger := GetLogger(cancel)
+	if defaultLogger != L {
+		panic("not same")
+	}
+}

pkg/log/logger.go

@@ -1,7 +1,9 @@
-package util
+package log
 
 import (
 	"fmt"
+	"io"
+	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -12,24 +14,30 @@ import (
 	"k8s.io/utils/ptr"
 )
 
-func InitLoggerForClient(debug bool) {
-	if debug {
-		log.SetLevel(log.DebugLevel)
-	} else {
-		log.SetLevel(log.InfoLevel)
-	}
-	log.SetReportCaller(false)
-	log.SetFormatter(&format{})
+func InitLoggerForClient() {
+	L = GetLoggerForClient(int32(log.InfoLevel), os.Stdout)
 }
 
-func InitLoggerForServer(debug bool) {
-	if debug {
-		log.SetLevel(log.DebugLevel)
-	} else {
-		log.SetLevel(log.InfoLevel)
+func GetLoggerForClient(level int32, out io.Writer) *log.Logger {
+	return &log.Logger{
+		Out:          out,
+		Formatter:    &format{},
+		Hooks:        make(log.LevelHooks),
+		Level:        log.Level(level),
+		ExitFunc:     os.Exit,
+		ReportCaller: false,
+	}
+}
+
+func InitLoggerForServer() *log.Logger {
+	return &log.Logger{
+		Out:          os.Stderr,
+		Formatter:    &format{},
+		Hooks:        make(log.LevelHooks),
+		Level:        log.DebugLevel,
+		ExitFunc:     os.Exit,
+		ReportCaller: true,
 	}
-	log.SetReportCaller(true)
-	log.SetFormatter(&serverFormat{})
 }
 
 type format struct {
@@ -84,7 +92,7 @@ func (g ServerEmitter) Emit(depth int, level glog.Level, timestamp time.Time, fo
 	message := fmt.Sprintf(format, args...)
 
 	// Emit the formatted result.
-	fmt.Fprintf(g.Writer, "%s %s:%d %s: %s\n",
+	_, _ = fmt.Fprintf(g.Writer, "%s %s:%d %s: %s\n",
 		timestamp.Format("2006-01-02 15:04:05"),
 		file,
 		line,

pkg/ssh/image.go

@@ -19,8 +19,9 @@ import (
 	"github.com/docker/docker/pkg/jsonmessage"
 	"github.com/moby/term"
 	"github.com/opencontainers/image-spec/specs-go/v1"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/crypto/ssh"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func GetClient() (*client.Client, *command.DockerCli, error) {
@@ -49,20 +50,20 @@ func GetClient() (*client.Client, *command.DockerCli, error) {
 func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarget string, out io.Writer) error {
 	client, cli, err := GetClient()
 	if err != nil {
-		log.Errorf("Failed to get docker client: %v", err)
+		plog.G(ctx).Errorf("Failed to get docker client: %v", err)
 		return err
 	}
 	// todo add flags? or detect k8s node runtime ?
 	platform := &v1.Platform{Architecture: "amd64", OS: "linux"}
 	err = PullImage(ctx, platform, client, cli, imageSource, out)
 	if err != nil {
-		log.Errorf("Failed to pull image: %v", err)
+		plog.G(ctx).Errorf("Failed to pull image: %v", err)
 		return err
 	}
 
 	err = client.ImageTag(ctx, imageSource, imageTarget)
 	if err != nil {
-		log.Errorf("Failed to tag image %s to %s: %v", imageSource, imageTarget, err)
+		plog.G(ctx).Errorf("Failed to tag image %s to %s: %v", imageSource, imageTarget, err)
 		return err
 	}
 
@@ -71,19 +72,19 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 		var distributionRef reference.Named
 		distributionRef, err = reference.ParseNormalizedNamed(imageTarget)
 		if err != nil {
-			log.Errorf("Failed to parse image name %s: %v", imageTarget, err)
+			plog.G(ctx).Errorf("Failed to parse image name %s: %v", imageTarget, err)
 			return err
 		}
 		var imgRefAndAuth trust.ImageRefAndAuth
 		imgRefAndAuth, err = trust.GetImageReferencesAndAuth(ctx, image.AuthResolver(cli), distributionRef.String())
 		if err != nil {
-			log.Errorf("Failed to get image auth: %v", err)
+			plog.G(ctx).Errorf("Failed to get image auth: %v", err)
 			return err
 		}
 		var encodedAuth string
 		encodedAuth, err = registrytypes.EncodeAuthConfig(*imgRefAndAuth.AuthConfig())
 		if err != nil {
-			log.Errorf("Failed to encode auth config to base64: %v", err)
+			plog.G(ctx).Errorf("Failed to encode auth config to base64: %v", err)
 			return err
 		}
 		requestPrivilege := command.RegistryAuthenticationPrivilegedFunc(cli, imgRefAndAuth.RepoInfo().Index, "push")
@@ -93,7 +94,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 			PrivilegeFunc: requestPrivilege,
 		})
 		if err != nil {
-			log.Errorf("Failed to push image %s, err: %v", imageTarget, err)
+			plog.G(ctx).Errorf("Failed to push image %s, err: %v", imageTarget, err)
 			return err
 		}
 		defer readCloser.Close()
@@ -103,7 +104,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 		outWarp := streams.NewOut(out)
 		err = jsonmessage.DisplayJSONMessagesToStream(readCloser, outWarp, nil)
 		if err != nil {
-			log.Errorf("Failed to display message, err: %v", err)
+			plog.G(ctx).Errorf("Failed to display message, err: %v", err)
 			return err
 		}
 		return nil
@@ -119,7 +120,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 	var responseReader io.ReadCloser
 	responseReader, err = client.ImageSave(ctx, []string{imageTarget})
 	if err != nil {
-		log.Errorf("Failed to save image %s: %v", imageTarget, err)
+		plog.G(ctx).Errorf("Failed to save image %s: %v", imageTarget, err)
 		return err
 	}
 	defer responseReader.Close()
@@ -127,7 +128,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 	if err != nil {
 		return err
 	}
-	log.Infof("Saving image %s to temp file %s", imageTarget, file.Name())
+	plog.G(ctx).Infof("Saving image %s to temp file %s", imageTarget, file.Name())
 	if _, err = io.Copy(file, responseReader); err != nil {
 		return err
 	}
@@ -136,19 +137,19 @@ func TransferImage(ctx context.Context, conf *SshConfig, imageSource, imageTarge
 	}
 	defer os.Remove(file.Name())
 
-	log.Infof("Transferring image %s", imageTarget)
+	plog.G(ctx).Infof("Transferring image %s", imageTarget)
 	filename := filepath.Base(file.Name())
 	cmd := fmt.Sprintf(
 		"(docker load -i ~/.kubevpn/%s && docker push %s) || (nerdctl image load -i ~/.kubevpn/%s && nerdctl image push %s)",
 		filename, imageTarget,
 		filename, imageTarget,
 	)
-	stdout := log.StandardLogger().Out
-	err = SCPAndExec(stdout, stdout, sshClient, file.Name(), filename, []string{cmd}...)
+	stdout := plog.G(ctx).Out
+	err = SCPAndExec(ctx, stdout, stdout, sshClient, file.Name(), filename, []string{cmd}...)
 	if err != nil {
 		return err
 	}
-	log.Infof("Loaded image: %s", imageTarget)
+	plog.G(ctx).Infof("Loaded image: %s", imageTarget)
 	return nil
 }
 
@@ -161,19 +162,19 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, d
 	}
 	distributionRef, err := reference.ParseNormalizedNamed(img)
 	if err != nil {
-		log.Errorf("Failed to parse image name %s: %v", img, err)
+		plog.G(ctx).Errorf("Failed to parse image name %s: %v", img, err)
 		return err
 	}
 	var imgRefAndAuth trust.ImageRefAndAuth
 	imgRefAndAuth, err = trust.GetImageReferencesAndAuth(ctx, image.AuthResolver(dockerCli), distributionRef.String())
 	if err != nil {
-		log.Errorf("Failed to get image auth: %v", err)
+		plog.G(ctx).Errorf("Failed to get image auth: %v", err)
 		return err
 	}
 	var encodedAuth string
 	encodedAuth, err = registrytypes.EncodeAuthConfig(*imgRefAndAuth.AuthConfig())
 	if err != nil {
-		log.Errorf("Failed to encode auth config to base64: %v", err)
+		plog.G(ctx).Errorf("Failed to encode auth config to base64: %v", err)
 		return err
 	}
 	requestPrivilege := command.RegistryAuthenticationPrivilegedFunc(dockerCli, imgRefAndAuth.RepoInfo().Index, "pull")
@@ -184,7 +185,7 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, d
 		Platform:      plat,
 	})
 	if err != nil {
-		log.Errorf("Failed to pull image %s: %v", img, err)
+		plog.G(ctx).Errorf("Failed to pull image %s: %v", img, err)
 		return err
 	}
 	defer readCloser.Close()
@@ -194,7 +195,7 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, d
 	outWarp := streams.NewOut(out)
 	err = jsonmessage.DisplayJSONMessagesToStream(readCloser, outWarp, nil)
 	if err != nil {
-		log.Errorf("Failed to display message, err: %v", err)
+		plog.G(ctx).Errorf("Failed to display message, err: %v", err)
 		return err
 	}
 	return nil

pkg/ssh/reverse.go

@@ -11,11 +11,11 @@ package ssh
 
 import (
 	"context"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"net"
 	"net/netip"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -33,14 +33,14 @@ func ExposeLocalPortToRemote(ctx context.Context, remoteSSHServer, remotePort, l
 	// Connect to SSH remote server using serverEndpoint
 	serverConn, err := ssh.Dial("tcp", remoteSSHServer.String(), sshConfig)
 	if err != nil {
-		log.Errorf("Dial into remote server error: %s", err)
+		plog.G(ctx).Errorf("Dial into remote server error: %s", err)
 		return err
 	}
 
 	// Listen on remote server port
 	listener, err := serverConn.Listen("tcp", remotePort.String())
 	if err != nil {
-		log.Errorf("Listen open port on remote server error: %s", err)
+		plog.G(ctx).Errorf("Listen open port on remote server error: %s", err)
 		return err
 	}
 	defer listener.Close()
@@ -49,7 +49,7 @@ func ExposeLocalPortToRemote(ctx context.Context, remoteSSHServer, remotePort, l
 	for {
 		client, err := listener.Accept()
 		if err != nil {
-			log.Errorf("Accept on remote service error: %s", err)
+			plog.G(ctx).Errorf("Accept on remote service error: %s", err)
 			return err
 		}
 		go func(client net.Conn) {
@@ -57,7 +57,7 @@ func ExposeLocalPortToRemote(ctx context.Context, remoteSSHServer, remotePort, l
 			// Open a (local) connection to localEndpoint whose content will be forwarded so serverEndpoint
 			local, err := net.Dial("tcp", localPort.String())
 			if err != nil {
-				log.Errorf("Dial INTO local service error: %s", err)
+				plog.G(ctx).Errorf("Dial INTO local service error: %s", err)
 				return
 			}
 			defer local.Close()

pkg/ssh/scp.go

@@ -1,20 +1,22 @@
 package ssh
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"os"
 
 	"github.com/schollz/progressbar/v3"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/crypto/ssh"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // SCPAndExec copy file to remote and exec command
-func SCPAndExec(stdout, stderr io.Writer, client *ssh.Client, filename, to string, commands ...string) error {
-	err := SCP(client, stdout, stderr, filename, to)
+func SCPAndExec(ctx context.Context, stdout, stderr io.Writer, client *ssh.Client, filename, to string, commands ...string) error {
+	err := SCP(ctx, client, stdout, stderr, filename, to)
 	if err != nil {
-		log.Errorf("Copy file to remote error: %s", err)
+		plog.G(ctx).Errorf("Copy file to remote error: %s", err)
 		return err
 	}
 	for _, command := range commands {
@@ -25,17 +27,17 @@ func SCPAndExec(stdout, stderr io.Writer, client *ssh.Client, filename, to strin
 		}
 		output, err := session.CombinedOutput(command)
 		if err != nil {
-			log.Error(string(output))
+			plog.G(ctx).Error(string(output))
 			return err
 		} else {
-			log.Info(string(output))
+			plog.G(ctx).Info(string(output))
 		}
 	}
 	return nil
 }
 
 // SCP https://blog.neilpang.com/%E6%94%B6%E8%97%8F-scp-secure-copy%E5%8D%8F%E8%AE%AE/
-func SCP(client *ssh.Client, stdout, stderr io.Writer, filename, to string) error {
+func SCP(ctx context.Context, client *ssh.Client, stdout, stderr io.Writer, filename, to string) error {
 	file, err := os.Open(filename)
 	if err != nil {
 		return err
@@ -55,9 +57,9 @@ func SCP(client *ssh.Client, stdout, stderr io.Writer, filename, to string) erro
 		defer w.Close()
 		fmt.Fprintln(w, "D0755", 0, ".kubevpn") // mkdir
 		fmt.Fprintln(w, "C0644", stat.Size(), to)
-		err := sCopy(w, file, stat.Size(), stdout, stderr)
+		err := sCopy(ctx, w, file, stat.Size(), stdout, stderr)
 		if err != nil {
-			log.Errorf("Failed to transfer file to remote: %v", err)
+			plog.G(ctx).Errorf("Failed to transfer file to remote: %v", err)
 			return
 		}
 		fmt.Fprint(w, "\x00") // transfer end with \x00
@@ -65,7 +67,7 @@ func SCP(client *ssh.Client, stdout, stderr io.Writer, filename, to string) erro
 	return sess.Run("scp -tr ./")
 }
 
-func sCopy(dst io.Writer, src io.Reader, size int64, stdout, stderr io.Writer) error {
+func sCopy(ctx context.Context, dst io.Writer, src io.Reader, size int64, stdout, stderr io.Writer) error {
 	total := float64(size) / 1024 / 1024
 	s := fmt.Sprintf("Length: %d (%0.2fM)", size, total)
 	io.WriteString(stdout, s+"\n")
@@ -90,11 +92,11 @@ func sCopy(dst io.Writer, src io.Reader, size int64, stdout, stderr io.Writer) e
 	buf := make([]byte, 10<<(10*2)) // 10M
 	written, err := io.CopyBuffer(io.MultiWriter(dst, bar), src, buf)
 	if err != nil {
-		log.Errorf("Failed to transfer file to remote: %v", err)
+		plog.G(ctx).Errorf("Failed to transfer file to remote: %v", err)
 		return err
 	}
 	if written != size {
-		log.Errorf("Failed to transfer file to remote: written size %d but actuall is %d", written, size)
+		plog.G(ctx).Errorf("Failed to transfer file to remote: written size %d but actuall is %d", written, size)
 		return err
 	}
 	return nil

pkg/ssh/ssh.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/kevinburke/ssh_config"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -30,10 +29,10 @@ import (
 	"k8s.io/client-go/util/homedir"
 	"k8s.io/kubectl/pkg/cmd/util"
 	"k8s.io/utils/pointer"
-	"k8s.io/utils/ptr"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/rpc"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	pkgutil "github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -142,7 +141,7 @@ func DialSshRemote(ctx context.Context, conf *SshConfig, stopChan <-chan struct{
 		//go func() {
 		//	err2 := keepAlive(remote, conn, ctx.Done())
 		//	if err2 != nil {
-		//		log.Debugf("Failed to send keep-alive request: %v", err2)
+		//		plog.G(ctx).Debugf("Failed to send keep-alive request: %v", err2)
 		//	}
 		//}()
 	}
@@ -216,7 +215,7 @@ func RemoteRun(client *ssh.Client, cmd string, env map[string]string) (output []
 		// /etc/ssh/sshd_config
 		// AcceptEnv DEBIAN_FRONTEND
 		if err = session.Setenv(k, v); err != nil {
-			log.Warn(err)
+			plog.G(context.Background()).Warn(err)
 			err = nil
 		}
 	}
@@ -261,7 +260,7 @@ func copyStream(ctx context.Context, local net.Conn, remote net.Conn) {
 		defer config.LPool.Put(buf[:])
 		_, err := io.CopyBuffer(local, remote, buf)
 		if err != nil && !errors.Is(err, net.ErrClosed) && !errors.Is(err, io.EOF) {
-			log.Debugf("Failed to copy remote -> local: %s", err)
+			plog.G(ctx).Debugf("Failed to copy remote -> local: %s", err)
 		}
 		pkgutil.SafeWrite(chDone, true)
 	}()
@@ -272,7 +271,7 @@ func copyStream(ctx context.Context, local net.Conn, remote net.Conn) {
 		defer config.LPool.Put(buf[:])
 		_, err := io.CopyBuffer(remote, local, buf)
 		if err != nil && !errors.Is(err, net.ErrClosed) && !errors.Is(err, io.EOF) {
-			log.Debugf("Failed to copy local -> remote: %s", err)
+			plog.G(ctx).Debugf("Failed to copy local -> remote: %s", err)
 		}
 		pkgutil.SafeWrite(chDone, true)
 	}()
@@ -551,7 +550,7 @@ func PortMapUntil(ctx context.Context, conf *SshConfig, remote, local netip.Addr
 	if e != nil {
 		return e
 	}
-	log.Debugf("SSH listening on local %s forward to %s", local.String(), remote.String())
+	plog.G(ctx).Debugf("SSH listening on local %s forward to %s", local.String(), remote.String())
 
 	go func() {
 		defer localListen.Close()
@@ -563,7 +562,7 @@ func PortMapUntil(ctx context.Context, conf *SshConfig, remote, local netip.Addr
 		for ctx1.Err() == nil {
 			localConn, err1 := localListen.Accept()
 			if err1 != nil {
-				log.Debugf("Failed to accept ssh conn: %v", err1)
+				plog.G(ctx).Debugf("Failed to accept ssh conn: %v", err1)
 				continue
 			}
 			go func() {
@@ -574,10 +573,10 @@ func PortMapUntil(ctx context.Context, conf *SshConfig, remote, local netip.Addr
 					var openChannelError *ssh.OpenChannelError
 					// if ssh server not permitted ssh port-forward, do nothing until exit
 					if errors.As(err, &openChannelError) && openChannelError.Reason == ssh.Prohibited {
-						log.Debugf("Failed to open ssh port-forward: %s: %v", remote.String(), err)
+						plog.G(ctx).Debugf("Failed to open ssh port-forward: %s: %v", remote.String(), err)
 						cancelFunc1()
 					}
-					log.Debugf("Failed to get remote conn: %v", err)
+					plog.G(ctx).Debugf("Failed to get remote conn: %v", err)
 					return
 				}
 
@@ -599,7 +598,7 @@ func getRemoteConn(ctx context.Context, sshClientChan chan *sshClient, conf *Ssh
 		defer cancelFunc1()
 		conn, err = cli.DialContext(ctx1, "tcp", remote.String())
 		if err != nil {
-			log.Debugf("Failed to dial remote address %s: %s", remote.String(), err)
+			plog.G(ctx).Debugf("Failed to dial remote address %s: %s", remote.String(), err)
 			_ = cli.Close()
 			return nil, err
 		}
@@ -617,14 +616,14 @@ func getRemoteConn(ctx context.Context, sshClientChan chan *sshClient, conf *Ssh
 		var client *ssh.Client
 		client, err = DialSshRemote(ctx2, conf, ctx1.Done())
 		if err != nil {
-			log.Debugf("Failed to dial remote ssh server: %v", err)
+			plog.G(ctx).Debugf("Failed to dial remote ssh server: %v", err)
 			return nil, err
 		}
 		ctx3, cancelFunc3 := context.WithTimeout(ctx, time.Second*10)
 		defer cancelFunc3()
 		conn, err = client.DialContext(ctx3, "tcp", remote.String())
 		if err != nil {
-			log.Debugf("Failed to dial remote addr: %s: %v", remote.String(), err)
+			plog.G(ctx).Debugf("Failed to dial remote addr: %s: %v", remote.String(), err)
 			client.Close()
 			return nil, err
 		}
@@ -798,14 +797,15 @@ func SshJump(ctx context.Context, conf *SshConfig, flags *pflag.FlagSet, print b
 	}
 
 	if print {
-		log.Infof("Waiting jump to bastion host...")
-		log.Debugf("Root daemon jumping to ssh host for kubeconfig %s ...", ptr.Deref(configFlags.KubeConfig, ""))
+		plog.G(ctx).Infof("Waiting jump to bastion host...")
+		plog.G(ctx).Infof("Jump ssh bastion host to apiserver: %s", cluster.Server)
 	} else {
-		log.Debugf("User daemon jumping to ssh host for kubeconfig %s ...", ptr.Deref(configFlags.KubeConfig, ""))
+		plog.G(ctx).Debugf("Waiting jump to bastion host...")
+		plog.G(ctx).Debugf("Jump ssh bastion host to apiserver: %s", cluster.Server)
 	}
 	err = PortMapUntil(ctx, conf, remote, local)
 	if err != nil {
-		log.Errorf("SSH port map error: %v", err)
+		plog.G(ctx).Errorf("SSH port map error: %v", err)
 		return
 	}
 
@@ -842,37 +842,17 @@ func SshJump(ctx context.Context, conf *SshConfig, flags *pflag.FlagSet, print b
 	}
 	if print {
 		msg := fmt.Sprintf("To use: export KUBECONFIG=%s", temp.Name())
-		PrintLine(log.Info, msg)
-		log.Debugf("Root daemon jump ssh bastion host with kubeconfig: %s", temp.Name())
+		plog.G(ctx).Info(pkgutil.PrintStr(msg))
+		plog.G(ctx).Infof("Use temporary kubeconfig: %s", temp.Name())
 	} else {
-		log.Debugf("User daemon jump ssh bastion host with kubeconfig: %s", temp.Name())
+		msg := fmt.Sprintf("To use: export KUBECONFIG=%s", temp.Name())
+		plog.G(ctx).Debugf(pkgutil.PrintStr(msg))
+		plog.G(ctx).Debugf("Use temporary kubeconfig: %s", temp.Name())
 	}
 	path = temp.Name()
 	return
 }
 
-func PrintLine(f func(...any), msg ...string) {
-	var length = -1
-	for _, s := range msg {
-		length = max(len(s), length)
-	}
-	if f == nil {
-		f = func(a ...any) {
-			fmt.Println(a...)
-		}
-	}
-	line := "+" + strings.Repeat("-", length+2) + "+"
-	f(line)
-	for _, s := range msg {
-		var padding string
-		if length != len(s) {
-			padding = strings.Repeat(" ", length-len(s))
-		}
-		f(fmt.Sprintf("| %s%s |", s, padding))
-	}
-	f(line)
-}
-
 func SshJumpAndSetEnv(ctx context.Context, conf *SshConfig, flags *pflag.FlagSet, print bool) error {
 	if conf.Addr == "" && conf.ConfigAlias == "" {
 		return nil

pkg/test/local.go

@@ -1,12 +1,12 @@
 package main
 
 import (
+	"context"
 	"io"
 	"net"
 
 	"github.com/containernetworking/cni/pkg/types"
-	log "github.com/sirupsen/logrus"
-
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/tun"
 )
 
@@ -35,12 +35,12 @@ func main() {
 	var tunConn net.Conn
 	tunConn, err = listener.Accept()
 	if err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	defer tunConn.Close()
 	tcpConn, err := net.Dial("tcp", ":1080")
 	if err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	go io.Copy(tunConn, tcpConn)
 	io.Copy(tcpConn, tunConn)

pkg/test/server/server.go

@@ -1,11 +1,11 @@
 package main
 
 import (
+	"context"
 	"io"
 	"net"
 
-	log "github.com/sirupsen/logrus"
-
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/tun"
 )
 
@@ -23,7 +23,7 @@ func main() {
 
 	tcpListener, err := net.Listen("tcp", ":1080")
 	if err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	for {
 		tcpConn, err := tcpListener.Accept()

pkg/tun/tun.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/containernetworking/cni/pkg/types"
-	log "github.com/sirupsen/logrus"
+	pkgerr "github.com/pkg/errors"
 	"golang.zx2c4.com/wireguard/device"
 	"golang.zx2c4.com/wireguard/tun"
 
@@ -40,13 +40,11 @@ func Listener(config Config) (net.Listener, error) {
 		config: config,
 	}
 
-	conn, ifce, err := createTun(config)
+	conn, _, err := createTun(config)
 	if err != nil {
-		log.Errorf("Create tun device error: %v", err)
+		err = pkgerr.Wrap(err, "create tun device failed")
 		return nil, err
 	}
-	addrs, _ := ifce.Addrs()
-	log.Debugf("[TUN] %s: name: %s, mtu: %d, addrs: %s", conn.LocalAddr(), ifce.Name, ifce.MTU, addrs)
 
 	ln.addr = conn.LocalAddr()
 	ln.conns <- conn

pkg/tun/tun_darwin.go

@@ -10,7 +10,7 @@ import (
 	"unsafe"
 
 	"github.com/containernetworking/cni/pkg/types"
-	log "github.com/sirupsen/logrus"
+	pkgerr "github.com/pkg/errors"
 	"golang.org/x/net/route"
 	"golang.org/x/sys/unix"
 	"golang.zx2c4.com/wireguard/tun"
@@ -76,7 +76,7 @@ func createTun(cfg Config) (conn net.Conn, itf *net.Interface, err error) {
 	}
 
 	if err = addTunRoutes(name, cfg.Routes...); err != nil {
-		log.Errorf("Add tun routes failed: %v", err)
+		err = pkgerr.Wrap(err, "Add tun routes failed")
 		return
 	}
 

pkg/tun/tun_windows.go

@@ -3,6 +3,7 @@
 package tun
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"net/netip"
@@ -12,11 +13,12 @@ import (
 
 	"github.com/containernetworking/cni/pkg/types"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/sys/windows"
 	wintun "golang.zx2c4.com/wintun"
 	wireguardtun "golang.zx2c4.com/wireguard/tun"
 	"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func createTun(cfg Config) (conn net.Conn, itf *net.Interface, err error) {
@@ -152,7 +154,7 @@ func (c *winTunConn) Close() error {
 	defer func() {
 		defer func() {
 			if err := recover(); err != nil {
-				log.Error(err)
+				plog.G(context.Background()).Error(err)
 			}
 		}()
 		tun := c.ifce.(*wireguardtun.NativeTun)

pkg/upgrade/upgrade.go

@@ -10,10 +10,10 @@ import (
 	"strings"
 
 	goversion "github.com/hashicorp/go-version"
-	log "github.com/sirupsen/logrus"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/daemon/elevate"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 	"github.com/wencaiwulue/kubevpn/v2/pkg/util"
 )
 
@@ -36,9 +36,9 @@ func Main(ctx context.Context, client *http.Client, url string) error {
 		return err
 	}
 
-	log.Infof("Upgrade daemon...")
+	plog.G(ctx).Infof("Upgrade daemon...")
 	err = daemon.StartupDaemon(context.Background())
-	log.Info("Done")
+	plog.G(ctx).Info("Done")
 	return err
 }
 

pkg/util/cidr.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/containernetworking/cni/libcni"
-	log "github.com/sirupsen/logrus"
 	v13 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -24,6 +23,7 @@ import (
 	"k8s.io/utils/ptr"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // GetCIDRElegant
@@ -37,17 +37,17 @@ func GetCIDRElegant(ctx context.Context, clientset *kubernetes.Clientset, restco
 	}()
 
 	var result []*net.IPNet
-	log.Infoln("Getting network CIDR from cluster info...")
+	plog.G(ctx).Infoln("Getting network CIDR from cluster info...")
 	info, err := GetCIDRByDumpClusterInfo(ctx, clientset)
 	if err == nil {
-		log.Debugf("Getting network CIDR from cluster info successfully")
+		plog.G(ctx).Debugf("Getting network CIDR from cluster info successfully")
 		result = append(result, info...)
 	}
 
-	log.Infoln("Getting network CIDR from CNI...")
+	plog.G(ctx).Infoln("Getting network CIDR from CNI...")
 	cni, err := GetCIDRFromCNI(ctx, clientset, restconfig, namespace)
 	if err == nil {
-		log.Debugf("Getting network CIDR from CNI successfully")
+		plog.G(ctx).Debugf("Getting network CIDR from CNI successfully")
 		result = append(result, cni...)
 	}
 
@@ -61,10 +61,10 @@ func GetCIDRElegant(ctx context.Context, clientset *kubernetes.Clientset, restco
 		result = append(result, svc)
 	}
 
-	log.Infoln("Getting network CIDR from services...")
+	plog.G(ctx).Infoln("Getting network CIDR from services...")
 	pod, err = GetPodCIDRFromPod(ctx, clientset, namespace, svc)
 	if err == nil {
-		log.Debugf("Getting network CIDR from services successfully")
+		plog.G(ctx).Debugf("Getting network CIDR from services successfully")
 		result = append(result, pod...)
 	}
 
@@ -294,7 +294,7 @@ func GetPodCIDRFromCNI(ctx context.Context, clientset *kubernetes.Clientset, res
 	if err != nil {
 		return nil, err
 	}
-	log.Infoln("Get CNI config", configList.Name)
+	plog.G(ctx).Infoln("Get CNI config", configList.Name)
 	var cidr []*net.IPNet
 	for _, plugin := range configList.Plugins {
 		switch plugin.Network.Type {

pkg/util/cidr_test.go

@@ -5,11 +5,12 @@ import (
 	"fmt"
 	"testing"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/kubectl/pkg/cmd/util"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 var (
@@ -26,16 +27,16 @@ func before() {
 	f = util.NewFactory(util.NewMatchVersionFlags(configFlags))
 
 	if restconfig, err = f.ToRESTConfig(); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	if restclient, err = rest.RESTClientFor(restconfig); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	if clientset, err = kubernetes.NewForConfig(restconfig); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 	if namespace, _, err = f.ToRawKubeConfigLoader().Namespace(); err != nil {
-		log.Fatal(err)
+		plog.G(context.Background()).Fatal(err)
 	}
 }
 

pkg/util/file.go

@@ -10,8 +10,6 @@ import (
 	"path/filepath"
 	"strings"
 	"time"
-
-	log "github.com/sirupsen/logrus"
 )
 
 func DownloadFileWithName(uri, name string) (string, error) {
@@ -42,7 +40,6 @@ func DownloadFileWithName(uri, name string) (string, error) {
 		return "", fmt.Errorf("failed to save file %s. error: %v", file, err)
 	}
 
-	log.Infof("Downloaded file %s", file)
 	return file, nil
 }
 

pkg/util/grpc.go

@@ -1,15 +1,17 @@
 package util
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"runtime/debug"
-	
-	"github.com/sirupsen/logrus"
+
 	"google.golang.org/grpc"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 type Printable interface {
@@ -81,7 +83,7 @@ func CopyAndConvertGRPCStream[I any, O any](r grpc.ClientStream, w grpc.ServerSt
 
 func HandleCrash() {
 	if r := recover(); r != nil {
-		logrus.Panic(fmt.Sprintf("Panic: %s", string(debug.Stack())))
+		plog.GetLogger(context.Background()).Panic(fmt.Sprintf("Panic: %s", string(debug.Stack())))
 		panic(r)
 	}
 }

pkg/util/krew/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
@@ -10,7 +11,7 @@ import (
 	"sync"
 	"text/template"
 
-	log "github.com/sirupsen/logrus"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 func main() {
@@ -72,7 +73,7 @@ func main() {
 			for k := 0; k < 10; k++ {
 				asset, err2 := GetSha256ForAsset(link)
 				if err2 != nil {
-					log.Error(err2)
+					plog.G(context.Background()).Error(err2)
 					continue
 				}
 				sha256Map[link] = asset

pkg/util/krew/sha256.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
@@ -10,7 +11,7 @@ import (
 	"path/filepath"
 	"time"
 
-	log "github.com/sirupsen/logrus"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 const retries = 4
@@ -44,7 +45,7 @@ func DownloadFileWithName(uri, name string) (string, error) {
 		return "", fmt.Errorf("failed to save file %s. error: %v", file, err)
 	}
 
-	log.Infof("Downloaded file %s", file)
+	plog.G(context.Background()).Infof("Downloaded file %s", file)
 	return file, nil
 }
 

pkg/util/krew/template.go

@@ -2,12 +2,13 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"path"
 	"strings"
 	"text/template"
 
-	log "github.com/sirupsen/logrus"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // InvalidPluginSpecError is invalid plugin spec error
@@ -43,7 +44,7 @@ func ProcessTemplate(templateFile string, values interface{}, sha256Map map[stri
 
 // RenderTemplate process the .krew.yaml template for the release request
 func RenderTemplate(templateFile string, values interface{}, sha256Map map[string]string) ([]byte, error) {
-	log.Debugf("Started processing of template %s", templateFile)
+	plog.G(context.Background()).Debugf("Started processing of template %s", templateFile)
 	name := path.Base(templateFile)
 	t := template.New(name).Funcs(map[string]interface{}{
 		"indent": indent,
@@ -64,7 +65,7 @@ func RenderTemplate(templateFile string, values interface{}, sha256Map map[strin
 				panic(err)
 			}
 
-			log.Infof("Getting sha256 for %s", buf.String())
+			plog.G(context.Background()).Infof("Getting sha256 for %s", buf.String())
 			sha256, ok := sha256Map[buf.String()]
 			if !ok {
 				panic(fmt.Errorf("can not get sha256 for link %s", buf.String()))
@@ -86,6 +87,6 @@ func RenderTemplate(templateFile string, values interface{}, sha256Map map[strin
 		return nil, err
 	}
 
-	log.Debugf("Completed processing of template")
+	plog.G(context.Background()).Debugf("Completed processing of template")
 	return buf.Bytes(), nil
 }

pkg/util/networkpolicy_windows.go

@@ -9,10 +9,10 @@ import (
 	"syscall"
 	"time"
 
-	log "github.com/sirupsen/logrus"
 	"golang.org/x/text/encoding/simplifiedchinese"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 /**
@@ -63,7 +63,7 @@ func DeleteBlockFirewallRule(ctx context.Context) {
 			if b, err = decode(out); err == nil {
 				s = string(b)
 			}
-			log.Debugf("failed to delete firewall rule: %v", s)
+			plog.G(ctx).Debugf("failed to delete firewall rule: %v", s)
 		}*/
 	}
 
@@ -117,7 +117,7 @@ func AddAllowFirewallRule(ctx context.Context) {
 		} else {
 			s = string(out)
 		}
-		log.Infof("Failed to exec command: %s, output: %s", cmd.Args, s)
+		plog.G(ctx).Infof("Failed to exec command: %s, output: %s", cmd.Args, s)
 	}
 }
 
@@ -139,7 +139,7 @@ func DeleteAllowFirewallRule(ctx context.Context) {
 		} else {
 			s = string(out)
 		}
-		log.Errorf("Failed to exec command: %s, output: %s", cmd.Args, s)
+		plog.G(ctx).Errorf("Failed to exec command: %s, output: %s", cmd.Args, s)
 	}
 }
 
@@ -160,7 +160,7 @@ func FindAllowFirewallRule(ctx context.Context) bool {
 		if b, err = decode(out); err == nil {
 			s = string(b)
 		}
-		log.Debugf("Find firewall %s, output: %s", config.ConfigMapPodTrafficManager, s)
+		plog.G(ctx).Debugf("Find firewall %s, output: %s", config.ConfigMapPodTrafficManager, s)
 		return false
 	} else {
 		return true

pkg/util/pod.go

@@ -17,7 +17,6 @@ import (
 	"github.com/hashicorp/go-version"
 	"github.com/moby/term"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -41,6 +40,7 @@ import (
 	pkgclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/wencaiwulue/kubevpn/v2/pkg/config"
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 type PodRouteConfig struct {
@@ -155,7 +155,7 @@ func PortForwardPod(config *rest.Config, clientset *rest.RESTClient, podName, na
 		URL()
 	transport, upgrader, err := spdy.RoundTripperFor(config)
 	if err != nil {
-		log.Errorf("Create spdy roundtripper error: %s", err.Error())
+		plog.G(context.Background()).Errorf("Create spdy roundtripper error: %s", err.Error())
 		return err
 	}
 	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url)
@@ -171,7 +171,6 @@ func PortForwardPod(config *rest.Config, clientset *rest.RESTClient, podName, na
 	}
 	forwarder, err := portforward.New(dialer, portPair, stopChan, readyChan, out, errOut)
 	if err != nil {
-		log.Errorf("Create port forward error: %s", err.Error())
 		return err
 	}
 
@@ -184,7 +183,6 @@ func PortForwardPod(config *rest.Config, clientset *rest.RESTClient, podName, na
 
 	select {
 	case err = <-errChan:
-		log.Debugf("Forward port error: %v", err)
 		return err
 	case <-stopChan:
 		return nil
@@ -271,7 +269,7 @@ func WaitPodToBeReady(ctx context.Context, podInterface v12.PodInterface, select
 				PrintStatus(podT, sb)
 
 				if last != sb.String() {
-					log.Infof(sb.String())
+					plog.G(ctx).Infof(sb.String())
 				}
 				last = sb.String()
 				if podutils.IsPodReady(podT) && func() bool {
@@ -343,7 +341,7 @@ func CheckPodStatus(ctx context.Context, cancelFunc context.CancelFunc, podName
 				return err
 			})
 		if err != nil {
-			log.Debugf("Failed to get Pod %s: %v", podName, err)
+			plog.G(ctx).Debugf("Failed to get Pod %s: %v", podName, err)
 			cancelFunc()
 		}
 	}
@@ -356,7 +354,7 @@ func CheckPodStatus(ctx context.Context, cancelFunc context.CancelFunc, podName
 				FieldSelector: fields.OneTermEqualSelector("metadata.name", podName).String(),
 			})
 			if err != nil {
-				log.Debugf("Failed to watch Pod %s: %v", podName, err)
+				plog.G(ctx).Debugf("Failed to watch Pod %s: %v", podName, err)
 				return
 			}
 			defer w.Stop()
@@ -370,7 +368,7 @@ func CheckPodStatus(ctx context.Context, cancelFunc context.CancelFunc, podName
 				}
 				switch e.Type {
 				case watch.Deleted:
-					log.Debugf("Pod %s is deleted", podName)
+					plog.G(ctx).Debugf("Pod %s is deleted", podName)
 					cancelFunc()
 					return
 				case watch.Error:
@@ -392,7 +390,7 @@ func CheckPortStatus(ctx context.Context, cancelFunc context.CancelFunc, readyCh
 	select {
 	case <-readyChan:
 	case <-ticker.C:
-		log.Debugf("Wait port-forward to be ready timeout")
+		plog.G(ctx).Debugf("Wait port-forward to be ready timeout")
 		return
 	case <-ctx.Done():
 		return
@@ -403,7 +401,7 @@ func CheckPortStatus(ctx context.Context, cancelFunc context.CancelFunc, readyCh
 		conn, err := lc.Listen(ctx, "tcp", net.JoinHostPort("127.0.0.1", localGvisorTCPPort))
 		if err == nil {
 			_ = conn.Close()
-			log.Debugf("Local port: %s is free", localGvisorTCPPort)
+			plog.G(ctx).Debugf("Local port: %s is free", localGvisorTCPPort)
 			return
 		}
 		time.Sleep(time.Second * 1)
@@ -497,7 +495,7 @@ func UpdateImage(ctx context.Context, factory util.Factory, ns string, deployNam
 		return nil
 	}
 
-	log.Infof("Found newer image %s, set image from %s to it...", image, deployment.Spec.Template.Spec.Containers[0].Image)
+	plog.G(ctx).Infof("Found newer image %s, set image from %s to it...", image, deployment.Spec.Template.Spec.Containers[0].Image)
 	for i := range deployment.Spec.Template.Spec.Containers {
 		deployment.Spec.Template.Spec.Containers[i].Image = image
 	}

pkg/util/port.go

@@ -8,8 +8,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
+
+	plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
 )
 
 // ParsePort [tcp/udp]/remote:local
@@ -67,7 +68,7 @@ func GetAvailableTCPPortOrDie() (int, error) {
 }
 
 func WaitPortToBeFree(ctx context.Context, port int) error {
-	logrus.Infoln(fmt.Sprintf("Wait port %v to be free...", port))
+	plog.G(ctx).Infoln(fmt.Sprintf("Wait port %v to be free...", port))
 	ticker := time.NewTicker(time.Second * 2)
 	defer ticker.Stop()
 	for {
@@ -76,7 +77,7 @@ func WaitPortToBeFree(ctx context.Context, port int) error {
 			return fmt.Errorf("wait port %d to be free timeout", port)
 		case <-ticker.C:
 			if !IsPortListening(port) {
-				logrus.Infof("Port %v are free", port)
+				plog.G(ctx).Infof("Port %v are free", port)
 				return nil
 			}
 		}