P7: restore agent node type, agent heartbeat expiry, build-version injection, remove log/history/xray-metrics modules, optional sub port

- nodes: port node-type (traditional/agent) picker back from web-src into the embedded frontend; backend annotates NodeView.nodeType from agent_nodes bindings; fix agent-node update path (skip reachability probe and apiToken requirement for agent-managed nodes); restore i18n keys in all 13 locales; install command now uses the Gitea mirror - jobs: expire agent-bound nodes whose agent_nodes.last_seen is older than max(3x heartbeat interval, 120s) = 180s; last_seen=0 (never registered) is left untouched; transitions reuse UpdateHeartbeat + node event broadcast - config: GetBaseVersion honors ldflags-injected buildVersion; release builds inject 3.7.0-agent.1 so the panel no longer reports a phantom update against the Gitea release tag - logger/server: remove the three log viewers (panel/xray/amneziawg), their API endpoints and the 10240-entry in-memory log buffer; file logging via lumberjack unchanged; tests assert via a new optional logger hook instead of the removed buffer - server: remove system history and xray metrics modules end to end (endpoints, sampling appends in RefreshStatus, per-minute persist cron, gob snapshot/restore, XrayMetricsService); realtime status and per-node history are untouched - settings: subPort may be 0/unset - subscription links are generated without a port while the subscription service keeps binding the default 2096; the settings form declares the cleared state via onNumber's new onClear option instead of snapping back to 1
2026-10-21 06:44:00 +00:00
parent 2c85f85549
commit f887f47bb9
66 changed files with 1093 additions and 5129 deletions
@@ -1,5 +1,7 @@
 // Package logger provides logging functionality for the 3x-ui panel with
-// dual-backend logging (console/syslog and file) and buffered log storage for web UI.
+// dual-backend logging (console/syslog and file). The in-memory log buffer
+// that fed the web UI's log viewer was removed together with that feature;
+// logs live on disk (rotating file under the log folder) and in syslog.
 package logger

 import (
@@ -8,7 +10,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"sync"
-	"time"

 	"github.com/op/go-logging"

@@ -18,9 +19,8 @@ import (
 )

 const (
-	maxLogBufferSize = 10240                 // Maximum log entries kept in memory
-	logFileName      = "3xui.log"            // Log file name
-	timeFormat       = "2006/01/02 15:04:05" // Log timestamp format
+	logFileName = "3xui.log"            // Log file name
+	timeFormat  = "2006/01/02 15:04:05" // Log timestamp format

 	// On-disk rotation limits — single file capped, old segments pruned automatically.
 	maxLogFileMB    = 10 // rotate active log when larger than this
@@ -35,16 +35,33 @@ var (
 	logger     = logging.MustGetLogger("x-ui")
 	fileRotate *lumberjack.Logger // nil when file backend disabled

-	// logBuffer maintains recent log entries in memory for web UI retrieval;
-	// logBufferMu guards it — written from many goroutines, read by the web UI.
-	logBufferMu sync.Mutex
-	logBuffer   []struct {
-		time  string
-		level logging.Level
-		log   string
-	}
+	// logHook, when set, additionally receives every log entry. Production
+	// never sets it; it exists so tests can assert on emitted logs now that
+	// the web UI's in-memory buffer is gone.
+	logHookMu sync.RWMutex
+	logHook   func(level, msg string)
 )

+// SetLogHook installs a sink receiving every log entry (level name and
+// formatted message) in addition to the normal backends, and returns the
+// previously installed hook (nil in production). Passing nil clears it.
+func SetLogHook(h func(level, msg string)) func(level, msg string) {
+	logHookMu.Lock()
+	defer logHookMu.Unlock()
+	prev := logHook
+	logHook = h
+	return prev
+}
+
+func emitLogHook(level, msg string) {
+	logHookMu.RLock()
+	h := logHook
+	logHookMu.RUnlock()
+	if h != nil {
+		h(level, msg)
+	}
+}
+
 // InitLogger initializes dual logging backends: console/syslog and file.
 // Console logging uses the specified level, file logging always uses DEBUG level.
 func InitLogger(level logging.Level) {
@@ -135,108 +152,62 @@ func CloseLogger() {
 	}
 }

-// Debug logs a debug message and adds it to the log buffer.
+// Debug logs a debug message and emits it to the log hook.
 func Debug(args ...any) {
 	logger.Debug(args...)
-	addToBuffer("DEBUG", fmt.Sprint(args...))
+	emitLogHook("DEBUG", fmt.Sprint(args...))
 }

-// Debugf logs a formatted debug message and adds it to the log buffer.
+// Debugf logs a formatted debug message and emits it to the log hook.
 func Debugf(format string, args ...any) {
 	logger.Debugf(format, args...)
-	addToBuffer("DEBUG", fmt.Sprintf(format, args...))
+	emitLogHook("DEBUG", fmt.Sprintf(format, args...))
 }

-// Info logs an info message and adds it to the log buffer.
+// Info logs an info message and emits it to the log hook.
 func Info(args ...any) {
 	logger.Info(args...)
-	addToBuffer("INFO", fmt.Sprint(args...))
+	emitLogHook("INFO", fmt.Sprint(args...))
 }

-// Infof logs a formatted info message and adds it to the log buffer.
+// Infof logs a formatted info message and emits it to the log hook.
 func Infof(format string, args ...any) {
 	logger.Infof(format, args...)
-	addToBuffer("INFO", fmt.Sprintf(format, args...))
+	emitLogHook("INFO", fmt.Sprintf(format, args...))
 }

-// Notice logs a notice message and adds it to the log buffer.
+// Notice logs a notice message and emits it to the log hook.
 func Notice(args ...any) {
 	logger.Notice(args...)
-	addToBuffer("NOTICE", fmt.Sprint(args...))
+	emitLogHook("NOTICE", fmt.Sprint(args...))
 }

-// Noticef logs a formatted notice message and adds it to the log buffer.
+// Noticef logs a formatted notice message and emits it to the log hook.
 func Noticef(format string, args ...any) {
 	logger.Noticef(format, args...)
-	addToBuffer("NOTICE", fmt.Sprintf(format, args...))
+	emitLogHook("NOTICE", fmt.Sprintf(format, args...))
 }

-// Warning logs a warning message and adds it to the log buffer.
+// Warning logs a warning message and emits it to the log hook.
 func Warning(args ...any) {
 	logger.Warning(args...)
-	addToBuffer("WARNING", fmt.Sprint(args...))
+	emitLogHook("WARNING", fmt.Sprint(args...))
 }

-// Warningf logs a formatted warning message and adds it to the log buffer.
+// Warningf logs a formatted warning message and emits it to the log hook.
 func Warningf(format string, args ...any) {
 	logger.Warningf(format, args...)
-	addToBuffer("WARNING", fmt.Sprintf(format, args...))
+	emitLogHook("WARNING", fmt.Sprintf(format, args...))
 }

-// Error logs an error message and adds it to the log buffer.
+// Error logs an error message and emits it to the log hook.
 func Error(args ...any) {
 	logger.Error(args...)
-	addToBuffer("ERROR", fmt.Sprint(args...))
+	emitLogHook("ERROR", fmt.Sprint(args...))
 }

-// Errorf logs a formatted error message and adds it to the log buffer.
+// Errorf logs a formatted error message and emits it to the log hook.
 func Errorf(format string, args ...any) {
 	logger.Errorf(format, args...)
-	addToBuffer("ERROR", fmt.Sprintf(format, args...))
-}
-
-// addToBuffer adds a log entry to the in-memory ring buffer for web UI retrieval.
-func addToBuffer(level string, newLog string) {
-	t := time.Now()
-	logBufferMu.Lock()
-	defer logBufferMu.Unlock()
-	if len(logBuffer) >= maxLogBufferSize {
-		logBuffer = logBuffer[1:]
-	}
-
-	logLevel, _ := logging.LogLevel(level)
-	logBuffer = append(logBuffer, struct {
-		time  string
-		level logging.Level
-		log   string
-	}{
-		time:  t.Format(timeFormat),
-		level: logLevel,
-		log:   newLog,
-	})
-}
-
-// GetLogs retrieves up to c log entries from the buffer that are at or below the specified level.
-func GetLogs(c int, level string) []string {
-	var output []string
-	logLevel, _ := logging.LogLevel(level)
-
-	// Snapshot (copy) under the lock, then filter/format unlocked: a UI log fetch
-	// must not block addToBuffer — and thus all logging — for the formatting loop.
-	// A copy (not a reslice) is required, since addToBuffer can append in place.
-	logBufferMu.Lock()
-	snapshot := make([]struct {
-		time  string
-		level logging.Level
-		log   string
-	}, len(logBuffer))
-	copy(snapshot, logBuffer)
-	logBufferMu.Unlock()
-
-	for i := len(snapshot) - 1; i >= 0 && len(output) < c; i-- {
-		if snapshot[i].level <= logLevel {
-			output = append(output, fmt.Sprintf("%s %s - %s", snapshot[i].time, snapshot[i].level, snapshot[i].log))
-		}
-	}
-	return output
+	emitLogHook("ERROR", fmt.Sprintf(format, args...))
 }
@@ -2,29 +2,47 @@ package logger

 import (
 	"fmt"
+	"sync"
 	"testing"
 )

-// TestGetLogs_ReturnsAtMostC guards the documented "up to c entries" contract.
-// The loop condition must cap output at c (ERROR entries are queried at "debug"
-// level so the level filter passes all of them, isolating the count).
-func TestGetLogs_ReturnsAtMostC(t *testing.T) {
-	logBufferMu.Lock()
-	logBuffer = nil
-	logBufferMu.Unlock()
-	for i := range 5 {
-		addToBuffer("ERROR", fmt.Sprintf("m%d", i))
-	}
+// TestLogHookReceivesEntries replaces the old in-memory buffer tests: the
+// buffer (and its GetLogs accessor) was removed with the web log viewer, and
+// the hook is now the only side channel tests assert on.
+func TestLogHookReceivesEntries(t *testing.T) {
+	var mu sync.Mutex
+	var got []string
+	prev := SetLogHook(func(level, msg string) {
+		mu.Lock()
+		defer mu.Unlock()
+		got = append(got, level+" "+msg)
+	})
+	t.Cleanup(func() { SetLogHook(prev) })

-	cases := []struct{ c, want int }{
-		{0, 0},
-		{2, 2},
-		{5, 5},
-		{10, 5}, // capped at what's available
+	Debug("d1")
+	Infof("i%d", 2)
+	Warning("w3")
+	Errorf("e%s", "4")
+
+	want := []string{"DEBUG d1", "INFO i2", "WARNING w3", "ERROR e4"}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(got) != len(want) {
+		t.Fatalf("hook captured %v, want %v", got, want)
 	}
-	for _, tc := range cases {
-		if got := GetLogs(tc.c, "debug"); len(got) != tc.want {
-			t.Errorf("GetLogs(%d) returned %d entries, want %d", tc.c, len(got), tc.want)
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("hook entry %d = %q, want %q", i, got[i], want[i])
 		}
 	}
 }
+
+// TestLogHookUnsetIsSilent guards the production path: with no hook
+// installed, logging must simply not panic.
+func TestLogHookUnsetIsSilent(t *testing.T) {
+	prev := SetLogHook(nil)
+	t.Cleanup(func() { SetLogHook(prev) })
+	for i := range 3 {
+		Info(fmt.Sprintf("m%d", i))
+	}
+}