optional http logging, updated module watcher

core/http/server.go

@@ -14,21 +14,23 @@ import (
 
 // Server handles HTTP requests using Lua and static file routers
 type Server struct {
-	luaRouter    *routers.LuaRouter
+	luaRouter      *routers.LuaRouter
-	staticRouter *routers.StaticRouter
+	staticRouter   *routers.StaticRouter
-	luaRunner    *runner.LuaRunner
+	luaRunner      *runner.LuaRunner
-	logger       *logger.Logger
+	logger         *logger.Logger
-	httpServer   *http.Server
+	httpServer     *http.Server
+	loggingEnabled bool
 }
 
 // New creates a new HTTP server with optimized connection settings
-func New(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter, runner *runner.LuaRunner, log *logger.Logger) *Server {
+func New(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter, runner *runner.LuaRunner, log *logger.Logger, loggingEnabled bool) *Server {
 	server := &Server{
-		luaRouter:    luaRouter,
+		luaRouter:      luaRouter,
-		staticRouter: staticRouter,
+		staticRouter:   staticRouter,
-		luaRunner:    runner,
+		luaRunner:      runner,
-		logger:       log,
+		logger:         log,
-		httpServer:   &http.Server{},
+		httpServer:     &http.Server{},
+		loggingEnabled: loggingEnabled,
 	}
 	server.httpServer.Handler = server
 
@@ -74,7 +76,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	statusCode := wrappedWriter.StatusCode()
 
 	// Log the request with our custom format
-	LogRequest(s.logger, statusCode, r, duration)
+	if s.loggingEnabled {
+		LogRequest(s.logger, statusCode, r, duration)
+	}
 }
 
 // handleRequest processes the actual request

core/runner/require.go

@@ -212,21 +212,8 @@ func (c *RequireCache) RefreshAll() int {
 		return 0
 	}
 
-	// Collect paths to check
+	// For maximum performance, just clear everything
-	var paths []string
+	c.Clear()
-	c.modules.Range(func(key, _ any) bool {
-		if path, ok := key.(string); ok {
-			paths = append(paths, path)
-		}
-		return true
-	})
-
-	// Check each path
-	for _, path := range paths {
-		if c.RefreshModule(path) {
-			refreshed++
-		}
-	}
 
 	// Reset the needsRefresh flag
 	c.needsRefresh.Store(false)
@@ -267,6 +254,13 @@ func findAndCompileModule(
 		}
 	}
 
+	// If the cache needs refresh, handle it immediately
+	if cache.needsRefresh.Load() {
+		cache.Clear() // Complete reset for max performance
+		cache.needsRefresh.Store(false)
+		cache.lastRefresh = time.Now()
+	}
+
 	// Try each path
 	for _, path := range paths {
 		// Clean the path to handle .. and such (security)
@@ -295,7 +289,7 @@ func findAndCompileModule(
 				return value.([]byte), nil
 			}
 
-			// Only do refresh check if marked as needed (by watcher)
+			// Check file modification time if cache is marked for refresh
 			if cache.needsRefresh.Load() {
 				fileInfo, err := os.Stat(cleanPath)
 				// Remove from cache if file changed or doesn't exist
@@ -303,10 +297,15 @@ func findAndCompileModule(
 					cache.modules.Delete(cleanPath)
 					// Continue to recompile
 				} else {
+					// Update last used time and return cached bytecode
+					entry.LastUsed = time.Now()
+					cache.modules.Store(cleanPath, entry)
 					return entry.Bytecode, nil
 				}
 			} else {
-				// No refresh needed, use cached bytecode
+				// Update last used time and return cached bytecode
+				entry.LastUsed = time.Now()
+				cache.modules.Store(cleanPath, entry)
 				return entry.Bytecode, nil
 			}
 		}

core/watchers/modulewatcher.go

@@ -10,30 +10,32 @@ func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string, log *logger.
 	watchers := make([]*Watcher, 0, len(libDirs))
 
 	for _, dir := range libDirs {
-		// Create a directory-specific callback that only signals changes
+		// Create a directory-specific callback that only does minimal work
-		// without doing heavy processing in the callback itself
 		dirCopy := dir // Capture for closure
 
 		callback := func() error {
 			log.Debug("Detected changes in Lua module directory: %s", dirCopy)
-			// Only mark that refresh is needed instead of doing refresh now
+
-			luaRunner.RequireCache().MarkNeedsRefresh()
+			// Completely reset the cache to match fresh-start performance
+			luaRunner.RequireCache().Clear()
+
+			// Force reset of Lua's module registry
+			luaRunner.ResetPackageLoaded()
+
 			return nil
 		}
 
 		config := WatcherConfig{
-			Dir:       dir,
+			Dir:          dir,
-			Callback:  callback,
+			Callback:     callback,
-			Log:       log,
+			Log:          log,
-			Recursive: true,
+			Recursive:    true,
-			Adaptive:  true,
+			Adaptive:     true,
-			// Use a longer debounce time to avoid too frequent updates
+			DebounceTime: defaultDebounceTime,
-			DebounceTime: defaultDebounceTime * 4,
 		}
 
 		watcher, err := WatchDirectory(config)
 		if err != nil {
-			// Close any watchers we've already created
 			for _, w := range watchers {
 				w.Close()
 			}

core/watchers/watcher.go

@@ -12,11 +12,9 @@ import (
 
 // Default polling intervals
 const (
-	defaultPollInterval   = 1 * time.Second  // Initial polling interval
+	defaultPollInterval  = 1 * time.Second  // Initial polling interval
-	extendedPollInterval  = 5 * time.Second  // Extended polling interval after inactivity
+	extendedPollInterval = 5 * time.Second  // Extended polling interval after inactivity
-	maxPollInterval       = 10 * time.Second // Maximum polling interval after long inactivity
+	inactivityThreshold  = 10 * time.Minute // Time before extending polling interval
-	inactivityThreshold   = 5 * time.Minute  // Time before extending polling interval
-	secondExtendThreshold = 30 * time.Minute // Time before second extension
 )
 
 // Default debounce time between detected change and callback
@@ -121,7 +119,7 @@ func WatchDirectory(config WatcherConfig) (*Watcher, error) {
 	go w.debounceLoop()
 
 	if config.Adaptive {
-		w.logDebug("Started watching with adaptive polling")
+		w.logDebug("Started watching with adaptive polling (1s default, 5s after 10m inactivity)")
 	} else {
 		w.logDebug("Started watching with fixed polling interval: %v", pollInterval)
 	}
@@ -173,17 +171,11 @@ func (w *Watcher) watchLoop() {
 				inactiveDuration := time.Since(w.lastChangeTime)
 
 				if w.pollInterval == w.basePollInterval && inactiveDuration > inactivityThreshold {
-					// First extension
+					// Extend polling interval
 					w.pollInterval = extendedPollInterval
 					ticker.Reset(w.pollInterval)
 					w.logDebug("Extended polling interval to: %v after %v of inactivity",
-						w.pollInterval, inactiveDuration.Round(time.Second))
+						w.pollInterval, inactiveDuration.Round(time.Minute))
-				} else if w.pollInterval == extendedPollInterval && inactiveDuration > secondExtendThreshold {
-					// Second extension
-					w.pollInterval = maxPollInterval
-					ticker.Reset(w.pollInterval)
-					w.logDebug("Extended polling interval to: %v after %v of inactivity",
-						w.pollInterval, inactiveDuration.Round(time.Second))
 				}
 			}
 
@@ -268,6 +260,7 @@ func (w *Watcher) logError(format string, args ...any) {
 	w.log.Error("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
 }
 
+// checkForChanges detects if any files have been added, modified, or deleted
 func (w *Watcher) checkForChanges() (bool, error) {
 	// Get current state
 	currentFiles := make(map[string]FileInfo)
@@ -308,43 +301,36 @@ func (w *Watcher) checkForChanges() (bool, error) {
 		return true, nil
 	}
 
-	// Check for modified files
+	// Check for modified, added, or removed files
-	var changed bool
 	for path, currentInfo := range currentFiles {
 		prevInfo, exists := previousFiles[path]
 		if !exists {
 			// New file
 			w.logDebug("New file detected: %s", path)
-			changed = true
+			w.updateFiles(currentFiles)
-			break
+			return true, nil
 		}
 
 		if currentInfo.ModTime != prevInfo.ModTime || currentInfo.Size != prevInfo.Size {
 			// File modified
 			w.logDebug("File modified: %s", path)
-			changed = true
+			w.updateFiles(currentFiles)
-			break
+			return true, nil
 		}
 	}
 
 	// Check for deleted files
-	if !changed {
+	for path := range previousFiles {
-		for path := range previousFiles {
+		if _, exists := currentFiles[path]; !exists {
-			if _, exists := currentFiles[path]; !exists {
+			// File deleted
-				// File deleted
+			w.logDebug("File deleted: %s", path)
-				w.logDebug("File deleted: %s", path)
+			w.updateFiles(currentFiles)
-				changed = true
+			return true, nil
-				break
-			}
 		}
 	}
 
-	// Update internal files state if there were changes
+	// No changes detected
-	if changed {
+	return false, nil
-		w.updateFiles(currentFiles)
-	}
-
-	return changed, nil
 }
 
 // updateFiles updates the internal file list

moonshark.go

@@ -208,8 +208,15 @@ func main() {
 		}
 	}()
 
+	httpLoggingEnabled := cfg.GetBool("http_logging_enabled", true)
+	if httpLoggingEnabled {
+		log.Info("HTTP logging is enabled")
+	} else {
+		log.Info("HTTP logging is disabled")
+	}
+
 	// Create HTTP server
-	server := http.New(luaRouter, staticRouter, luaRunner, log)
+	server := http.New(luaRouter, staticRouter, luaRunner, log, httpLoggingEnabled)
 
 	// Handle graceful shutdown
 	stop := make(chan os.Signal, 1)