fix: module loading regex #1108

Author: 0xJacky

internal/nginx/modules.go

@@ -97,9 +97,8 @@ func updateDynamicModulesStatus() {
 		return
 	}
 
-	// Regular expression to find loaded dynamic modules in nginx -T output
-	// Look for lines like "load_module modules/ngx_http_image_filter_module.so;"
-	loadModuleRe := regexp.MustCompile(`load_module\s+(?:modules/|/.*/)([a-zA-Z0-9_-]+)\.so;`)
+	// Use the shared regex function to find loaded dynamic modules
+	loadModuleRe := GetLoadModuleRegex()
 	matches := loadModuleRe.FindAllStringSubmatch(out, -1)
 
 	for _, match := range matches {
@@ -117,6 +116,24 @@ func updateDynamicModulesStatus() {
 	}
 }
 
+// GetLoadModuleRegex returns a compiled regular expression to match nginx load_module statements.
+// It matches both quoted and unquoted module paths:
+//   - load_module "/usr/local/nginx/modules/ngx_stream_module.so";
+//   - load_module modules/ngx_http_upstream_fair_module.so;
+//
+// The regex captures the module name (without path and extension).
+func GetLoadModuleRegex() *regexp.Regexp {
+	// Pattern explanation:
+	// load_module\s+ - matches "load_module" followed by whitespace
+	// "? - optional opening quote
+	// (?:[^"\s]+/)? - non-capturing group for optional path (any non-quote, non-space chars ending with /)
+	// ([a-zA-Z0-9_-]+) - capturing group for module name
+	// \.so - matches ".so" extension
+	// "? - optional closing quote
+	// \s*; - optional whitespace followed by semicolon
+	return regexp.MustCompile(`load_module\s+"?(?:[^"\s]+/)?([a-zA-Z0-9_-]+)\.so"?\s*;`)
+}
+
 func GetModules() *orderedmap.OrderedMap[string, *Module] {
 	modulesCacheLock.RLock()
 	cachedModules := modulesCache

internal/nginx/modules_test.go

@@ -0,0 +1,118 @@
+package nginx
+
+import (
+	"testing"
+)
+
+func TestGetLoadModuleRegex(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected []string // expected module names
+	}{
+		{
+			name:     "quoted absolute path",
+			input:    `load_module "/usr/local/nginx/modules/ngx_stream_module.so";`,
+			expected: []string{"ngx_stream_module"},
+		},
+		{
+			name:     "unquoted relative path",
+			input:    `load_module modules/ngx_http_upstream_fair_module.so;`,
+			expected: []string{"ngx_http_upstream_fair_module"},
+		},
+		{
+			name:     "quoted relative path",
+			input:    `load_module "modules/ngx_http_geoip_module.so";`,
+			expected: []string{"ngx_http_geoip_module"},
+		},
+		{
+			name:     "unquoted absolute path",
+			input:    `load_module /etc/nginx/modules/ngx_http_cache_purge_module.so;`,
+			expected: []string{"ngx_http_cache_purge_module"},
+		},
+		{
+			name:     "multiple modules",
+			input:    `load_module "/path/ngx_module1.so";\nload_module modules/ngx_module2.so;`,
+			expected: []string{"ngx_module1", "ngx_module2"},
+		},
+		{
+			name:     "with extra whitespace",
+			input:    `load_module    "modules/ngx_test_module.so"   ;`,
+			expected: []string{"ngx_test_module"},
+		},
+		{
+			name:     "no matches",
+			input:    `some other nginx config`,
+			expected: []string{},
+		},
+	}
+
+	regex := GetLoadModuleRegex()
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			matches := regex.FindAllStringSubmatch(tc.input, -1)
+
+			if len(matches) != len(tc.expected) {
+				t.Errorf("Expected %d matches, got %d", len(tc.expected), len(matches))
+				return
+			}
+
+			for i, match := range matches {
+				if len(match) < 2 {
+					t.Errorf("Match %d should have at least 2 groups, got %d", i, len(match))
+					continue
+				}
+
+				moduleName := match[1]
+				expectedModule := tc.expected[i]
+
+				if moduleName != expectedModule {
+					t.Errorf("Expected module name %s, got %s", expectedModule, moduleName)
+				}
+			}
+		})
+	}
+}
+
+func TestModulesLoaded(t *testing.T) {
+	text := `
+load_module "/usr/local/nginx/modules/ngx_stream_module.so";
+load_module modules/ngx_http_upstream_fair_module.so;
+load_module "modules/ngx_http_geoip_module.so";
+load_module /etc/nginx/modules/ngx_http_cache_purge_module.so;
+`
+
+	loadModuleRe := GetLoadModuleRegex()
+	matches := loadModuleRe.FindAllStringSubmatch(text, -1)
+
+	t.Log("matches", matches)
+
+	// Expected module names
+	expectedModules := []string{
+		"ngx_stream_module",
+		"ngx_http_upstream_fair_module",
+		"ngx_http_geoip_module",
+		"ngx_http_cache_purge_module",
+	}
+
+	if len(matches) != len(expectedModules) {
+		t.Errorf("Expected %d matches, got %d", len(expectedModules), len(matches))
+	}
+
+	for i, match := range matches {
+		if len(match) < 2 {
+			t.Errorf("Match %d should have at least 2 groups, got %d", i, len(match))
+			continue
+		}
+
+		moduleName := match[1]
+		expectedModule := expectedModules[i]
+
+		t.Logf("Match %d: %s", i, moduleName)
+
+		if moduleName != expectedModule {
+			t.Errorf("Expected module name %s, got %s", expectedModule, moduleName)
+		}
+	}
+}