mirror of
https://github.com/lukaszraczylo/kportal.git
synced 2026-07-05 06:05:39 +00:00
improvements nov2025 (#10)
* Add benchmark and httplog modules, update UI for modals artefacts
This commit is contained in:
GitHub
@@ -0,0 +1,112 @@
|
||||
package httplog
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"io"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Entry represents a single HTTP log entry
|
||||
type Entry struct {
|
||||
Timestamp time.Time `json:"timestamp"`
|
||||
ForwardID string `json:"forward_id"`
|
||||
RequestID string `json:"request_id"`
|
||||
Direction string `json:"direction"` // "request" or "response"
|
||||
Method string `json:"method,omitempty"`
|
||||
Path string `json:"path,omitempty"`
|
||||
StatusCode int `json:"status_code,omitempty"`
|
||||
Headers map[string]string `json:"headers,omitempty"`
|
||||
BodySize int `json:"body_size"`
|
||||
Body string `json:"body,omitempty"`
|
||||
LatencyMs int64 `json:"latency_ms,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
// LogCallback is a function that receives log entries
|
||||
type LogCallback func(entry Entry)
|
||||
|
||||
// Logger writes HTTP log entries to an output stream
|
||||
type Logger struct {
|
||||
mu sync.Mutex
|
||||
output io.Writer
|
||||
file *os.File // Only set if we opened the file ourselves
|
||||
forwardID string
|
||||
maxBodyLen int
|
||||
callbacks []LogCallback
|
||||
}
|
||||
|
||||
// NewLogger creates a new HTTP logger
|
||||
// If logFile is empty, logs only go to registered callbacks (no file output)
|
||||
// This prevents stdout corruption when running in TUI mode
|
||||
func NewLogger(forwardID, logFile string, maxBodyLen int) (*Logger, error) {
|
||||
l := &Logger{
|
||||
forwardID: forwardID,
|
||||
maxBodyLen: maxBodyLen,
|
||||
}
|
||||
|
||||
if logFile == "" {
|
||||
// Don't write to stdout - use io.Discard
|
||||
// Log entries are delivered via callbacks to the UI
|
||||
l.output = io.Discard
|
||||
} else {
|
||||
f, err := os.OpenFile(logFile, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l.file = f
|
||||
l.output = f
|
||||
}
|
||||
|
||||
return l, nil
|
||||
}
|
||||
|
||||
// AddCallback registers a callback to receive log entries
|
||||
func (l *Logger) AddCallback(cb LogCallback) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.callbacks = append(l.callbacks, cb)
|
||||
}
|
||||
|
||||
// ClearCallbacks removes all registered callbacks
|
||||
func (l *Logger) ClearCallbacks() {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.callbacks = nil
|
||||
}
|
||||
|
||||
// Log writes a log entry as JSON
|
||||
func (l *Logger) Log(entry Entry) error {
|
||||
entry.ForwardID = l.forwardID
|
||||
entry.Timestamp = time.Now()
|
||||
|
||||
// Truncate body if too large
|
||||
if len(entry.Body) > l.maxBodyLen {
|
||||
entry.Body = entry.Body[:l.maxBodyLen] + "...(truncated)"
|
||||
}
|
||||
|
||||
data, err := json.Marshal(entry)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
|
||||
// Notify callbacks
|
||||
for _, cb := range l.callbacks {
|
||||
cb(entry)
|
||||
}
|
||||
|
||||
_, err = l.output.Write(append(data, '\n'))
|
||||
return err
|
||||
}
|
||||
|
||||
// Close closes the logger
|
||||
func (l *Logger) Close() error {
|
||||
if l.file != nil {
|
||||
return l.file.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,262 @@
|
||||
package httplog
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httputil"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/nvm/kportal/internal/config"
|
||||
)
|
||||
|
||||
// Proxy is an HTTP reverse proxy with logging capabilities
|
||||
type Proxy struct {
|
||||
localPort int // Port to listen on (user-facing)
|
||||
targetPort int // Port to forward to (k8s tunnel)
|
||||
logger *Logger
|
||||
server *http.Server
|
||||
forwardID string
|
||||
filterPath string // Glob pattern for path filtering
|
||||
includeHdrs bool
|
||||
listener net.Listener
|
||||
requestCount uint64
|
||||
mu sync.Mutex
|
||||
running bool
|
||||
}
|
||||
|
||||
// NewProxy creates a new HTTP logging proxy
|
||||
func NewProxy(fwd *config.Forward, targetPort int) (*Proxy, error) {
|
||||
httpCfg := fwd.HTTPLog
|
||||
if httpCfg == nil {
|
||||
return nil, fmt.Errorf("HTTP log config is nil")
|
||||
}
|
||||
|
||||
logger, err := NewLogger(fwd.ID(), httpCfg.LogFile, fwd.GetHTTPLogMaxBodySize())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create logger: %w", err)
|
||||
}
|
||||
|
||||
return &Proxy{
|
||||
localPort: fwd.LocalPort,
|
||||
targetPort: targetPort,
|
||||
logger: logger,
|
||||
forwardID: fwd.ID(),
|
||||
filterPath: httpCfg.FilterPath,
|
||||
includeHdrs: httpCfg.IncludeHeaders,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Start starts the HTTP proxy server
|
||||
func (p *Proxy) Start() error {
|
||||
p.mu.Lock()
|
||||
if p.running {
|
||||
p.mu.Unlock()
|
||||
return fmt.Errorf("proxy already running")
|
||||
}
|
||||
|
||||
// Create listener
|
||||
ln, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", p.localPort))
|
||||
if err != nil {
|
||||
p.mu.Unlock()
|
||||
return fmt.Errorf("failed to listen on port %d: %w", p.localPort, err)
|
||||
}
|
||||
p.listener = ln
|
||||
|
||||
// Create reverse proxy
|
||||
director := func(req *http.Request) {
|
||||
req.URL.Scheme = "http"
|
||||
req.URL.Host = fmt.Sprintf("127.0.0.1:%d", p.targetPort)
|
||||
}
|
||||
|
||||
proxy := &httputil.ReverseProxy{
|
||||
Director: director,
|
||||
Transport: &loggingTransport{
|
||||
proxy: p,
|
||||
transport: http.DefaultTransport,
|
||||
},
|
||||
ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
|
||||
p.logError(r, err)
|
||||
w.WriteHeader(http.StatusBadGateway)
|
||||
w.Write([]byte("Proxy error: " + err.Error()))
|
||||
},
|
||||
}
|
||||
|
||||
p.server = &http.Server{
|
||||
Handler: proxy,
|
||||
}
|
||||
|
||||
p.running = true
|
||||
p.mu.Unlock()
|
||||
|
||||
// Start serving (blocking)
|
||||
go func() {
|
||||
if err := p.server.Serve(ln); err != nil && err != http.ErrServerClosed {
|
||||
// Log error but don't crash - proxy will be replaced on reconnect
|
||||
}
|
||||
}()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stop stops the HTTP proxy server
|
||||
func (p *Proxy) Stop() error {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
|
||||
if !p.running {
|
||||
return nil
|
||||
}
|
||||
|
||||
p.running = false
|
||||
|
||||
// Shutdown with timeout
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
if err := p.server.Shutdown(ctx); err != nil {
|
||||
// Force close
|
||||
p.server.Close()
|
||||
}
|
||||
|
||||
if err := p.logger.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// loggingTransport wraps http.RoundTripper to log requests and responses
|
||||
type loggingTransport struct {
|
||||
proxy *Proxy
|
||||
transport http.RoundTripper
|
||||
}
|
||||
|
||||
func (t *loggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
|
||||
// Generate request ID
|
||||
reqID := fmt.Sprintf("%d", atomic.AddUint64(&t.proxy.requestCount, 1))
|
||||
|
||||
// Check if we should log this request based on path filter
|
||||
if !t.proxy.shouldLog(req.URL.Path) {
|
||||
return t.transport.RoundTrip(req)
|
||||
}
|
||||
|
||||
startTime := time.Now()
|
||||
|
||||
// Read request body
|
||||
var reqBody []byte
|
||||
if req.Body != nil {
|
||||
reqBody, _ = io.ReadAll(req.Body)
|
||||
req.Body = io.NopCloser(bytes.NewBuffer(reqBody))
|
||||
}
|
||||
|
||||
// Log request
|
||||
reqEntry := Entry{
|
||||
RequestID: reqID,
|
||||
Direction: "request",
|
||||
Method: req.Method,
|
||||
Path: req.URL.Path,
|
||||
BodySize: len(reqBody),
|
||||
Body: string(reqBody),
|
||||
}
|
||||
|
||||
if t.proxy.includeHdrs {
|
||||
reqEntry.Headers = flattenHeaders(req.Header)
|
||||
}
|
||||
|
||||
t.proxy.logger.Log(reqEntry)
|
||||
|
||||
// Make the request
|
||||
resp, err := t.transport.RoundTrip(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Read response body
|
||||
var respBody []byte
|
||||
if resp.Body != nil {
|
||||
respBody, _ = io.ReadAll(resp.Body)
|
||||
resp.Body = io.NopCloser(bytes.NewBuffer(respBody))
|
||||
}
|
||||
|
||||
latency := time.Since(startTime)
|
||||
|
||||
// Log response
|
||||
respEntry := Entry{
|
||||
RequestID: reqID,
|
||||
Direction: "response",
|
||||
Method: req.Method,
|
||||
Path: req.URL.Path,
|
||||
StatusCode: resp.StatusCode,
|
||||
BodySize: len(respBody),
|
||||
Body: string(respBody),
|
||||
LatencyMs: latency.Milliseconds(),
|
||||
}
|
||||
|
||||
if t.proxy.includeHdrs {
|
||||
respEntry.Headers = flattenHeaders(resp.Header)
|
||||
}
|
||||
|
||||
t.proxy.logger.Log(respEntry)
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// shouldLog checks if the request path matches the filter
|
||||
func (p *Proxy) shouldLog(path string) bool {
|
||||
if p.filterPath == "" {
|
||||
return true
|
||||
}
|
||||
|
||||
matched, err := filepath.Match(p.filterPath, path)
|
||||
if err != nil {
|
||||
// Invalid pattern, log everything
|
||||
return true
|
||||
}
|
||||
|
||||
// Also try matching with ** for prefix patterns like /api/*
|
||||
if !matched && strings.HasSuffix(p.filterPath, "/*") {
|
||||
prefix := strings.TrimSuffix(p.filterPath, "/*")
|
||||
matched = strings.HasPrefix(path, prefix)
|
||||
}
|
||||
|
||||
return matched
|
||||
}
|
||||
|
||||
// logError logs an error entry
|
||||
func (p *Proxy) logError(req *http.Request, err error) {
|
||||
entry := Entry{
|
||||
RequestID: fmt.Sprintf("%d", atomic.AddUint64(&p.requestCount, 1)),
|
||||
Direction: "error",
|
||||
Method: req.Method,
|
||||
Path: req.URL.Path,
|
||||
Error: err.Error(),
|
||||
}
|
||||
p.logger.Log(entry)
|
||||
}
|
||||
|
||||
// flattenHeaders converts http.Header to map[string]string
|
||||
func flattenHeaders(h http.Header) map[string]string {
|
||||
result := make(map[string]string, len(h))
|
||||
for k, v := range h {
|
||||
result[k] = strings.Join(v, ", ")
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// GetTargetPort returns the target port for the k8s tunnel
|
||||
func (p *Proxy) GetTargetPort() int {
|
||||
return p.targetPort
|
||||
}
|
||||
|
||||
// GetLogger returns the HTTP logger for subscribing to log entries
|
||||
func (p *Proxy) GetLogger() *Logger {
|
||||
return p.logger
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
package httplog
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/nvm/kportal/internal/config"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestLogger(t *testing.T) {
|
||||
// Create a buffer to capture output
|
||||
var buf bytes.Buffer
|
||||
|
||||
l := &Logger{
|
||||
forwardID: "test-forward",
|
||||
maxBodyLen: 100,
|
||||
output: &buf,
|
||||
}
|
||||
|
||||
// Log an entry
|
||||
err := l.Log(Entry{
|
||||
Direction: "request",
|
||||
Method: "GET",
|
||||
Path: "/test",
|
||||
BodySize: 0,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
// Parse the output
|
||||
var entry Entry
|
||||
err = json.Unmarshal(buf.Bytes(), &entry)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, "test-forward", entry.ForwardID)
|
||||
assert.Equal(t, "request", entry.Direction)
|
||||
assert.Equal(t, "GET", entry.Method)
|
||||
assert.Equal(t, "/test", entry.Path)
|
||||
assert.False(t, entry.Timestamp.IsZero())
|
||||
}
|
||||
|
||||
func TestLoggerBodyTruncation(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
|
||||
l := &Logger{
|
||||
forwardID: "test-forward",
|
||||
maxBodyLen: 10,
|
||||
output: &buf,
|
||||
}
|
||||
|
||||
// Log an entry with a long body
|
||||
err := l.Log(Entry{
|
||||
Direction: "request",
|
||||
Method: "POST",
|
||||
Path: "/test",
|
||||
Body: "this is a very long body that should be truncated",
|
||||
BodySize: 50,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
// Parse the output
|
||||
var entry Entry
|
||||
err = json.Unmarshal(buf.Bytes(), &entry)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, "this is a ...(truncated)", entry.Body)
|
||||
}
|
||||
|
||||
func TestProxyShouldLog(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
filterPath string
|
||||
path string
|
||||
expected bool
|
||||
}{
|
||||
{"no filter", "", "/anything", true},
|
||||
{"exact match", "/api", "/api", true},
|
||||
{"no match", "/api", "/other", false},
|
||||
{"prefix match", "/api/*", "/api/users", true},
|
||||
{"prefix no match", "/api/*", "/other/users", false},
|
||||
{"wildcard", "/api/*/test", "/api/v1/test", true},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
p := &Proxy{filterPath: tt.filterPath}
|
||||
assert.Equal(t, tt.expected, p.shouldLog(tt.path))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestProxyIntegration(t *testing.T) {
|
||||
// Create a buffer for log output
|
||||
var logBuf bytes.Buffer
|
||||
|
||||
// Create config
|
||||
fwd := &config.Forward{
|
||||
LocalPort: 0, // Will be assigned dynamically
|
||||
HTTPLog: &config.HTTPLogSpec{
|
||||
Enabled: true,
|
||||
IncludeHeaders: true,
|
||||
MaxBodySize: 1024,
|
||||
},
|
||||
}
|
||||
|
||||
// Create logger with buffer
|
||||
logger := &Logger{
|
||||
forwardID: "test",
|
||||
maxBodyLen: 1024,
|
||||
output: &logBuf,
|
||||
}
|
||||
|
||||
// Create proxy manually for testing
|
||||
proxy := &Proxy{
|
||||
localPort: 0, // Will use ephemeral port
|
||||
targetPort: 0, // Not used in this test
|
||||
logger: logger,
|
||||
forwardID: fwd.ID(),
|
||||
filterPath: "",
|
||||
includeHdrs: true,
|
||||
}
|
||||
|
||||
// Test shouldLog
|
||||
assert.True(t, proxy.shouldLog("/any/path"))
|
||||
|
||||
// Test logging through logger directly
|
||||
err := logger.Log(Entry{
|
||||
RequestID: "1",
|
||||
Direction: "request",
|
||||
Method: "GET",
|
||||
Path: "/test",
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify log output
|
||||
assert.Contains(t, logBuf.String(), `"direction":"request"`)
|
||||
assert.Contains(t, logBuf.String(), `"method":"GET"`)
|
||||
}
|
||||
|
||||
func TestFlattenHeaders(t *testing.T) {
|
||||
h := http.Header{
|
||||
"Content-Type": []string{"application/json"},
|
||||
"Accept": []string{"text/html", "application/json"},
|
||||
}
|
||||
|
||||
result := flattenHeaders(h)
|
||||
|
||||
assert.Equal(t, "application/json", result["Content-Type"])
|
||||
assert.Equal(t, "text/html, application/json", result["Accept"])
|
||||
}
|
||||
|
||||
func TestNewLogger(t *testing.T) {
|
||||
// Test stdout logger
|
||||
l, err := NewLogger("test-forward", "", 1024)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, l)
|
||||
assert.Nil(t, l.file) // No file when using stdout
|
||||
l.Close()
|
||||
|
||||
// Test file logger (using temp file)
|
||||
tmpFile := t.TempDir() + "/test.log"
|
||||
l, err = NewLogger("test-forward", tmpFile, 1024)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, l)
|
||||
assert.NotNil(t, l.file)
|
||||
|
||||
// Write something
|
||||
err = l.Log(Entry{Direction: "request", Method: "GET"})
|
||||
require.NoError(t, err)
|
||||
|
||||
l.Close()
|
||||
|
||||
// Verify file has content
|
||||
data, err := os.ReadFile(tmpFile)
|
||||
require.NoError(t, err)
|
||||
assert.Contains(t, string(data), `"direction":"request"`)
|
||||
}
|
||||
Reference in New Issue
Block a user