chore: massive optimization overhaul

Author: mirkobrombin

internal/config/config.go

@@ -25,15 +25,19 @@ type SSLConfig struct {
 
 // SiteConfig contains the configuration for a single site.
 type SiteConfig struct {
-	Domain         string            `json:"domain"`
-	Port           int               `json:"port"`
-	RootDirectory  string            `json:"root_directory"`
-	CustomHeaders  map[string]string `json:"custom_headers"`
-	ProxyPass      string            `json:"proxy_pass"`
-	SSL            SSLConfig         `json:"ssl"`
-	RequestTimeout int               `json:"request_timeout"` // in seconds
-	FlushInterval  string            `json:"proxy_flush_interval"`
-	BufferSizeKB   int               `json:"buffer_size_kb"`
+	Domain            string            `json:"domain"`
+	Port              int               `json:"port"`
+	RootDirectory     string            `json:"root_directory"`
+	CustomHeaders     map[string]string `json:"custom_headers"`
+	ProxyPass         string            `json:"proxy_pass"`
+	SSL               SSLConfig         `json:"ssl"`
+	RequestTimeout    int               `json:"request_timeout"`     // in seconds
+	ReadHeaderTimeout int               `json:"read_header_timeout"` // in seconds
+	IdleTimeout       int               `json:"idle_timeout"`        // in seconds
+	MaxHeaderBytes    int               `json:"max_header_bytes"`    // in bytes
+	FlushInterval     string            `json:"proxy_flush_interval"`
+	BufferSizeKB      int               `json:"buffer_size_kb"`
+	EnableLogging     *bool             `json:"enable_logging,omitempty"` // Default true if nil
 
 	PluginConfigs map[string]interface{} `json:"plugin_configs"`
 }

internal/server/handler.go

@@ -60,8 +60,11 @@ func createHandler(conf config.SiteConfig, log *logger.Logger, identifier string
 		siteMwManager.Use(middleware.TimeoutMiddleware(timeout))
 	}
 
-	// Add logging middleware last to ensure it wraps the entire request
-	siteMwManager.Use(middleware.LoggingMiddleware(log, conf.Domain, identifier))
+	// Add logging middleware last to ensure it wraps the entire request.
+	// We default to true if the pointer is nil.
+	if conf.EnableLogging == nil || *conf.EnableLogging {
+		siteMwManager.Use(middleware.LoggingMiddleware(log, conf.Domain, identifier))
+	}
 
 	// Apply the final chain of middleware
 	handler = siteMwManager.Apply(handler)

internal/server/middleware/async_logger.go

@@ -0,0 +1,89 @@
+package middleware
+
+import (
+	"sync"
+
+	"github.com/mirkobrombin/goup/internal/logger"
+	"github.com/mirkobrombin/goup/internal/tui"
+)
+
+// LogEntry represents a single log event.
+type LogEntry struct {
+	Logger     *logger.Logger
+	Fields     logger.Fields
+	Message    string
+	Identifier string
+}
+
+// AsyncLogger handles logging asynchronously.
+type AsyncLogger struct {
+	logChan      chan *LogEntry
+	logEntryPool sync.Pool
+}
+
+var globalAsyncLogger *AsyncLogger
+
+// InitAsyncLogger initializes the global async logger.
+func InitAsyncLogger(bufferSize int) {
+	globalAsyncLogger = &AsyncLogger{
+		logChan: make(chan *LogEntry, bufferSize),
+		logEntryPool: sync.Pool{
+			New: func() interface{} {
+				return &LogEntry{
+					Fields: make(logger.Fields),
+				}
+			},
+		},
+	}
+	go globalAsyncLogger.worker()
+}
+
+// GetAsyncLogger returns the global async logger instance.
+func GetAsyncLogger() *AsyncLogger {
+	return globalAsyncLogger
+}
+
+// GetEntry retrieves a LogEntry from the pool.
+func (al *AsyncLogger) GetEntry() *LogEntry {
+	return al.logEntryPool.Get().(*LogEntry)
+}
+
+// Log queues a log entry. If the buffer is full, the log is dropped
+// and the entry is returned to the pool immediately.
+func (al *AsyncLogger) Log(entry *LogEntry) {
+	select {
+	case al.logChan <- entry:
+	default:
+		// Drop log if buffer is full to maintain performance
+		al.PutEntry(entry)
+	}
+}
+
+// PutEntry resets and returns a LogEntry to the pool.
+func (al *AsyncLogger) PutEntry(entry *LogEntry) {
+	entry.Logger = nil
+	entry.Message = ""
+	entry.Identifier = ""
+	for k := range entry.Fields {
+		delete(entry.Fields, k)
+	}
+	al.logEntryPool.Put(entry)
+}
+
+// worker processes log entries from the channel.
+func (al *AsyncLogger) worker() {
+	for entry := range al.logChan {
+		entry.Logger.WithFields(entry.Fields).Info(entry.Message)
+
+		if tui.IsEnabled() {
+			tui.UpdateLog(entry.Identifier, entry.Fields)
+		}
+
+		al.PutEntry(entry)
+	}
+}
+
+// Shutdown closes the log channel.
+func (al *AsyncLogger) Shutdown() {
+	close(al.logChan)
+}

internal/server/middleware/middleware.go

@@ -1,8 +1,12 @@
 package middleware
 
 import (
+	"bufio"
 	"fmt"
+	"io"
+	"net"
 	"net/http"
+	"sync"
 	"time"
 
 	"github.com/mirkobrombin/goup/internal/logger"
@@ -11,11 +15,21 @@ import (
 
 // LoggingMiddleware logs HTTP requests.
 func LoggingMiddleware(l *logger.Logger, domain string, identifier string) MiddlewareFunc {
+	// sync.Pool for responseWriter to reduce allocation (Operation "31")
+	rwPool := sync.Pool{
+		New: func() interface{} {
+			return &responseWriter{}
+		},
+	}
+
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			start := time.Now()
 
-			rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+			// Get ResponseWriter from pool
+			rw := rwPool.Get().(*responseWriter)
+			rw.ResponseWriter = w
+			rw.statusCode = http.StatusOK
 
 			next.ServeHTTP(rw, r)
 
@@ -29,19 +43,38 @@ func LoggingMiddleware(l *logger.Logger, domain string, identifier string) Middl
 				remoteAddr = ips
 			}
 
-			fields := logger.Fields{
-				"method":       r.Method,
-				"url":          r.URL.String(),
-				"remote_addr":  remoteAddr,
-				"status_code":  rw.statusCode,
-				"duration_sec": duration.Seconds(),
-				"domain":       domain,
+			// Use Async Logging if initialized
+			if asyncLog := GetAsyncLogger(); asyncLog != nil {
+				entry := asyncLog.GetEntry()
+				entry.Logger = l
+				entry.Message = "Handled request"
+				entry.Identifier = identifier
+				entry.Fields["method"] = r.Method
+				entry.Fields["url"] = r.URL.String()
+				entry.Fields["remote_addr"] = remoteAddr
+				entry.Fields["status_code"] = rw.statusCode
+				entry.Fields["duration_sec"] = duration.Seconds()
+				entry.Fields["domain"] = domain
+
+				asyncLog.Log(entry)
+			} else {
+				// Fallback to sync logging (creates allocations)
+				fields := logger.Fields{
+					"method":       r.Method,
+					"url":          r.URL.String(),
+					"remote_addr":  remoteAddr,
+					"status_code":  rw.statusCode,
+					"duration_sec": duration.Seconds(),
+					"domain":       domain,
+				}
+				l.WithFields(fields).Info("Handled request")
+				if tui.IsEnabled() {
+					tui.UpdateLog(identifier, fields)
+				}
 			}
-			l.WithFields(fields).Info("Handled request")
 
-			if tui.IsEnabled() {
-				tui.UpdateLog(identifier, fields)
-			}
+			rw.ResponseWriter = nil
+			rwPool.Put(rw)
 		})
 	}
 }
@@ -91,3 +124,34 @@ func (rw *responseWriter) WriteHeader(code int) {
 	rw.statusCode = code
 	rw.ResponseWriter.WriteHeader(code)
 }
+
+// Flush implements http.Flusher.
+func (rw *responseWriter) Flush() {
+	if flusher, ok := rw.ResponseWriter.(http.Flusher); ok {
+		flusher.Flush()
+	}
+}
+
+// Hijack implements http.Hijacker.
+func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hijacker, ok := rw.ResponseWriter.(http.Hijacker); ok {
+		return hijacker.Hijack()
+	}
+	return nil, nil, http.ErrNotSupported
+}
+
+// ReadFrom implements io.ReaderFrom.
+func (rw *responseWriter) ReadFrom(r io.Reader) (n int64, err error) {
+	if rf, ok := rw.ResponseWriter.(io.ReaderFrom); ok {
+		return rf.ReadFrom(r)
+	}
+	return io.Copy(rw.ResponseWriter, r)
+}
+
+// Push implements http.Pusher.
+func (rw *responseWriter) Push(target string, opts *http.PushOptions) error {
+	if pusher, ok := rw.ResponseWriter.(http.Pusher); ok {
+		return pusher.Push(target, opts)
+	}
+	return http.ErrNotSupported
+}

internal/server/server.go

@@ -33,6 +33,9 @@ func StartServers(configs []config.SiteConfig, enableTUI bool, enableBench bool)
 		tui.InitTUI()
 	}
 
+	// Initialize the global async logger
+	middleware.InitAsyncLogger(10000)
+
 	// Start API Server if enabled
 	api.StartAPIServer()
 

internal/server/server_utils.go

@@ -1,28 +1,64 @@
 package server
 
 import (
+	"context"
 	"crypto/tls"
 	"fmt"
+	"net"
 	"net/http"
 	"os"
+	"syscall"
 	"time"
 
 	"github.com/mirkobrombin/goup/internal/config"
 	"github.com/mirkobrombin/goup/internal/logger"
 	"github.com/quic-go/quic-go/http3"
+	"golang.org/x/sys/unix"
 )
 
 // createHTTPServer creates an HTTP server with the given configuration and handler.
 func createHTTPServer(conf config.SiteConfig, handler http.Handler) *http.Server {
-	return &http.Server{
+	readTimeout := time.Duration(0)
+	writeTimeout := time.Duration(0)
+	if conf.RequestTimeout >= 0 {
+		readTimeout = time.Duration(conf.RequestTimeout) * time.Second
+		writeTimeout = time.Duration(conf.RequestTimeout) * time.Second
+	}
+
+	s := &http.Server{
 		Addr:         fmt.Sprintf(":%d", conf.Port),
 		Handler:      handler,
-		ReadTimeout:  time.Duration(conf.RequestTimeout) * time.Second,
-		WriteTimeout: time.Duration(conf.RequestTimeout) * time.Second,
+		ReadTimeout:  readTimeout,
+		WriteTimeout: writeTimeout,
 		TLSConfig: &tls.Config{
 			NextProtos: []string{"h3", "h2", "http/1.1"},
 		},
 	}
+
+	if conf.ReadHeaderTimeout > 0 {
+		s.ReadHeaderTimeout = time.Duration(conf.ReadHeaderTimeout) * time.Second
+	}
+	if conf.IdleTimeout > 0 {
+		s.IdleTimeout = time.Duration(conf.IdleTimeout) * time.Second
+	}
+	if conf.MaxHeaderBytes > 0 {
+		s.MaxHeaderBytes = conf.MaxHeaderBytes
+	}
+
+	return s
+}
+
+// listenOptimized creates a TCP listener with SO_REUSEPORT and TCP_FASTOPEN optimizations.
+func listenOptimized(addr string) (net.Listener, error) {
+	lc := net.ListenConfig{
+		Control: func(network, address string, c syscall.RawConn) error {
+			return c.Control(func(fd uintptr) {
+				unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+				unix.SetsockoptInt(int(fd), unix.SOL_TCP, unix.TCP_FASTOPEN, 256)
+			})
+		},
+	}
+	return lc.Listen(context.Background(), "tcp", addr)
 }
 
 // startServerInstance starts the HTTP server instance.
@@ -56,7 +92,12 @@ func startServerInstance(server *http.Server, conf config.SiteConfig, l *logger.
 			}
 		} else {
 			l.Infof("Serving on HTTP port %d", conf.Port)
-			if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			ln, err := listenOptimized(server.Addr)
+			if err != nil {
+				l.Errorf("Error listening on port %d: %v", conf.Port, err)
+				return
+			}
+			if err := server.Serve(ln); err != nil && err != http.ErrServerClosed {
 				l.Errorf("Server error on port %d: %v", conf.Port, err)
 			}
 		}