mirror of
https://github.com/lukaszraczylo/kportal.git
synced 2026-06-06 23:13:39 +00:00
119 lines
2.9 KiB
Go
119 lines
2.9 KiB
Go
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 {
|
|
// #nosec G304 -- logFile is from config validation, not arbitrary user input
|
|
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
|
|
}
|
|
|
|
// GetMaxBodyLen returns the maximum body length for logging
|
|
func (l *Logger) GetMaxBodyLen() int {
|
|
return l.maxBodyLen
|
|
}
|