platform: modularize api/gui, add docs-tests-web foundation, and refresh root config

selective-vpn-api/app/trace_handlers_write.go

@@ -0,0 +1,173 @@
+package app
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+// ---------------------------------------------------------------------
+// trace append
+// ---------------------------------------------------------------------
+
+// POST /api/v1/trace/append { "kind": "gui|smartdns|info", "line": "..." }
+func handleTraceAppend(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Kind string `json:"kind"`
+		Line string `json:"line"`
+	}
+	if r.Body != nil {
+		defer r.Body.Close()
+		_ = json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body)
+	}
+	kind := strings.ToLower(strings.TrimSpace(body.Kind))
+	line := strings.TrimRight(body.Line, "\r\n")
+
+	if line == "" {
+		writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+		return
+	}
+
+	_ = os.MkdirAll(stateDir, 0o755)
+
+	switch kind {
+	case "smartdns":
+		appendTraceLineTo(smartdnsLogPath, "smartdns", line)
+	case "gui":
+		appendTraceLineTo(traceLogPath, "gui", line)
+	default:
+		appendTraceLineTo(traceLogPath, "info", line)
+	}
+
+	events.push("trace_append", map[string]any{
+		"kind": kind,
+	})
+
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+// ---------------------------------------------------------------------
+// trace write helpers
+// ---------------------------------------------------------------------
+
+func appendTraceLineTo(path, prefix, line string) {
+	line = strings.TrimRight(line, "\r\n")
+	if line == "" {
+		return
+	}
+	ts := time.Now().UTC().Format(time.RFC3339)
+	_ = os.MkdirAll(stateDir, 0o755)
+
+	// простейший "ручной логротейт"
+	const maxSize = 10 * 1024 * 1024 // 10 МБ
+	if fi, err := os.Stat(path); err == nil && fi.Size() > maxSize {
+		// можно просто truncate
+		_ = os.Truncate(path, 0)
+		// или переименовать в *.1 и начать новый
+		// _ = os.Rename(path, path+".1")
+	}
+
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	_, _ = fmt.Fprintf(f, "[%s] %s %s\n", prefix, ts, line)
+}
+
+// ---------------------------------------------------------------------
+// EN: `appendTraceLine` appends or adds trace line to an existing state.
+// RU: `appendTraceLine` - добавляет trace line в текущее состояние.
+// ---------------------------------------------------------------------
+func appendTraceLine(prefix, line string) {
+	appendTraceLineTo(traceLogPath, prefix, line)
+}
+
+const (
+	traceRateLimitDefaultWindow = 20 * time.Second
+	traceRateLimitMaxEntries    = 1024
+)
+
+type traceRateLimitState struct {
+	lastAt     time.Time
+	suppressed int
+}
+
+var (
+	traceRateLimitMu    sync.Mutex
+	traceRateLimitCache = map[string]traceRateLimitState{}
+)
+
+// appendTraceLineRateLimited keeps first line in the window and suppresses exact duplicates.
+// When window is over, it writes one compact summary for suppressed duplicates.
+func appendTraceLineRateLimited(prefix, line string, window time.Duration) {
+	line = strings.TrimSpace(strings.TrimRight(line, "\r\n"))
+	if line == "" {
+		return
+	}
+	if window <= 0 {
+		window = traceRateLimitDefaultWindow
+	}
+
+	now := time.Now().UTC()
+	key := strings.TrimSpace(prefix) + "\n" + line
+
+	var summary string
+	writeCurrent := true
+
+	traceRateLimitMu.Lock()
+	st, ok := traceRateLimitCache[key]
+	if ok && !st.lastAt.IsZero() && now.Sub(st.lastAt) < window {
+		st.suppressed++
+		traceRateLimitCache[key] = st
+		writeCurrent = false
+	} else {
+		if ok && st.suppressed > 0 {
+			summary = fmt.Sprintf("trace dedup: suppressed=%d within=%s line=%q", st.suppressed, window.String(), line)
+		}
+		st.lastAt = now
+		st.suppressed = 0
+		traceRateLimitCache[key] = st
+	}
+	traceRateLimitShrinkLocked(now)
+	traceRateLimitMu.Unlock()
+
+	if summary != "" {
+		appendTraceLineTo(traceLogPath, prefix, summary)
+	}
+	if writeCurrent {
+		appendTraceLineTo(traceLogPath, prefix, line)
+	}
+}
+
+func traceRateLimitShrinkLocked(now time.Time) {
+	if len(traceRateLimitCache) <= traceRateLimitMaxEntries {
+		return
+	}
+	cutoff := now.Add(-10 * time.Minute)
+	for key, st := range traceRateLimitCache {
+		if st.lastAt.Before(cutoff) && st.suppressed == 0 {
+			delete(traceRateLimitCache, key)
+		}
+	}
+	if len(traceRateLimitCache) <= traceRateLimitMaxEntries {
+		return
+	}
+	overflow := len(traceRateLimitCache) - traceRateLimitMaxEntries
+	for key := range traceRateLimitCache {
+		delete(traceRateLimitCache, key)
+		overflow--
+		if overflow <= 0 {
+			break
+		}
+	}
+}