diff --git a/main.go b/main.go index cc58d07b..2890563e 100644 --- a/main.go +++ b/main.go @@ -21,7 +21,7 @@ import ( ) func runWebServer() { - log.Printf("%v %v", config.GetName(), config.GetVersion()) + log.Printf("Starting %v %v", config.GetName(), config.GetVersion()) switch config.GetLogLevel() { case config.Debug: @@ -35,31 +35,29 @@ func runWebServer() { case config.Error: logger.InitLogger(logging.ERROR) default: - log.Fatal("unknown log level:", config.GetLogLevel()) + log.Fatalf("Unknown log level: %v", config.GetLogLevel()) } err := database.InitDB(config.GetDBPath()) if err != nil { - log.Fatal(err) + log.Fatalf("Error initializing database: %v", err) } var server *web.Server - server = web.NewServer() global.SetWebServer(server) err = server.Start() if err != nil { - log.Println(err) + log.Fatalf("Error starting web server: %v", err) return } var subServer *sub.Server subServer = sub.NewServer() global.SetSubServer(subServer) - err = subServer.Start() if err != nil { - log.Println(err) + log.Fatalf("Error starting sub server: %v", err) return } @@ -71,34 +69,39 @@ func runWebServer() { switch sig { case syscall.SIGHUP: + logger.Info("Received SIGHUP signal. Restarting servers...") + err := server.Stop() if err != nil { - logger.Warning("stop server err:", err) + logger.Warning("Error stopping web server:", err) } err = subServer.Stop() if err != nil { - logger.Warning("stop server err:", err) + logger.Warning("Error stopping sub server:", err) } server = web.NewServer() global.SetWebServer(server) err = server.Start() if err != nil { - log.Println(err) + log.Fatalf("Error restarting web server: %v", err) return } + log.Println("Web server restarted successfully.") subServer = sub.NewServer() global.SetSubServer(subServer) - err = subServer.Start() if err != nil { - log.Println(err) + log.Fatalf("Error restarting sub server: %v", err) return } + log.Println("Sub server restarted successfully.") + default: server.Stop() subServer.Stop() + log.Println("Shutting down servers.") return } } @@ -107,16 +110,16 @@ func runWebServer() { func resetSetting() { err := database.InitDB(config.GetDBPath()) if err != nil { - fmt.Println(err) + fmt.Println("Failed to initialize database:", err) return } settingService := service.SettingService{} err = settingService.ResetSettings() if err != nil { - fmt.Println("reset setting failed:", err) + fmt.Println("Failed to reset settings:", err) } else { - fmt.Println("reset setting success") + fmt.Println("Settings successfully reset.") } } @@ -179,7 +182,7 @@ func updateTgbotEnableSts(status bool) { func updateTgbotSetting(tgBotToken string, tgBotChatid string, tgBotRuntime string) { err := database.InitDB(config.GetDBPath()) if err != nil { - fmt.Println(err) + fmt.Println("Error initializing database:", err) return } @@ -188,68 +191,65 @@ func updateTgbotSetting(tgBotToken string, tgBotChatid string, tgBotRuntime stri if tgBotToken != "" { err := settingService.SetTgBotToken(tgBotToken) if err != nil { - fmt.Println(err) + fmt.Printf("Error setting Telegram bot token: %v\n", err) return - } else { - logger.Info("updateTgbotSetting tgBotToken success") } + logger.Info("Successfully updated Telegram bot token.") } if tgBotRuntime != "" { err := settingService.SetTgbotRuntime(tgBotRuntime) if err != nil { - fmt.Println(err) + fmt.Printf("Error setting Telegram bot runtime: %v\n", err) return - } else { - logger.Infof("updateTgbotSetting tgBotRuntime[%s] success", tgBotRuntime) } + logger.Infof("Successfully updated Telegram bot runtime to [%s].", tgBotRuntime) } if tgBotChatid != "" { err := settingService.SetTgBotChatId(tgBotChatid) if err != nil { - fmt.Println(err) + fmt.Printf("Error setting Telegram bot chat ID: %v\n", err) return - } else { - logger.Info("updateTgbotSetting tgBotChatid success") } + logger.Info("Successfully updated Telegram bot chat ID.") } } func updateSetting(port int, username string, password string, webBasePath string) { err := database.InitDB(config.GetDBPath()) if err != nil { - fmt.Println(err) + fmt.Println("Database initialization failed:", err) return } settingService := service.SettingService{} + userService := service.UserService{} if port > 0 { err := settingService.SetPort(port) if err != nil { - fmt.Println("set port failed:", err) + fmt.Println("Failed to set port:", err) } else { - fmt.Printf("set port %v success", port) + fmt.Printf("Port set successfully: %v\n", port) } } if username != "" || password != "" { - userService := service.UserService{} err := userService.UpdateFirstUser(username, password) if err != nil { - fmt.Println("set username and password failed:", err) + fmt.Println("Failed to update username and password:", err) } else { - fmt.Println("set username and password success") + fmt.Println("Username and password updated successfully") } } if webBasePath != "" { err := settingService.SetBasePath(webBasePath) if err != nil { - fmt.Println("set base URI path failed:", err) + fmt.Println("Failed to set base URI path:", err) } else { - fmt.Println("set base URI path success") + fmt.Println("Base URI path set successfully") } } } @@ -348,19 +348,19 @@ func main() { var reset bool var show bool var remove_secret bool - settingCmd.BoolVar(&reset, "reset", false, "reset all settings") - settingCmd.BoolVar(&show, "show", false, "show current settings") - settingCmd.BoolVar(&remove_secret, "remove_secret", false, "remove secret") - settingCmd.IntVar(&port, "port", 0, "set panel port") - settingCmd.StringVar(&username, "username", "", "set login username") - settingCmd.StringVar(&password, "password", "", "set login password") - settingCmd.StringVar(&webBasePath, "webBasePath", "", "set web base path") - settingCmd.StringVar(&webCertFile, "webCert", "", "set web public key path") - settingCmd.StringVar(&webKeyFile, "webCertKey", "", "set web private key path") - settingCmd.StringVar(&tgbottoken, "tgbottoken", "", "set telegram bot token") - settingCmd.StringVar(&tgbotRuntime, "tgbotRuntime", "", "set telegram bot cron time") - settingCmd.StringVar(&tgbotchatid, "tgbotchatid", "", "set telegram bot chat id") - settingCmd.BoolVar(&enabletgbot, "enabletgbot", false, "enable telegram bot notify") + settingCmd.BoolVar(&reset, "reset", false, "Reset all settings") + settingCmd.BoolVar(&show, "show", false, "Display current settings") + settingCmd.BoolVar(&remove_secret, "remove_secret", false, "Remove secret key") + settingCmd.IntVar(&port, "port", 0, "Set panel port number") + settingCmd.StringVar(&username, "username", "", "Set login username") + settingCmd.StringVar(&password, "password", "", "Set login password") + settingCmd.StringVar(&webBasePath, "webBasePath", "", "Set base path for Panel") + settingCmd.StringVar(&webCertFile, "webCert", "", "Set path to public key file for panel") + settingCmd.StringVar(&webKeyFile, "webCertKey", "", "Set path to private key file for panel") + settingCmd.StringVar(&tgbottoken, "tgbottoken", "", "Set token for Telegram bot") + settingCmd.StringVar(&tgbotRuntime, "tgbotRuntime", "", "Set cron time for Telegram bot notifications") + settingCmd.StringVar(&tgbotchatid, "tgbotchatid", "", "Set chat ID for Telegram bot notifications") + settingCmd.BoolVar(&enabletgbot, "enabletgbot", false, "Enable notifications via Telegram bot") oldUsage := flag.Usage flag.Usage = func() { diff --git a/sub/sub.go b/sub/sub.go index 8fe025bc..47b6158c 100644 --- a/sub/sub.go +++ b/sub/sub.go @@ -163,13 +163,13 @@ func (s *Server) Start() (err error) { } listener = network.NewAutoHttpsListener(listener) listener = tls.NewListener(listener, c) - logger.Info("sub server run https on", listener.Addr()) + logger.Info("Sub server running HTTPS on", listener.Addr()) } else { - logger.Error("error in loading certificates: ", err) - logger.Info("sub server run http on", listener.Addr()) + logger.Error("Error loading certificates:", err) + logger.Info("Sub server running HTTP on", listener.Addr()) } } else { - logger.Info("sub server run http on", listener.Addr()) + logger.Info("Sub server running HTTP on", listener.Addr()) } s.listener = listener diff --git a/web/controller/index.go b/web/controller/index.go index 12a2d99c..c4fe5eb2 100644 --- a/web/controller/index.go +++ b/web/controller/index.go @@ -76,25 +76,25 @@ func (a *IndexController) login(c *gin.Context) { sessionMaxAge, err := a.settingService.GetSessionMaxAge() if err != nil { - logger.Warningf("Unable to get session's max age from DB") + logger.Warning("Unable to get session's max age from DB") } if sessionMaxAge > 0 { err = session.SetMaxAge(c, sessionMaxAge*60) if err != nil { - logger.Warningf("Unable to set session's max age") + logger.Warning("Unable to set session's max age") } } err = session.SetLoginUser(c, user) - logger.Info(user.Username, " logged in successfully") + logger.Infof("%s logged in successfully", user.Username) jsonMsg(c, I18nWeb(c, "pages.login.toasts.successLogin"), err) } func (a *IndexController) logout(c *gin.Context) { user := session.GetLoginUser(c) if user != nil { - logger.Info(user.Username, " logged out successfully") + logger.Infof("%s logged out successfully", user.Username) } session.ClearSession(c) c.Redirect(http.StatusTemporaryRedirect, c.GetString("base_path")) diff --git a/web/job/check_client_ip_job.go b/web/job/check_client_ip_job.go index c5e8fc0d..8b7f81f1 100644 --- a/web/job/check_client_ip_job.go +++ b/web/job/check_client_ip_job.go @@ -252,46 +252,55 @@ func (j *CheckClientIpJob) addInboundClientIps(clientEmail string, ips []string) func (j *CheckClientIpJob) updateInboundClientIps(inboundClientIps *model.InboundClientIps, clientEmail string, ips []string) bool { jsonIps, err := json.Marshal(ips) - j.checkError(err) + if err != nil { + logger.Error("failed to marshal IPs to JSON:", err) + return false + } inboundClientIps.ClientEmail = clientEmail inboundClientIps.Ips = string(jsonIps) - // check inbound limitation + // Fetch inbound settings by client email inbound, err := j.getInboundByEmail(clientEmail) - j.checkError(err) - - if inbound.Settings == "" { - logger.Debug("wrong data ", inbound) + if err != nil { + logger.Errorf("failed to fetch inbound settings for email %s: %s", clientEmail, err) return false } + if inbound.Settings == "" { + logger.Debug("wrong data:", inbound) + return false + } + + // Unmarshal settings to get client limits settings := map[string][]model.Client{} json.Unmarshal([]byte(inbound.Settings), &settings) clients := settings["clients"] shouldCleanLog := false j.disAllowedIps = []string{} - // create iplimit log file channel - logIpFile, err := os.OpenFile(xray.GetIPLimitLogPath(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644) + // Open log file for IP limits + logIpFile, err := os.OpenFile(xray.GetIPLimitLogPath(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644) if err != nil { - logger.Errorf("failed to create or open ip limit log file: %s", err) + logger.Errorf("failed to open IP limit log file: %s", err) + return false } defer logIpFile.Close() log.SetOutput(logIpFile) log.SetFlags(log.LstdFlags) + // Check client IP limits for _, client := range clients { if client.Email == clientEmail { limitIp := client.LimitIP - if limitIp != 0 { + if limitIp > 0 && inbound.Enable { shouldCleanLog = true - if limitIp < len(ips) && inbound.Enable { + if limitIp < len(ips) { j.disAllowedIps = append(j.disAllowedIps, ips[limitIp:]...) for i := limitIp; i < len(ips); i++ { - log.Printf("[LIMIT_IP] Email = %s || SRC = %s", clientEmail, ips[i]) + logger.Debugf("[LIMIT_IP] Email = %s || SRC = %s", clientEmail, ips[i]) } } } @@ -301,12 +310,15 @@ func (j *CheckClientIpJob) updateInboundClientIps(inboundClientIps *model.Inboun sort.Strings(j.disAllowedIps) if len(j.disAllowedIps) > 0 { - logger.Debug("disAllowedIps ", j.disAllowedIps) + logger.Debug("disAllowedIps:", j.disAllowedIps) } db := database.GetDB() err = db.Save(inboundClientIps).Error - j.checkError(err) + if err != nil { + logger.Error("failed to save inboundClientIps:", err) + return false + } return shouldCleanLog } diff --git a/web/job/xray_traffic_job.go b/web/job/xray_traffic_job.go index dea407e0..dbbbb059 100644 --- a/web/job/xray_traffic_job.go +++ b/web/job/xray_traffic_job.go @@ -19,10 +19,8 @@ func (j *XrayTrafficJob) Run() { if !j.xrayService.IsXrayRunning() { return } - traffics, clientTraffics, err := j.xrayService.GetXrayTraffic() if err != nil { - logger.Warning("get xray traffic failed:", err) return } err, needRestart0 := j.inboundService.AddTraffic(traffics, clientTraffics) diff --git a/web/service/inbound.go b/web/service/inbound.go index d82bfa9c..6f9aac98 100644 --- a/web/service/inbound.go +++ b/web/service/inbound.go @@ -1142,7 +1142,7 @@ func (s *InboundService) GetClientInboundByTrafficID(trafficId int) (traffic *xr var traffics []*xray.ClientTraffic err = db.Model(xray.ClientTraffic{}).Where("id = ?", trafficId).Find(&traffics).Error if err != nil { - logger.Warning(err) + logger.Warningf("Error retrieving ClientTraffic with trafficId %d: %v", trafficId, err) return nil, nil, err } if len(traffics) > 0 { @@ -1157,7 +1157,7 @@ func (s *InboundService) GetClientInboundByEmail(email string) (traffic *xray.Cl var traffics []*xray.ClientTraffic err = db.Model(xray.ClientTraffic{}).Where("email = ?", email).Find(&traffics).Error if err != nil { - logger.Warning(err) + logger.Warningf("Error retrieving ClientTraffic with email %s: %v", email, err) return nil, nil, err } if len(traffics) > 0 { @@ -1698,15 +1698,20 @@ func (s *InboundService) DelDepletedClients(id int) (err error) { func (s *InboundService) GetClientTrafficTgBot(tgId int64) ([]*xray.ClientTraffic, error) { db := database.GetDB() var inbounds []*model.Inbound - err := db.Model(model.Inbound{}).Where("settings like ?", fmt.Sprintf(`%%"tgId": %d%%`, tgId)).Find(&inbounds).Error + + // Retrieve inbounds where settings contain the given tgId + err := db.Model(model.Inbound{}).Where("settings LIKE ?", fmt.Sprintf(`%%"tgId": %d%%`, tgId)).Find(&inbounds).Error if err != nil && err != gorm.ErrRecordNotFound { + logger.Errorf("Error retrieving inbounds with tgId %d: %v", tgId, err) return nil, err } + var emails []string for _, inbound := range inbounds { clients, err := s.GetClients(inbound) if err != nil { - logger.Error("Unable to get clients from inbound") + logger.Errorf("Error retrieving clients for inbound %d: %v", inbound.Id, err) + continue } for _, client := range clients { if client.TgID == tgId { @@ -1714,15 +1719,19 @@ func (s *InboundService) GetClientTrafficTgBot(tgId int64) ([]*xray.ClientTraffi } } } + var traffics []*xray.ClientTraffic err = db.Model(xray.ClientTraffic{}).Where("email IN ?", emails).Find(&traffics).Error if err != nil { if err == gorm.ErrRecordNotFound { - logger.Warning(err) - return nil, err + logger.Warning("No ClientTraffic records found for emails:", emails) + return nil, nil } + logger.Errorf("Error retrieving ClientTraffic for emails %v: %v", emails, err) + return nil, err } - return traffics, err + + return traffics, nil } func (s *InboundService) GetClientTrafficByEmail(email string) (traffic *xray.ClientTraffic, err error) { @@ -1731,7 +1740,7 @@ func (s *InboundService) GetClientTrafficByEmail(email string) (traffic *xray.Cl err = db.Model(xray.ClientTraffic{}).Where("email = ?", email).Find(&traffics).Error if err != nil { - logger.Warning(err) + logger.Warningf("Error retrieving ClientTraffic with email %s: %v", email, err) return nil, err } if len(traffics) > 0 { @@ -1746,38 +1755,51 @@ func (s *InboundService) SearchClientTraffic(query string) (traffic *xray.Client inbound := &model.Inbound{} traffic = &xray.ClientTraffic{} - err = db.Model(model.Inbound{}).Where("settings like ?", "%\""+query+"\"%").First(inbound).Error + // Search for inbound settings that contain the query + err = db.Model(model.Inbound{}).Where("settings LIKE ?", "%\""+query+"\"%").First(inbound).Error if err != nil { if err == gorm.ErrRecordNotFound { - logger.Warning(err) + logger.Warningf("Inbound settings containing query %s not found: %v", query, err) return nil, err } + logger.Errorf("Error searching for inbound settings with query %s: %v", query, err) + return nil, err } + traffic.InboundId = inbound.Id - // get settings clients + // Unmarshal settings to get clients settings := map[string][]model.Client{} - json.Unmarshal([]byte(inbound.Settings), &settings) + if err := json.Unmarshal([]byte(inbound.Settings), &settings); err != nil { + logger.Errorf("Error unmarshalling inbound settings for inbound ID %d: %v", inbound.Id, err) + return nil, err + } + clients := settings["clients"] for _, client := range clients { - if client.ID == query && client.Email != "" { - traffic.Email = client.Email - break - } - if client.Password == query && client.Email != "" { + if (client.ID == query || client.Password == query) && client.Email != "" { traffic.Email = client.Email break } } + if traffic.Email == "" { - return nil, err + logger.Warningf("No client found with query %s in inbound ID %d", query, inbound.Id) + return nil, gorm.ErrRecordNotFound } + + // Retrieve ClientTraffic based on the found email err = db.Model(xray.ClientTraffic{}).Where("email = ?", traffic.Email).First(traffic).Error if err != nil { - logger.Warning(err) + if err == gorm.ErrRecordNotFound { + logger.Warningf("ClientTraffic for email %s not found: %v", traffic.Email, err) + return nil, err + } + logger.Errorf("Error retrieving ClientTraffic for email %s: %v", traffic.Email, err) return nil, err } - return traffic, err + + return traffic, nil } func (s *InboundService) GetInboundClientIps(clientEmail string) (string, error) { diff --git a/web/service/outbound.go b/web/service/outbound.go index 685ac422..3b432228 100644 --- a/web/service/outbound.go +++ b/web/service/outbound.go @@ -70,7 +70,7 @@ func (s *OutboundService) GetOutboundsTraffic() ([]*model.OutboundTraffics, erro err := db.Model(model.OutboundTraffics{}).Find(&traffics).Error if err != nil { - logger.Warning(err) + logger.Warning("Error retrieving OutboundTraffics: ", err) return nil, err } diff --git a/web/service/panel.go b/web/service/panel.go index 71782a8f..3b0c75a5 100644 --- a/web/service/panel.go +++ b/web/service/panel.go @@ -19,7 +19,7 @@ func (s *PanelService) RestartPanel(delay time.Duration) error { time.Sleep(delay) err := p.Signal(syscall.SIGHUP) if err != nil { - logger.Error("send signal SIGHUP failed:", err) + logger.Error("failed to send SIGHUP signal:", err) } }() return nil diff --git a/web/service/tgbot.go b/web/service/tgbot.go index eecea078..640a2032 100644 --- a/web/service/tgbot.go +++ b/web/service/tgbot.go @@ -64,52 +64,59 @@ func (t *Tgbot) GetHashStorage() *global.HashStorage { } func (t *Tgbot) Start(i18nFS embed.FS) error { + // Initialize localizer err := locale.InitLocalizer(i18nFS, &t.settingService) if err != nil { return err } - // init hash storage => store callback queries + // Initialize hash storage to store callback queries hashStorage = global.NewHashStorage(20 * time.Minute) t.SetHostname() - tgBottoken, err := t.settingService.GetTgBotToken() - if err != nil || tgBottoken == "" { - logger.Warning("Get TgBotToken failed:", err) + + // Get Telegram bot token + tgBotToken, err := t.settingService.GetTgBotToken() + if err != nil || tgBotToken == "" { + logger.Warning("Failed to get Telegram bot token:", err) return err } - tgBotid, err := t.settingService.GetTgBotChatId() + // Get Telegram bot chat ID(s) + tgBotID, err := t.settingService.GetTgBotChatId() if err != nil { - logger.Warning("Get GetTgBotChatId failed:", err) + logger.Warning("Failed to get Telegram bot chat ID:", err) return err } - if tgBotid != "" { - for _, adminId := range strings.Split(tgBotid, ",") { - id, err := strconv.Atoi(adminId) + // Parse admin IDs from comma-separated string + if tgBotID != "" { + for _, adminID := range strings.Split(tgBotID, ",") { + id, err := strconv.Atoi(adminID) if err != nil { - logger.Warning("Failed to get IDs from GetTgBotChatId:", err) + logger.Warning("Failed to parse admin ID from Telegram bot chat ID:", err) return err } adminIds = append(adminIds, int64(id)) } } + // Get Telegram bot proxy URL tgBotProxy, err := t.settingService.GetTgBotProxy() if err != nil { - logger.Warning("Failed to get ProxyUrl:", err) + logger.Warning("Failed to get Telegram bot proxy URL:", err) } - bot, err = t.NewBot(tgBottoken, tgBotProxy) + // Create new Telegram bot instance + bot, err = t.NewBot(tgBotToken, tgBotProxy) if err != nil { - fmt.Println("Get tgbot's api error:", err) + logger.Error("Failed to initialize Telegram bot API:", err) return err } - // listen for TG bot income messages + // Start receiving Telegram bot messages if !isRunning { - logger.Info("Starting Telegram receiver ...") + logger.Info("Telegram bot receiver started") go t.OnReceive() isRunning = true } diff --git a/web/service/xray.go b/web/service/xray.go index 6074216d..d37c963a 100644 --- a/web/service/xray.go +++ b/web/service/xray.go @@ -97,7 +97,7 @@ func (s *XrayService) GetXrayConfig() (*xray.Config, error) { if !clientTraffic.Enable { clients = RemoveIndex(clients, index-indexDecrease) indexDecrease++ - logger.Info("Remove Inbound User ", c["email"], " due the expire or traffic limit") + logger.Infof("Remove Inbound User %s due to expiration or traffic limit", c["email"]) } } } @@ -165,11 +165,20 @@ func (s *XrayService) GetXrayConfig() (*xray.Config, error) { func (s *XrayService) GetXrayTraffic() ([]*xray.Traffic, []*xray.ClientTraffic, error) { if !s.IsXrayRunning() { - return nil, nil, errors.New("xray is not running") + err := errors.New("xray is not running") + logger.Debug("Attempted to fetch Xray traffic, but Xray is not running:", err) + return nil, nil, err } - s.xrayAPI.Init(p.GetAPIPort()) + apiPort := p.GetAPIPort() + s.xrayAPI.Init(apiPort) defer s.xrayAPI.Close() - return s.xrayAPI.GetTraffic(true) + + traffic, clientTraffic, err := s.xrayAPI.GetTraffic(true) + if err != nil { + logger.Debug("Failed to fetch Xray traffic:", err) + return nil, nil, err + } + return traffic, clientTraffic, nil } func (s *XrayService) RestartXray(isForce bool) error { @@ -202,7 +211,7 @@ func (s *XrayService) RestartXray(isForce bool) error { func (s *XrayService) StopXray() error { lock.Lock() defer lock.Unlock() - logger.Debug("stop xray") + logger.Debug("Attempting to stop Xray...") if s.IsXrayRunning() { return p.Stop() } diff --git a/web/web.go b/web/web.go index 5850e85d..35ccec70 100644 --- a/web/web.go +++ b/web/web.go @@ -344,13 +344,13 @@ func (s *Server) Start() (err error) { } listener = network.NewAutoHttpsListener(listener) listener = tls.NewListener(listener, c) - logger.Info("web server run https on", listener.Addr()) + logger.Info("Web server running HTTPS on", listener.Addr()) } else { - logger.Error("error in loading certificates: ", err) - logger.Info("web server run http on", listener.Addr()) + logger.Error("Error loading certificates:", err) + logger.Info("Web server running HTTP on", listener.Addr()) } } else { - logger.Info("web server run http on", listener.Addr()) + logger.Info("Web server running HTTP on", listener.Addr()) } s.listener = listener diff --git a/xray/api.go b/xray/api.go index 2dce4dcb..d7d916d3 100644 --- a/xray/api.go +++ b/xray/api.go @@ -183,6 +183,7 @@ func (x *XrayAPI) GetTraffic(reset bool) ([]*Traffic, []*ClientTraffic, error) { resp, err := (*x.StatsServiceClient).QueryStats(ctx, &statsService.QueryStatsRequest{Reset_: reset}) if err != nil { + logger.Debug("Failed to query Xray stats:", err) return nil, nil, err } @@ -196,7 +197,6 @@ func (x *XrayAPI) GetTraffic(reset bool) ([]*Traffic, []*ClientTraffic, error) { processClientTraffic(matches, stat.Value, emailTrafficMap) } } - return mapToSlice(tagTrafficMap), mapToSlice(emailTrafficMap), nil } diff --git a/xray/process.go b/xray/process.go index f7c66f8a..db8509eb 100644 --- a/xray/process.go +++ b/xray/process.go @@ -60,14 +60,14 @@ func GetAccessPersistentPrevLogPath() string { func GetAccessLogPath() (string, error) { config, err := os.ReadFile(GetConfigPath()) if err != nil { - logger.Warningf("Something went wrong: %s", err) + logger.Warningf("Failed to read configuration file: %s", err) return "", err } jsonConfig := map[string]interface{}{} err = json.Unmarshal([]byte(config), &jsonConfig) if err != nil { - logger.Warningf("Something went wrong: %s", err) + logger.Warningf("Failed to parse JSON configuration: %s", err) return "", err } @@ -206,7 +206,7 @@ func (p *process) Start() (err error) { err = os.MkdirAll(config.GetLogFolder(), 0o770) if err != nil { - logger.Warningf("Something went wrong: %s", err) + logger.Warningf("Failed to create log folder: %s", err) } configPath := GetConfigPath() @@ -224,7 +224,7 @@ func (p *process) Start() (err error) { go func() { err := cmd.Run() if err != nil { - logger.Error("Failure in running xray-core: ", err) + logger.Error("Failure in running xray-core:", err) p.exitErr = err } }()