diff --git a/cmd/bitsrun/main.go b/cmd/bitsrun/main.go
index 4a6d304..22712f2 100644
--- a/cmd/bitsrun/main.go
+++ b/cmd/bitsrun/main.go
@@ -4,7 +4,6 @@ import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
 	"github.com/Mmx233/BitSrunLoginGo/internal/controllers"
 	"github.com/Mmx233/BitSrunLoginGo/tools"
-	log "github.com/sirupsen/logrus"
 )
 
 func main() {
@@ -14,21 +13,22 @@ func main() {
 	} else {
 		//登录流程
 		var err error
+		logger := config.Logger
 		if config.Settings.Basic.Interfaces == "" { //单网卡
 			if err = controllers.Login(nil, false); err != nil {
-				log.Errorln("登录出错: ", err)
+				logger.Errorln("登录出错: ", err)
 				if !config.Settings.Log.DebugLevel {
-					log.Infoln("开启调试日志（debug_level）获取详细信息")
+					logger.Infoln("开启调试日志（debug_level）获取详细信息")
 				}
 				return
 			}
 		} else { //多网卡
-			log.Infoln("多网卡模式")
-			interfaces, _ := tools.GetInterfaceAddr(config.Settings.Basic.Interfaces)
+			logger.Infoln("多网卡模式")
+			interfaces, _ := tools.GetInterfaceAddr(logger, config.Settings.Basic.Interfaces)
 			for _, eth := range interfaces {
-				log.Infoln("使用网卡: ", eth.Name)
+				logger.Infoln("使用网卡: ", eth.Name)
 				if err = controllers.Login(&eth, false); err != nil {
-					log.Errorf("网卡 %s 登录出错: %v", eth.Name, err)
+					config.Logger.Errorf("网卡 %s 登录出错: %v", eth.Name, err)
 				}
 			}
 		}
diff --git a/go.mod b/go.mod
index 9313693..3a30aa4 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,7 @@ module github.com/Mmx233/BitSrunLoginGo
 go 1.23.1
 
 require (
-	github.com/Mmx233/BackoffCli/backoff v0.0.0-20240923161441-2cf9a65477c8
+	github.com/Mmx233/BackoffCli/backoff v0.0.0-20240924144324-7b288b13d4c6
 	github.com/Mmx233/tool v0.7.8
 	github.com/antonfisher/nested-logrus-formatter v1.3.1
 	github.com/cloudflare/cloudflare-go v0.104.0
@@ -15,7 +15,7 @@ require (
 
 require (
 	github.com/goccy/go-json v0.10.3 // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	golang.org/x/net v0.29.0 // indirect
diff --git a/go.sum b/go.sum
index 7ed50ea..9f3b73f 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,5 @@
-github.com/Mmx233/BackoffCli/backoff v0.0.0-20240923161441-2cf9a65477c8 h1:4CnbKFlym1OOqO9mMmpDVq2URvk80YyqqT8MY7ZP6pU=
-github.com/Mmx233/BackoffCli/backoff v0.0.0-20240923161441-2cf9a65477c8/go.mod h1:lSwJMEvGYQoEyQzvEFI88x+c2PHzp4/1ut2CrzJ3Q2o=
+github.com/Mmx233/BackoffCli/backoff v0.0.0-20240924144324-7b288b13d4c6 h1:sfvujwTP5u1qTiJTGzwzGc7/2xdT5qywXyeEImteytE=
+github.com/Mmx233/BackoffCli/backoff v0.0.0-20240924144324-7b288b13d4c6/go.mod h1:lSwJMEvGYQoEyQzvEFI88x+c2PHzp4/1ut2CrzJ3Q2o=
 github.com/Mmx233/tool v0.7.8 h1:SNl1AHhvF3owGDMFGRxWCqFukvySDqAv9IJe8ubWeWg=
 github.com/Mmx233/tool v0.7.8/go.mod h1:tEQN6qc2s/sOJKcxr06SktzZ2fCuwdOs0fK01UTfe4Q=
 github.com/antonfisher/nested-logrus-formatter v1.3.1 h1:NFJIr+pzwv5QLHTPyKz9UMEoHck02Q9L0FP13b/xSbQ=
@@ -13,8 +13,8 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
 github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
diff --git a/internal/config/log.go b/internal/config/log.go
index 4f9eabd..2e9f70e 100644
--- a/internal/config/log.go
+++ b/internal/config/log.go
@@ -10,9 +10,13 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+var Logger *log.Logger
+
 func initLog() {
+	Logger = log.New()
+
 	if Settings.Log.DebugLevel {
-		log.SetLevel(log.DebugLevel)
+		Logger.SetLevel(log.DebugLevel)
 	}
 
 	if Settings.Log.WriteFile {
@@ -22,7 +26,7 @@ func initLog() {
 		}
 		err := os.MkdirAll(Settings.Log.FilePath, os.ModePerm)
 		if err != nil {
-			log.Fatalln(err)
+			Logger.Fatalln(err)
 		}
 
 		if Settings.Log.FileName == "" {
@@ -31,15 +35,15 @@ func initLog() {
 
 		f, err := os.OpenFile(Settings.Log.FilePath+Settings.Log.FileName, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
 		if err != nil {
-			log.Fatalln(err)
+			Logger.Fatalln(err)
 		}
 
 		//设置双重输出
 		mw := io.MultiWriter(os.Stdout, f)
-		log.SetOutput(mw)
+		Logger.SetOutput(mw)
 
 		//设置输出格式
-		log.SetFormatter(&nested.Formatter{
+		Logger.SetFormatter(&nested.Formatter{
 			HideKeys:        true,
 			NoColors:        Settings.Log.WriteFile,
 			TimestampFormat: "2006-01-02 15:04:05",
diff --git a/internal/controllers/guardian.go b/internal/controllers/guardian.go
index f06cddf..c9baf2e 100644
--- a/internal/controllers/guardian.go
+++ b/internal/controllers/guardian.go
@@ -5,12 +5,13 @@ import (
 	"time"
 
 	"github.com/Mmx233/BitSrunLoginGo/tools"
-	log "github.com/sirupsen/logrus"
 )
 
 // Guardian 守护模式逻辑
 func Guardian() {
-	log.Infoln("[以守护模式启动]")
+	logger := config.Logger
+
+	logger.Infoln("[以守护模式启动]")
 
 	GuardianDuration := time.Duration(config.Settings.Guardian.Duration) * time.Second
 
@@ -20,16 +21,16 @@ func Guardian() {
 			if config.Settings.Basic.Interfaces == "" { //单网卡
 				err := Login(nil, true)
 				if err != nil {
-					log.Errorln("登录出错: ", err)
+					logger.Errorln("登录出错: ", err)
 				}
 			} else { //多网卡
-				interfaces, err := tools.GetInterfaceAddr(config.Settings.Basic.Interfaces)
+				interfaces, err := tools.GetInterfaceAddr(logger, config.Settings.Basic.Interfaces)
 				if err == nil {
 					for _, eth := range interfaces {
-						log.Debugf("使用 %s 网口登录 ", eth.Name)
+						logger.Debugf("使用 %s 网口登录 ", eth.Name)
 						err = Login(&eth, true)
 						if err != nil {
-							log.Errorln("网口 ", eth.Name+" 登录出错: ", err)
+							logger.Errorln("网口 ", eth.Name+" 登录出错: ", err)
 						}
 					}
 				}
diff --git a/internal/controllers/login.go b/internal/controllers/login.go
index adc4e8d..5be42bc 100644
--- a/internal/controllers/login.go
+++ b/internal/controllers/login.go
@@ -5,18 +5,21 @@ import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
 	"github.com/Mmx233/BitSrunLoginGo/internal/config/flags"
 	"github.com/Mmx233/BitSrunLoginGo/internal/pkg/dns"
+	"github.com/Mmx233/BitSrunLoginGo/internal/pkg/http_client"
 	"github.com/Mmx233/BitSrunLoginGo/pkg/srun"
 	"github.com/Mmx233/BitSrunLoginGo/tools"
-	log "github.com/sirupsen/logrus"
 	"net/http"
 )
 
 // Login 登录逻辑
 func Login(eth *tools.Eth, debugOutput bool) error {
+	logger := config.Logger
+
 	// 登录配置初始化
-	httpClient := tools.HttpPackSelect(eth).Client
+	httpClient := http_client.HttpPackSelect(eth).Client
 	srunClient := srun.New(&srun.Conf{
-		Https: config.Settings.Basic.Https,
+		Logger: logger,
+		Https:  config.Settings.Basic.Https,
 		LoginInfo: srun.LoginInfo{
 			Form: *config.Form,
 			Meta: *config.Meta,
@@ -30,42 +33,42 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	// Reality 与 Acid
 	var acidOnReality bool
 	if config.Settings.Reality.Enable {
-		log.Debugln("开始 Reality 流程")
+		logger.Debugln("开始 Reality 流程")
 		acid, _, err := srunDetector.Reality(config.Settings.Reality.Addr, flags.AutoAcid)
 		if err != nil {
-			log.Warnln("Reality 请求异常:", err)
+			logger.Warnln("Reality 请求异常:", err)
 		} else if flags.AutoAcid && acid != "" {
 			acidOnReality = true
-			log.Debugf("使用嗅探 acid: %s", acid)
+			logger.Debugf("使用嗅探 acid: %s", acid)
 			srunClient.LoginInfo.Meta.Acid = acid
 		}
 	}
 	if !acidOnReality && flags.AutoAcid {
-		log.Debugln("开始嗅探 acid")
+		logger.Debugln("开始嗅探 acid")
 		acid, err := srunDetector.DetectAcid()
 		if err != nil {
 			if errors.Is(err, srun.ErrAcidCannotFound) {
-				log.Warnln("找不到 acid，使用配置 acid")
+				logger.Warnln("找不到 acid，使用配置 acid")
 			} else {
-				log.Warnf("嗅探 acid 失败，使用配置 acid: %v", err)
+				logger.Warnf("嗅探 acid 失败，使用配置 acid: %v", err)
 			}
 		} else {
-			log.Debugf("使用嗅探 acid: %s", acid)
+			logger.Debugf("使用嗅探 acid: %s", acid)
 			srunClient.LoginInfo.Meta.Acid = acid
 		}
 	}
 
 	if flags.AutoEnc {
-		log.Debugln("开始嗅探 enc")
+		logger.Debugln("开始嗅探 enc")
 		enc, err := srunDetector.DetectEnc()
 		if err != nil {
 			if errors.Is(err, srun.ErrEnvCannotFound) {
-				log.Warnln("找不到 enc，使用配置 enc")
+				logger.Warnln("找不到 enc，使用配置 enc")
 			} else {
-				log.Warnf("嗅探 enc 失败，使用配置 enc: %v", err)
+				logger.Warnf("嗅探 enc 失败，使用配置 enc: %v", err)
 			}
 		} else {
-			log.Debugf("使用嗅探 enc: %s", enc)
+			logger.Debugf("使用嗅探 enc: %s", enc)
 			srunClient.LoginInfo.Meta.Enc = enc
 		}
 	}
@@ -73,9 +76,9 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	// 选择输出函数
 	var output func(args ...interface{})
 	if debugOutput {
-		output = log.Debugln
+		output = logger.Debugln
 	} else {
-		output = log.Infoln
+		output = logger.Infoln
 	}
 
 	output("正在获取登录状态")
@@ -88,10 +91,10 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	var loginIp string
 
 	if config.Meta.DoubleStack {
-		log.Debugln("使用双栈网络时认证 ip 为空")
+		logger.Debugln("使用双栈网络时认证 ip 为空")
 	} else {
 		loginIp = ip
-		log.Debugln("认证客户端 ip: ", ip)
+		logger.Debugln("认证客户端 ip: ", ip)
 	}
 
 	// 登录执行
@@ -107,13 +110,13 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 
 		return nil
 	} else {
-		log.Infoln("检测到用户未登录，开始尝试登录...")
+		logger.Infoln("检测到用户未登录，开始尝试登录...")
 
 		if err = srunClient.DoLogin(loginIp); err != nil {
 			return err
 		}
 
-		log.Infoln("登录成功~")
+		logger.Infoln("登录成功~")
 
 		if config.Settings.DDNS.Enable {
 			_ = ddns(ip, httpClient)
@@ -127,6 +130,7 @@ var ipLast string
 
 func ddns(ip string, httpClient *http.Client) error {
 	return dns.Run(&dns.Config{
+		Logger:   config.Logger,
 		Provider: config.Settings.DDNS.Provider,
 		IP:       ip,
 		Domain:   config.Settings.DDNS.Domain,
diff --git a/internal/pkg/dns/dns.go b/internal/pkg/dns/dns.go
index 27c261f..2da8d57 100644
--- a/internal/pkg/dns/dns.go
+++ b/internal/pkg/dns/dns.go
@@ -10,12 +10,15 @@ import (
 )
 
 func Run(c *Config) error {
-	log.Infof("开始 %s DDNS 流程", c.Provider)
-
+	if c.Logger == nil {
+		c.Logger = log.New()
+	}
 	if c.TTL == 0 {
 		c.TTL = 600
 	}
 
+	c.Logger.Infof("开始 %s DDNS 流程", c.Provider)
+
 	var dns Provider
 	var err error
 	switch c.Provider {
@@ -32,22 +35,22 @@ func Run(c *Config) error {
 		} else {
 			msg = fmt.Sprintf("DDNS 模块 dns 运营商 %s 不支持", c.Provider)
 		}
-		log.Warnln(msg)
+		c.Logger.Warnln(msg)
 		return errors.New(msg)
 	}
 	if err != nil {
-		log.Warnf("解析 DDNS config 失败：%v", err)
+		c.Logger.Warnf("解析 DDNS config 失败：%v", err)
 		return err
 	}
 
 	// 修改 dns 记录
 
 	if err = dns.SetDomainRecord(c.Domain, c.IP); err != nil {
-		log.Warnf("设置 dns 解析记录失败：%v", err)
+		c.Logger.Warnf("设置 dns 解析记录失败：%v", err)
 		return err
 	}
 
-	log.Infof("DDNS 配置应用成功: %s | %s", c.Domain, c.IP)
+	c.Logger.Infof("DDNS 配置应用成功: %s | %s", c.Domain, c.IP)
 
 	return nil
 }
diff --git a/internal/pkg/dns/models.go b/internal/pkg/dns/models.go
index 1bf0827..6315ada 100644
--- a/internal/pkg/dns/models.go
+++ b/internal/pkg/dns/models.go
@@ -2,6 +2,7 @@ package dns
 
 import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	log "github.com/sirupsen/logrus"
 	"net/http"
 )
 
@@ -16,4 +17,5 @@ type Config struct {
 	TTL      uint
 	Conf     config.DdnsProviderConfigSum
 	Http     *http.Client
+	Logger   *log.Logger
 }
diff --git a/tools/http.go b/internal/pkg/http_client/http.go
similarity index 56%
rename from tools/http.go
rename to internal/pkg/http_client/http.go
index 1e5e073..3ad9c53 100644
--- a/tools/http.go
+++ b/internal/pkg/http_client/http.go
@@ -1,9 +1,9 @@
-package tools
+package http_client
 
 import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
 	"github.com/Mmx233/BitSrunLoginGo/internal/config/flags"
-	log "github.com/sirupsen/logrus"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
 	"net"
 	"net/http"
 )
@@ -17,20 +17,21 @@ var HttpPack *Http
 var httpTools map[string]*Http
 
 func init() {
+	logger := config.Logger
 	if config.Settings.Basic.Interfaces == "" {
-		var eth *Eth
+		var eth *tools.Eth
 		if flags.Interface != "" {
 			netEth, err := net.InterfaceByName(flags.Interface)
 			if err != nil {
-				log.Warnf("获取指定网卡 %s 失败，使用默认网卡: %v", flags.Interface, err)
+				logger.Warnf("获取指定网卡 %s 失败，使用默认网卡: %v", flags.Interface, err)
 			} else {
-				eth, err = ConvertInterface(*netEth)
+				eth, err = tools.ConvertInterface(logger, *netEth)
 				if err != nil {
-					log.Warnf("获取指定网卡 %s ip 地址失败，使用默认网卡: %v", flags.Interface, err)
+					logger.Warnf("获取指定网卡 %s ip 地址失败，使用默认网卡: %v", flags.Interface, err)
 				} else if eth == nil {
-					log.Warnf("指定网卡 %s 无可用 ip 地址，使用默认网卡", flags.Interface)
+					logger.Warnf("指定网卡 %s 无可用 ip 地址，使用默认网卡", flags.Interface)
 				} else {
-					log.Debugf("使用指定网卡 %s ip: %s", eth.Name, eth.Addr.String())
+					logger.Debugf("使用指定网卡 %s ip: %s", eth.Name, eth.Addr.String())
 				}
 			}
 		}
@@ -41,7 +42,7 @@ func init() {
 	}
 }
 
-func HttpPackSelect(eth *Eth) *Http {
+func HttpPackSelect(eth *tools.Eth) *Http {
 	if HttpPack != nil {
 		return HttpPack
 	}
diff --git a/tools/http_default.go b/internal/pkg/http_client/http_default.go
similarity index 85%
rename from tools/http_default.go
rename to internal/pkg/http_client/http_default.go
index ca16926..472f13a 100644
--- a/tools/http_default.go
+++ b/internal/pkg/http_client/http_default.go
@@ -1,16 +1,17 @@
 //go:build !linux
 
-package tools
+package http_client
 
 import (
 	"crypto/tls"
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
 	"github.com/Mmx233/tool"
 	"net"
 	"net/http"
 )
 
-func genHttpPack(eth *Eth) *Http {
+func genHttpPack(eth *tools.Eth) *Http {
 	var addr net.Addr
 	if eth != nil {
 		addr = eth.Addr
diff --git a/tools/http_linux.go b/internal/pkg/http_client/http_linux.go
similarity index 90%
rename from tools/http_linux.go
rename to internal/pkg/http_client/http_linux.go
index 1ec5143..55e3b04 100644
--- a/tools/http_linux.go
+++ b/internal/pkg/http_client/http_linux.go
@@ -1,15 +1,16 @@
-package tools
+package http_client
 
 import (
 	"crypto/tls"
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
 	"github.com/Mmx233/tool"
 	"net"
 	"net/http"
 	"syscall"
 )
 
-func genHttpPack(eth *Eth) *Http {
+func genHttpPack(eth *tools.Eth) *Http {
 	dialer := net.Dialer{
 		Timeout: config.Timeout,
 	}
diff --git a/pkg/srun/api.go b/pkg/srun/api.go
index 8901464..a1d5f1c 100644
--- a/pkg/srun/api.go
+++ b/pkg/srun/api.go
@@ -14,11 +14,13 @@ import (
 
 type Api struct {
 	BaseUrl string
-	Client  *http.Client
-	// 禁用自动重定向
-	NoDirect *http.Client
 
+	Client *http.Client
+	// 禁用自动重定向
+	NoDirect     *http.Client
 	CustomHeader map[string]interface{}
+
+	Logger *log.Logger
 }
 
 type ApiConfig struct {
@@ -26,6 +28,7 @@ type ApiConfig struct {
 	Domain       string
 	Client       *http.Client
 	CustomHeader map[string]interface{}
+	Logger       *log.Logger
 }
 
 func (a *Api) Init(conf *ApiConfig) {
@@ -44,11 +47,16 @@ func (a *Api) Init(conf *ApiConfig) {
 	a.NoDirect.CheckRedirect = func(_ *http.Request, _ []*http.Request) error {
 		return http.ErrUseLastResponse
 	}
+
+	if conf.Logger == nil {
+		conf.Logger = log.New()
+	}
+	a.Logger = conf.Logger
 }
 
 func (a *Api) request(path string, query map[string]interface{}) (map[string]interface{}, error) {
-	log.Debugln("HTTP GET", a.BaseUrl+path)
-	callback := fmt.Sprintf("jQuery%s_%d", tool.RandMath(rand.NewSource(time.Now().UnixNano())).WithLetters("123456789").String(21), time.Now().UnixMilli())
+	a.Logger.Debugln("HTTP GET", a.BaseUrl+path)
+	callback := fmt.Sprintf("jQuery%s_%d", tool.RandMath(rand.NewSource(time.Now().UnixNano())).WithLetters("123456789").Text(21), time.Now().UnixMilli())
 	if query == nil {
 		query = make(map[string]interface{}, 2)
 	}
@@ -61,25 +69,25 @@ func (a *Api) request(path string, query map[string]interface{}) (map[string]int
 		Header: a.CustomHeader,
 	})
 	if err != nil {
-		log.Debugln(err)
+		a.Logger.Debugln(err)
 		return nil, err
 	}
 
 	resp, err := httpTool.Client.Do(req)
 	if err != nil {
-		log.Debugln(err)
+		a.Logger.Debugln(err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
-		log.Debugln(err)
+		a.Logger.Debugln(err)
 		return nil, err
 	}
 	res := string(data)
 
-	log.Debugln(res)
+	a.Logger.Debugln(res)
 	res = strings.TrimPrefix(res, callback+"(")
 	res = strings.TrimSuffix(res, ")")
 
diff --git a/pkg/srun/detect.go b/pkg/srun/detect.go
index 405b13e..7813ea8 100644
--- a/pkg/srun/detect.go
+++ b/pkg/srun/detect.go
@@ -21,12 +21,15 @@ func (a *Api) NewDetector() *Detector {
 	}
 
 	return &Detector{
+		Logger:      a.Logger,
 		api:         a,
 		redirectReg: redirectReg,
 	}
 }
 
 type Detector struct {
+	Logger *log.Logger
+
 	api *Api
 
 	redirectReg *regexp.Regexp
@@ -36,27 +39,27 @@ type Detector struct {
 	page    []byte
 }
 
-func (a *Detector) _GET(client *http.Client, addr string) (*http.Response, error) {
-	log.Debugln("HTTP GET", addr)
+func (d *Detector) _GET(client *http.Client, addr string) (*http.Response, error) {
+	d.Logger.Debugln("HTTP GET", addr)
 	req, err := http.NewRequest("GET", addr, nil)
 	if err != nil {
 		return nil, err
 	}
-	for k, v := range a.api.CustomHeader {
+	for k, v := range d.api.CustomHeader {
 		req.Header.Set(k, fmt.Sprint(v))
 	}
 	return client.Do(req)
 }
 
-func (a *Detector) _DirectGET(addr string) (*http.Response, error) {
-	return a._GET(a.api.Client, addr)
+func (d *Detector) _DirectGET(addr string) (*http.Response, error) {
+	return d._GET(d.api.Client, addr)
 }
 
-func (a *Detector) _NoDirectGET(addr string) (*http.Response, error) {
-	return a._GET(a.api.NoDirect, addr)
+func (d *Detector) _NoDirectGET(addr string) (*http.Response, error) {
+	return d._GET(d.api.NoDirect, addr)
 }
 
-func (a *Detector) _JoinRedirectLocation(addr *url.URL, loc string) (*url.URL, error) {
+func (d *Detector) _JoinRedirectLocation(addr *url.URL, loc string) (*url.URL, error) {
 	if loc == "" {
 		return nil, errors.New("目标跳转地址缺失")
 	}
@@ -79,7 +82,7 @@ type _FollowRedirectConfig struct {
 	onNextAddr func(addr *url.URL) error
 }
 
-func (a *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*http.Response, []byte, error) {
+func (d *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*http.Response, []byte, error) {
 	addrCopy := *addr
 	addr = &addrCopy
 
@@ -87,7 +90,7 @@ func (a *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*
 	var res *http.Response
 	for {
 		var err error
-		res, err = a._NoDirectGET(addr.String())
+		res, err = d._NoDirectGET(addr.String())
 		if err != nil {
 			return nil, nil, err
 		}
@@ -98,12 +101,12 @@ func (a *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*
 			if err != nil {
 				return nil, nil, err
 			}
-			locMatch := a.redirectReg.FindSubmatch(body)
+			locMatch := d.redirectReg.FindSubmatch(body)
 			if len(locMatch) >= 2 {
 				for i := 1; i < len(locMatch); i++ {
 					locBytes := locMatch[i]
 					if len(locBytes) != 0 {
-						addr, err = a._JoinRedirectLocation(addr, unsafe.String(unsafe.SliceData(locBytes), len(locBytes)))
+						addr, err = d._JoinRedirectLocation(addr, unsafe.String(unsafe.SliceData(locBytes), len(locBytes)))
 						if err != nil {
 							return nil, nil, err
 						}
@@ -118,7 +121,7 @@ func (a *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*
 			_ = res.Body.Close()
 
 			if res.StatusCode < 400 {
-				addr, err = a._JoinRedirectLocation(addr, res.Header.Get("location"))
+				addr, err = d._JoinRedirectLocation(addr, res.Header.Get("location"))
 				if err != nil {
 					return nil, nil, err
 				}
@@ -136,15 +139,15 @@ func (a *Detector) _FollowRedirect(addr *url.URL, conf _FollowRedirectConfig) (*
 	return res, body, nil
 }
 
-func (a *Detector) _SearchAcid(query url.Values) (string, bool) {
+func (d *Detector) _SearchAcid(query url.Values) (string, bool) {
 	addr := query.Get(`ac_id`)
 	return addr, addr != ""
 }
 
 // 用于直接获取登录页数据
-func (a *Detector) _RequestPageBytes() ([]byte, error) {
-	if a.pageUrl != "" {
-		res, err := a._DirectGET(a.pageUrl)
+func (d *Detector) _RequestPageBytes() ([]byte, error) {
+	if d.pageUrl != "" {
+		res, err := d._DirectGET(d.pageUrl)
 		if err != nil {
 			return nil, err
 		}
@@ -153,25 +156,25 @@ func (a *Detector) _RequestPageBytes() ([]byte, error) {
 			_, _ = io.Copy(io.Discard, res.Body)
 			return nil, fmt.Errorf("server return http status: %d", res.StatusCode)
 		}
-		a.page, err = io.ReadAll(res.Body)
+		d.page, err = io.ReadAll(res.Body)
 		if err != nil {
 			return nil, err
 		}
 
-		return a.page, nil
+		return d.page, nil
 	}
 
-	baseUrl, err := url.Parse(a.api.BaseUrl)
+	baseUrl, err := url.Parse(d.api.BaseUrl)
 	if err != nil {
 		return nil, err
 	}
-	_, a.page, err = a._FollowRedirect(baseUrl, _FollowRedirectConfig{})
-	return a.page, err
+	_, d.page, err = d._FollowRedirect(baseUrl, _FollowRedirectConfig{})
+	return d.page, err
 }
 
-func (a *Detector) DetectEnc() (string, error) {
-	if a.page == nil {
-		_, err := a._RequestPageBytes()
+func (d *Detector) DetectEnc() (string, error) {
+	if d.page == nil {
+		_, err := d._RequestPageBytes()
 		if err != nil {
 			return "", err
 		}
@@ -181,17 +184,17 @@ func (a *Detector) DetectEnc() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	jsPathMatch := jsReg.FindSubmatch(a.page)
+	jsPathMatch := jsReg.FindSubmatch(d.page)
 	if len(jsPathMatch) == 3 {
 		jsPathBytes := jsPathMatch[1]
 		jsPath := unsafe.String(unsafe.SliceData(jsPathBytes), len(jsPathBytes))
-		jsUrl, err := url.Parse(a.api.BaseUrl)
+		jsUrl, err := url.Parse(d.api.BaseUrl)
 		if err != nil {
 			return "", err
 		}
 		jsUrl.Path = jsPath
 		jsAddr := jsUrl.String()
-		jsRes, err := a._DirectGET(jsAddr)
+		jsRes, err := d._DirectGET(jsAddr)
 		if err != nil {
 			return "", err
 		}
@@ -224,23 +227,23 @@ func (a *Detector) DetectEnc() (string, error) {
 }
 
 // DetectAcid err 为 nil 时 acid 一定存在
-func (a *Detector) DetectAcid() (string, error) {
-	if a.page == nil {
+func (d *Detector) DetectAcid() (string, error) {
+	if d.page == nil {
 		// page 有值时说明 reality 已进行过 query match，此部分可跳过
 		// 从入口地址 url query 寻找 acid
-		baseUrl, err := url.Parse(a.api.BaseUrl)
+		baseUrl, err := url.Parse(d.api.BaseUrl)
 		if err != nil {
 			return "", err
 		}
 
 		var AcidFound = errors.New("acid found")
 		var acid string
-		_, a.page, err = a._FollowRedirect(baseUrl, _FollowRedirectConfig{
+		_, d.page, err = d._FollowRedirect(baseUrl, _FollowRedirectConfig{
 			onNextAddr: func(addr *url.URL) error {
 				var ok bool
-				acid, ok = a._SearchAcid(addr.Query())
+				acid, ok = d._SearchAcid(addr.Query())
 				if ok {
-					a.pageUrl = addr.String()
+					d.pageUrl = addr.String()
 					return AcidFound
 				}
 				return nil
@@ -260,7 +263,7 @@ func (a *Detector) DetectAcid() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	result := reg.FindSubmatch(a.page)
+	result := reg.FindSubmatch(d.page)
 	if len(result) == 2 {
 		return string(result[1]), nil
 	}
@@ -269,19 +272,19 @@ func (a *Detector) DetectAcid() (string, error) {
 }
 
 // Reality acid 可能为空字符串
-func (a *Detector) Reality(addr string, getAcid bool) (acid string, online bool, err error) {
+func (d *Detector) Reality(addr string, getAcid bool) (acid string, online bool, err error) {
 	startUrl, err := url.Parse(addr)
 	if err != nil {
 		return "", false, err
 	}
 	var AlreadyOnline = errors.New("already online")
-	finalRes, pageBytes, err := a._FollowRedirect(startUrl, _FollowRedirectConfig{
+	finalRes, pageBytes, err := d._FollowRedirect(startUrl, _FollowRedirectConfig{
 		onNextAddr: func(addr *url.URL) error {
 			if addr.Host == startUrl.Host {
 				return AlreadyOnline
 			}
 			if getAcid {
-				acid, _ = a._SearchAcid(addr.Query())
+				acid, _ = d._SearchAcid(addr.Query())
 			}
 			return nil
 		},
@@ -295,11 +298,11 @@ func (a *Detector) Reality(addr string, getAcid bool) (acid string, online bool,
 		return
 	}
 	online = finalRes.Request.URL.Host == startUrl.Host
-	a.page = pageBytes
+	d.page = pageBytes
 	return
 }
 
-func (a *Detector) Reset() {
-	a.pageUrl = ""
-	a.page = nil
+func (d *Detector) Reset() {
+	d.pageUrl = ""
+	d.page = nil
 }
diff --git a/pkg/srun/srun.go b/pkg/srun/srun.go
index d65c82c..a2f09f6 100644
--- a/pkg/srun/srun.go
+++ b/pkg/srun/srun.go
@@ -15,17 +15,25 @@ type Conf struct {
 	LoginInfo    LoginInfo
 	Client       *http.Client
 	CustomHeader map[string]interface{}
+
+	Logger *log.Logger
 }
 
 func New(conf *Conf) *Srun {
+	if conf.Logger == nil {
+		conf.Logger = log.New()
+	}
+
 	srun := &Srun{
 		LoginInfo: conf.LoginInfo,
+		Logger:    conf.Logger,
 	}
 	srun.Api.Init(&ApiConfig{
 		Https:        conf.Https,
 		Domain:       conf.LoginInfo.Form.Domain,
 		Client:       conf.Client,
 		CustomHeader: conf.CustomHeader,
+		Logger:       conf.Logger,
 	})
 	return srun
 }
@@ -34,6 +42,7 @@ type Srun struct {
 	//登录参数，不可缺省
 	LoginInfo LoginInfo
 	Api       Api
+	Logger    *log.Logger
 }
 
 func (c Srun) LoginStatus() (online bool, ip string, err error) {
@@ -61,7 +70,7 @@ func (c Srun) LoginStatus() (online bool, ip string, err error) {
 }
 
 func (c Srun) DoLogin(clientIP string) error {
-	log.Debugln("正在获取 Token")
+	c.Logger.Debugln("正在获取 Token")
 
 	if c.LoginInfo.Form.UserType != "" {
 		c.LoginInfo.Form.Username += "@" + c.LoginInfo.Form.UserType
@@ -76,9 +85,9 @@ func (c Srun) DoLogin(clientIP string) error {
 		return ErrResultCannotFound
 	}
 	tokenStr := token.(string)
-	log.Debugln("token: ", tokenStr)
+	c.Logger.Debugln("token: ", tokenStr)
 
-	log.Debugln("发送登录请求")
+	c.Logger.Debugln("发送登录请求")
 
 	info, err := json.Marshal(map[string]string{
 		"username": c.LoginInfo.Form.Username,
diff --git a/tools/eth.go b/tools/eth.go
index 5e5ec72..5334cdd 100644
--- a/tools/eth.go
+++ b/tools/eth.go
@@ -13,7 +13,7 @@ type Eth struct {
 }
 
 // ConvertInterface 当没有 ipv4 地址时 eth 可能为 nil
-func ConvertInterface(eth net.Interface) (*Eth, error) {
+func ConvertInterface(logger *log.Logger, eth net.Interface) (*Eth, error) {
 	addresses, err := eth.Addrs()
 	if err != nil {
 		return nil, err
@@ -23,7 +23,7 @@ func ConvertInterface(eth net.Interface) (*Eth, error) {
 			var ip *net.TCPAddr
 			ip, err = net.ResolveTCPAddr("tcp", strings.Split(addr.String(), "/")[0]+":0")
 			if err != nil {
-				log.Warnln(eth.Name+" ip解析失败：", err)
+				logger.Warnln(eth.Name+" ip解析失败：", err)
 				continue
 			}
 			return &Eth{
@@ -35,7 +35,7 @@ func ConvertInterface(eth net.Interface) (*Eth, error) {
 	return nil, nil
 }
 
-func GetInterfaceAddr(regexpStr string) ([]Eth, error) {
+func GetInterfaceAddr(logger *log.Logger, regexpStr string) ([]Eth, error) {
 	var result []Eth
 
 	interfaces, err := net.Interfaces()
@@ -44,13 +44,13 @@ func GetInterfaceAddr(regexpStr string) ([]Eth, error) {
 	}
 	reg, err := regexp.Compile(regexpStr)
 	if err != nil {
-		log.Fatalln("interfaces设置异常，无法解析: ", err)
+		logger.Fatalln("interfaces设置异常，无法解析: ", err)
 	}
 	for _, eth := range interfaces {
 		if reg.Match([]byte(eth.Name)) {
-			cEth, err := ConvertInterface(eth)
+			cEth, err := ConvertInterface(logger, eth)
 			if err != nil {
-				log.Warnln(eth.Name+" 网卡地址获取失败: ", err)
+				logger.Warnln(eth.Name+" 网卡地址获取失败: ", err)
 				continue
 			}
 
@@ -58,14 +58,14 @@ func GetInterfaceAddr(regexpStr string) ([]Eth, error) {
 				result = append(result, *cEth)
 			}
 		} else {
-			log.Debugf("网卡 %s 不匹配", eth.Name)
+			logger.Debugf("网卡 %s 不匹配", eth.Name)
 		}
 	}
 
-	log.Debugln("有效匹配网卡：", result)
+	logger.Debugln("有效匹配网卡：", result)
 
 	if len(result) == 0 {
-		log.Warnln("没有扫描到有效匹配网卡")
+		logger.Warnln("没有扫描到有效匹配网卡")
 	}
 
 	return result, nil