improved - message logs

9 files changed, 112 insertions, 64 deletions

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 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)
+		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