feat: add functions to retrieve nginx paths and enhance log cache management

Author: 0xJacky

internal/nginx/config_args.go

@@ -74,6 +74,19 @@ func resolvePath(path string) string {
 	return path
 }
 
+// GetPrefix returns the prefix of the nginx executable
+func GetPrefix() string {
+	out := getNginxV()
+	r, _ := regexp.Compile(`--prefix=(\S+)`)
+	match := r.FindStringSubmatch(out)
+	if len(match) < 1 {
+		logger.Error("nginx.GetPrefix len(match) < 1")
+		return "/usr/local/nginx"
+	}
+	return resolvePath(match[1])
+}
+
+// GetConfPath returns the path to the nginx configuration file
 func GetConfPath(dir ...string) (confPath string) {
 	if settings.NginxSettings.ConfigDir == "" {
 		out := getNginxV()
@@ -97,6 +110,7 @@ func GetConfPath(dir ...string) (confPath string) {
 	return joined
 }
 
+// GetConfEntryPath returns the path to the nginx configuration file
 func GetConfEntryPath() (path string) {
 	if settings.NginxSettings.ConfigPath == "" {
 		out := getNginxV()
@@ -114,6 +128,7 @@ func GetConfEntryPath() (path string) {
 	return resolvePath(path)
 }
 
+// GetPIDPath returns the path to the nginx PID file
 func GetPIDPath() (path string) {
 	if settings.NginxSettings.PIDPath == "" {
 		out := getNginxV()
@@ -131,9 +146,10 @@ func GetPIDPath() (path string) {
 	return resolvePath(path)
 }
 
+// GetSbinPath returns the path to the nginx executable
 func GetSbinPath() (path string) {
 	out := getNginxV()
-	r, _ := regexp.Compile("--sbin-path=(\\S+)")
+	r, _ := regexp.Compile(`--sbin-path=(\S+)`)
 	match := r.FindStringSubmatch(out)
 	if len(match) < 1 {
 		logger.Error("nginx.GetPIDPath len(match) < 1")
@@ -144,10 +160,11 @@ func GetSbinPath() (path string) {
 	return resolvePath(path)
 }
 
+// GetAccessLogPath returns the path to the nginx access log file
 func GetAccessLogPath() (path string) {
 	if settings.NginxSettings.AccessLogPath == "" {
 		out := getNginxV()
-		r, _ := regexp.Compile("--http-log-path=(\\S+)")
+		r, _ := regexp.Compile(`--http-log-path=(\S+)`)
 		match := r.FindStringSubmatch(out)
 		if len(match) < 1 {
 			logger.Error("nginx.GetAccessLogPath len(match) < 1")
@@ -161,10 +178,11 @@ func GetAccessLogPath() (path string) {
 	return resolvePath(path)
 }
 
+// GetErrorLogPath returns the path to the nginx error log file
 func GetErrorLogPath() string {
 	if settings.NginxSettings.ErrorLogPath == "" {
 		out := getNginxV()
-		r, _ := regexp.Compile("--error-log-path=(\\S+)")
+		r, _ := regexp.Compile(`--error-log-path=(\S+)`)
 		match := r.FindStringSubmatch(out)
 		if len(match) < 1 {
 			logger.Error("nginx.GetErrorLogPath len(match) < 1")

internal/nginx_log/log_cache.go

@@ -6,9 +6,10 @@ import (
 
 // NginxLogCache represents a cached log entry from nginx configuration
 type NginxLogCache struct {
-	Path string `json:"path"` // Path to the log file
-	Type string `json:"type"` // Type of log: "access" or "error"
-	Name string `json:"name"` // Name of the log file
+	Path       string `json:"path"`        // Path to the log file
+	Type       string `json:"type"`        // Type of log: "access" or "error"
+	Name       string `json:"name"`        // Name of the log file
+	ConfigFile string `json:"config_file"` // Path to the configuration file that contains this log directive
 }
 
 var (
@@ -17,15 +18,28 @@ var (
 	cacheMutex sync.RWMutex
 )
 
-// AddLogPath adds a log path to the log cache
-func AddLogPath(path, logType, name string) {
+// AddLogPath adds a log path to the log cache with the source config file
+func AddLogPath(path, logType, name, configFile string) {
 	cacheMutex.Lock()
 	defer cacheMutex.Unlock()
 
 	logCache[path] = &NginxLogCache{
-		Path: path,
-		Type: logType,
-		Name: name,
+		Path:       path,
+		Type:       logType,
+		Name:       name,
+		ConfigFile: configFile,
+	}
+}
+
+// RemoveLogPathsFromConfig removes all log paths that come from a specific config file
+func RemoveLogPathsFromConfig(configFile string) {
+	cacheMutex.Lock()
+	defer cacheMutex.Unlock()
+
+	for path, cache := range logCache {
+		if cache.ConfigFile == configFile {
+			delete(logCache, path)
+		}
 	}
 }
 

internal/nginx_log/nginx_log.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 
 	"github.com/0xJacky/Nginx-UI/internal/cache"
 	"github.com/0xJacky/Nginx-UI/internal/helper"
@@ -24,31 +25,75 @@ func init() {
 
 // scanForLogDirectives scans and parses configuration files for log directives
 func scanForLogDirectives(configPath string, content []byte) error {
+	// First, remove all log paths that came from this config file
+	// This ensures that removed log directives are properly cleaned up
+	RemoveLogPathsFromConfig(configPath)
+
 	// Find log directives using regex
 	matches := logDirectiveRegex.FindAllSubmatch(content, -1)
 
+	prefix := nginx.GetPrefix()
 	// Parse log paths
 	for _, match := range matches {
 		if len(match) >= 3 {
+			// Check if this match is from a commented line
+			if isCommentedMatch(content, match) {
+				continue // Skip commented directives
+			}
+
 			directiveType := string(match[1]) // "access_log" or "error_log"
 			logPath := string(match[2])       // Path to log file
 
+			// Handle relative paths by joining with nginx prefix
+			if !filepath.IsAbs(logPath) {
+				logPath = filepath.Join(prefix, logPath)
+			}
+
 			// Validate log path
-			if IsLogPathUnderWhiteList(logPath) && isValidLogPath(logPath) {
+			if isValidLogPath(logPath) {
 				logType := "access"
 				if directiveType == "error_log" {
 					logType = "error"
 				}
 
-				// Add to cache
-				AddLogPath(logPath, logType, filepath.Base(logPath))
+				// Add to cache with config file path
+				AddLogPath(logPath, logType, filepath.Base(logPath), configPath)
 			}
 		}
 	}
 
 	return nil
 }
 
+// isCommentedMatch checks if a regex match is from a commented line
+func isCommentedMatch(content []byte, match [][]byte) bool {
+	// Find the position of the match in the content
+	matchStr := string(match[0])
+	matchIndex := strings.Index(string(content), matchStr)
+	if matchIndex == -1 {
+		return false
+	}
+
+	// Find the start of the line containing this match
+	lineStart := matchIndex
+	for lineStart > 0 && content[lineStart-1] != '\n' {
+		lineStart--
+	}
+
+	// Check if the line starts with # (possibly with leading whitespace)
+	for i := lineStart; i < matchIndex; i++ {
+		char := content[i]
+		if char == '#' {
+			return true // This is a commented line
+		}
+		if char != ' ' && char != '\t' {
+			return false // Found non-whitespace before the directive, not a comment
+		}
+	}
+
+	return false
+}
+
 // GetAllLogs returns all log paths
 func GetAllLogs(filters ...func(*NginxLogCache) bool) []*NginxLogCache {
 	return GetAllLogPaths(filters...)
@@ -116,6 +161,9 @@ func IsLogPathUnderWhiteList(path string) bool {
 	if errorLogPath != "" {
 		logDirWhiteList = append(logDirWhiteList, filepath.Dir(errorLogPath))
 	}
+	if nginx.GetPrefix() != "" {
+		logDirWhiteList = append(logDirWhiteList, nginx.GetPrefix())
+	}
 
 	// No cache, check it
 	if !ok {