implement godoxy-agent

2026-04-23 01:08:47 +02:00 · 2025-02-10 09:36:37 +08:00
parent ecb89f80a0
commit eaf191e350
57 changed files with 1479 additions and 467 deletions
--- a/internal/logging/html.go
+++ b/internal/logging/html.go
@@ -1,159 +0,0 @@
-package logging
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/rs/zerolog"
-	"github.com/yusing/go-proxy/internal/common"
-)
-
-var levelHTMLFormats = [][]byte{
-	[]byte(` <span class="log-trace">TRC</span> `),
-	[]byte(` <span class="log-debug">DBG</span> `),
-	[]byte(` <span class="log-info">INF</span> `),
-	[]byte(` <span class="log-warn">WRN</span> `),
-	[]byte(` <span class="log-error">ERR</span> `),
-	[]byte(` <span class="log-fatal">FTL</span> `),
-	[]byte(` <span class="log-panic">PAN</span> `),
-}
-
-var colorToClass = map[string]string{
-	"1":  "log-bold",
-	"3":  "log-italic",
-	"4":  "log-underline",
-	"30": "log-black",
-	"31": "log-red",
-	"32": "log-green",
-	"33": "log-yellow",
-	"34": "log-blue",
-	"35": "log-magenta",
-	"36": "log-cyan",
-	"37": "log-white",
-	"90": "log-bright-black",
-	"91": "log-red",
-	"92": "log-bright-green",
-	"93": "log-bright-yellow",
-	"94": "log-bright-blue",
-	"95": "log-bright-magenta",
-	"96": "log-bright-cyan",
-	"97": "log-bright-white",
-}
-
-// FormatMessageToHTMLBytes converts text with ANSI color codes to HTML with class names.
-// ANSI codes are mapped to classes via a static map, and reset codes ([0m) close all spans.
-// Time complexity is O(n) with minimal allocations.
-func FormatMessageToHTMLBytes(msg string, buf []byte) ([]byte, error) {
-	buf = append(buf, "<span class=\"log-message\">"...)
-	var stack []string
-	lastPos := 0
-
-	for i := 0; i < len(msg); {
-		if msg[i] == '\x1b' && i+1 < len(msg) && msg[i+1] == '[' {
-			if lastPos < i {
-				escapeAndAppend(msg[lastPos:i], &buf)
-			}
-			i += 2 // Skip \x1b[
-
-			start := i
-			for ; i < len(msg) && msg[i] != 'm'; i++ {
-				if !isANSICodeChar(msg[i]) {
-					return nil, fmt.Errorf("invalid ANSI char: %c", msg[i])
-				}
-			}
-
-			if i >= len(msg) {
-				return nil, errors.New("unterminated ANSI sequence")
-			}
-
-			codeStr := msg[start:i]
-			i++ // Skip 'm'
-			lastPos = i
-
-			startPart := 0
-			for j := 0; j <= len(codeStr); j++ {
-				if j == len(codeStr) || codeStr[j] == ';' {
-					part := codeStr[startPart:j]
-					if part == "" {
-						return nil, errors.New("empty code part")
-					}
-
-					if part == "0" {
-						for range stack {
-							buf = append(buf, "</span>"...)
-						}
-						stack = stack[:0]
-					} else {
-						className, ok := colorToClass[part]
-						if !ok {
-							return nil, fmt.Errorf("invalid ANSI code: %s", part)
-						}
-						stack = append(stack, className)
-						buf = append(buf, `<span class="`...)
-						buf = append(buf, className...)
-						buf = append(buf, `">`...)
-					}
-					startPart = j + 1
-				}
-			}
-		} else {
-			i++
-		}
-	}
-
-	if lastPos < len(msg) {
-		escapeAndAppend(msg[lastPos:], &buf)
-	}
-
-	for range stack {
-		buf = append(buf, "</span>"...)
-	}
-
-	buf = append(buf, "</span>"...)
-	return buf, nil
-}
-
-func isANSICodeChar(c byte) bool {
-	return (c >= '0' && c <= '9') || c == ';'
-}
-
-func escapeAndAppend(s string, buf *[]byte) {
-	for i, r := range s {
-		switch r {
-		case '•':
-			*buf = append(*buf, "&middot;"...)
-		case '&':
-			*buf = append(*buf, "&amp;"...)
-		case '<':
-			*buf = append(*buf, "&lt;"...)
-		case '>':
-			*buf = append(*buf, "&gt;"...)
-		case '\t':
-			*buf = append(*buf, "&#9;"...)
-		case '\n':
-			*buf = append(*buf, "<br>"...)
-			*buf = append(*buf, prefixHTML...)
-		default:
-			*buf = append(*buf, s[i])
-		}
-	}
-}
-
-func timeNowHTML() []byte {
-	if !common.IsTest {
-		return []byte(time.Now().Format(timeFmt))
-	}
-	return []byte(time.Date(2024, 1, 1, 1, 1, 1, 1, time.UTC).Format(timeFmt))
-}
-
-func FormatLogEntryHTML(level zerolog.Level, message string, buf []byte) []byte {
-	buf = append(buf, []byte(`<pre class="log-entry">`)...)
-	buf = append(buf, timeNowHTML()...)
-	if level < zerolog.NoLevel {
-		buf = append(buf, levelHTMLFormats[level+1]...)
-	}
-	buf, _ = FormatMessageToHTMLBytes(message, buf)
-	buf = append(buf, []byte("</pre>")...)
-	return buf
-}
--- a/internal/logging/html_test.go
+++ b/internal/logging/html_test.go
@@ -1,30 +0,0 @@
-package logging
-
-import (
-	"testing"
-
-	"github.com/rs/zerolog"
-	. "github.com/yusing/go-proxy/internal/utils/testing"
-)
-
-func TestFormatHTML(t *testing.T) {
-	buf := make([]byte, 0, 100)
-	buf = FormatLogEntryHTML(zerolog.InfoLevel, "This is a test.\nThis is a new line.", buf)
-	ExpectEqual(t, string(buf), `<pre class="log-entry">01-01 01:01 <span class="log-info">INF</span> <span class="log-message">This is a test.<br>`+prefix+`This is a new line.</span></pre>`)
-}
-
-func TestFormatHTMLANSI(t *testing.T) {
-	buf := make([]byte, 0, 100)
-	buf = FormatLogEntryHTML(zerolog.InfoLevel, "This is \x1b[91m\x1b[1ma test.\x1b[0mOK!.", buf)
-	ExpectEqual(t, string(buf), `<pre class="log-entry">01-01 01:01 <span class="log-info">INF</span> <span class="log-message">This is <span class="log-red"><span class="log-bold">a test.</span></span>OK!.</span></pre>`)
-	buf = buf[:0]
-	buf = FormatLogEntryHTML(zerolog.InfoLevel, "This is \x1b[91ma \x1b[1mtest.\x1b[0mOK!.", buf)
-	ExpectEqual(t, string(buf), `<pre class="log-entry">01-01 01:01 <span class="log-info">INF</span> <span class="log-message">This is <span class="log-red">a <span class="log-bold">test.</span></span>OK!.</span></pre>`)
-}
-
-func BenchmarkFormatLogEntryHTML(b *testing.B) {
-	buf := make([]byte, 0, 250)
-	for range b.N {
-		FormatLogEntryHTML(zerolog.InfoLevel, "This is \x1b[91ma \x1b[1mtest.\x1b[0mOK!.", buf)
-	}
-}
--- a/internal/logging/memlogger/mem_logger.go
+++ b/internal/logging/memlogger/mem_logger.go
@@ -0,0 +1,207 @@
+package memlogger
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+	"github.com/yusing/go-proxy/internal/api/v1/utils"
+	"github.com/yusing/go-proxy/internal/common"
+	config "github.com/yusing/go-proxy/internal/config/types"
+	"github.com/yusing/go-proxy/internal/logging"
+	"github.com/yusing/go-proxy/internal/task"
+	F "github.com/yusing/go-proxy/internal/utils/functional"
+)
+
+type logEntryRange struct {
+	Start, End int
+}
+
+type memLogger struct {
+	bytes.Buffer
+	sync.RWMutex
+	notifyLock sync.RWMutex
+	connChans  F.Map[chan *logEntryRange, struct{}]
+
+	bufPool sync.Pool // used in hook mode
+}
+
+type MemLogger io.Writer
+
+type buffer struct {
+	data []byte
+}
+
+const (
+	maxMemLogSize         = 16 * 1024
+	truncateSize          = maxMemLogSize / 2
+	initialWriteChunkSize = 4 * 1024
+	hookModeBufSize       = 256
+)
+
+var memLoggerInstance = &memLogger{
+	connChans: F.NewMapOf[chan *logEntryRange, struct{}](),
+	bufPool: sync.Pool{
+		New: func() any {
+			return &buffer{
+				data: make([]byte, 0, hookModeBufSize),
+			}
+		},
+	},
+}
+
+func init() {
+	if !common.EnableLogStreaming {
+		return
+	}
+	memLoggerInstance.Grow(maxMemLogSize)
+
+	if common.DebugMemLogger {
+		ticker := time.NewTicker(1 * time.Second)
+
+		go func() {
+			defer ticker.Stop()
+
+			for {
+				select {
+				case <-task.RootContextCanceled():
+					return
+				case <-ticker.C:
+					logging.Info().Msgf("mem logger size: %d, active conns: %d",
+						memLoggerInstance.Len(),
+						memLoggerInstance.connChans.Size())
+				}
+			}
+		}()
+	}
+}
+
+func LogsWS(config config.ConfigInstance) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		memLoggerInstance.ServeHTTP(config, w, r)
+	}
+}
+
+func GetMemLogger() MemLogger {
+	return memLoggerInstance
+}
+
+func (m *memLogger) truncateIfNeeded(n int) {
+	m.RLock()
+	needTruncate := m.Len()+n > maxMemLogSize
+	m.RUnlock()
+
+	if needTruncate {
+		m.Lock()
+		defer m.Unlock()
+		needTruncate = m.Len()+n > maxMemLogSize
+		if !needTruncate {
+			return
+		}
+
+		m.Truncate(truncateSize)
+	}
+}
+
+func (m *memLogger) notifyWS(pos, n int) {
+	if m.connChans.Size() > 0 {
+		timeout := time.NewTimer(1 * time.Second)
+		defer timeout.Stop()
+
+		m.notifyLock.RLock()
+		defer m.notifyLock.RUnlock()
+		m.connChans.Range(func(ch chan *logEntryRange, _ struct{}) bool {
+			select {
+			case ch <- &logEntryRange{pos, pos + n}:
+				return true
+			case <-timeout.C:
+				logging.Warn().Msg("mem logger: timeout logging to channel")
+				return false
+			}
+		})
+		return
+	}
+}
+
+func (m *memLogger) writeBuf(b []byte) (pos int, err error) {
+	m.Lock()
+	defer m.Unlock()
+	pos = m.Len()
+	_, err = m.Buffer.Write(b)
+	return
+}
+
+// Write implements io.Writer.
+func (m *memLogger) Write(p []byte) (n int, err error) {
+	n = len(p)
+	m.truncateIfNeeded(n)
+
+	pos, err := m.writeBuf(p)
+	if err != nil {
+		// not logging the error here, it will cause Run to be called again = infinite loop
+		return
+	}
+
+	m.notifyWS(pos, n)
+	return
+}
+
+func (m *memLogger) ServeHTTP(config config.ConfigInstance, w http.ResponseWriter, r *http.Request) {
+	conn, err := utils.InitiateWS(config, w, r)
+	if err != nil {
+		utils.HandleErr(w, r, err)
+		return
+	}
+
+	logCh := make(chan *logEntryRange)
+	m.connChans.Store(logCh, struct{}{})
+
+	/* trunk-ignore(golangci-lint/errcheck) */
+	defer func() {
+		_ = conn.CloseNow()
+
+		m.notifyLock.Lock()
+		m.connChans.Delete(logCh)
+		close(logCh)
+		m.notifyLock.Unlock()
+	}()
+
+	if err := m.wsInitial(r.Context(), conn); err != nil {
+		utils.HandleErr(w, r, err)
+		return
+	}
+
+	m.wsStreamLog(r.Context(), conn, logCh)
+}
+
+func (m *memLogger) writeBytes(ctx context.Context, conn *websocket.Conn, b []byte) error {
+	return conn.Write(ctx, websocket.MessageText, b)
+}
+
+func (m *memLogger) wsInitial(ctx context.Context, conn *websocket.Conn) error {
+	m.Lock()
+	defer m.Unlock()
+
+	return m.writeBytes(ctx, conn, m.Buffer.Bytes())
+}
+
+func (m *memLogger) wsStreamLog(ctx context.Context, conn *websocket.Conn, ch <-chan *logEntryRange) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case logRange := <-ch:
+			m.RLock()
+			msg := m.Buffer.Bytes()[logRange.Start:logRange.End]
+			err := m.writeBytes(ctx, conn, msg)
+			m.RUnlock()
+			if err != nil {
+				return
+			}
+		}
+	}
+}