chore: logging improvements

Author: moshloop

.gitignore

@@ -1,3 +1,5 @@
+bin
+y
 # Binaries for programs and plugins
 *.exe
 *.exe~

http/client.go

@@ -459,15 +459,16 @@ func (c *Client) TraceToStdout(config TraceConfig) *Client {
 }
 
 // WithHttpLogging enables HTTP request/response logging based on the provided log levels.
-// 
+//
 // Parameters:
 //   - headerLevel: The minimum log level required to log HTTP headers (e.g., logger.Debug)
 //   - bodyLevel: The minimum log level required to log request/response bodies (e.g., logger.Trace)
 //
 // Example:
-//   client.WithHttpLogging(logger.Debug, logger.Trace)
-//   
-// This will log headers when debug logging is enabled (-v or -v 1) and 
+//
+//	client.WithHttpLogging(logger.Debug, logger.Trace)
+//
+// This will log headers when debug logging is enabled (-v or -v 1) and
 // bodies when trace logging is enabled (-vv or -v 2 or higher).
 //
 // Note: When using with cobra commands, ensure UseCobraFlags is called

http/response.go

@@ -101,6 +101,29 @@ func (h *Response) HeaderMap() map[string]string {
 	return headers
 }
 
+func (h *Response) AsMap() (map[string]any, error) {
+
+	m := make(map[string]any)
+
+	m["headers"] = map[string]any{}
+	for k, v := range logger.StripSecretsFromMap(h.HeaderMap()) {
+		m["headers"].(map[string]any)[k] = v
+	}
+
+	if h.Request != nil && h.Request.url != nil {
+		m["url"] = h.Request.url.String()
+	}
+	m["status"] = h.StatusCode
+
+	if h.IsJSON() {
+		m["body"], _ = h.AsJSON()
+	} else {
+		m["body"], _ = h.AsString()
+	}
+
+	return m, nil
+}
+
 func (h *Response) Debug() string {
 	// mimic the response, + add content-type and size
 	var sb strings.Builder

logger/buffered.go

@@ -288,42 +288,7 @@ func (b *BufferedLogger) GetLevel() LogLevel {
 func (b *BufferedLogger) SetLogLevel(level any) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
-	oldLevel := b.logLevel
-
-	switch v := level.(type) {
-	case LogLevel:
-		b.logLevel = v
-	case int:
-		b.logLevel = LogLevel(v)
-	case string:
-		// Parse string level
-		switch v {
-		case "trace":
-			b.logLevel = Trace
-		case "debug":
-			b.logLevel = Debug
-		case "info":
-			b.logLevel = Info
-		case "warn":
-			b.logLevel = Warn
-		case "error":
-			b.logLevel = Error
-		case "fatal":
-			b.logLevel = Fatal
-		default:
-			b.logLevel = Info
-		}
-	default:
-		b.logLevel = Info
-	}
-
-	// Auto-scale retention if log level changed
-	if oldLevel != b.logLevel {
-		b.mu.Unlock() // Unlock temporarily for ScaleRetentionByLogLevel
-		b.ScaleRetentionByLogLevel()
-		b.mu.Lock() // Re-lock for defer
-	}
+	b.logLevel = ParseLevel(b, level)
 }
 
 // SetMinLogLevel sets the minimum log level (same as SetLogLevel for BufferedLogger)

logger/default.go

@@ -2,6 +2,7 @@ package logger
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"regexp"
 	"strings"
@@ -231,6 +232,17 @@ func SetLogger(logger Logger) {
 	currentLogger = logger
 }
 
+// Use configures the logger to write to the specified writer.
+// This replaces the current logger with one that outputs to the given writer.
+// Useful for integrating with test frameworks like Ginkgo.
+//
+// Example:
+//
+//	logger.Use(GinkgoWriter) // Route logger output to Ginkgo's test writer
+func Use(writer io.Writer) {
+	currentLogger = NewWithWriter(writer)
+}
+
 // StandardLogger returns the current global logger instance.
 // This is equivalent to GetLogger().
 func StandardLogger() Logger {

logger/http.go

@@ -16,7 +16,7 @@ var SensitiveHeaders = []string{
 
 // NewHttpLogger creates an HTTP logger that logs at predefined levels.
 // Deprecated: Use NewHttpLoggerWithLevels for more control over logging levels.
-// 
+//
 // Default behavior:
 //   - Headers and timing: Requires log level 5 (Trace3)
 //   - Request body: Requires log level 6 (Trace4)
@@ -51,8 +51,9 @@ func NewHttpLogger(logger Logger, rt http.RoundTripper) http.RoundTripper {
 //   - bodyLevel: Minimum log level required to log request/response bodies
 //
 // Example:
-//   // Log headers at debug level (-v) and bodies at trace level (-vv)
-//   transport := NewHttpLoggerWithLevels(logger, http.DefaultTransport, logger.Debug, logger.Trace)
+//
+//	// Log headers at debug level (-v) and bodies at trace level (-vv)
+//	transport := NewHttpLoggerWithLevels(logger, http.DefaultTransport, logger.Debug, logger.Trace)
 func NewHttpLoggerWithLevels(logger Logger, rt http.RoundTripper, headerLevel, bodyLevel LogLevel) http.RoundTripper {
 	if !logger.IsLevelEnabled(headerLevel) {
 		return rt

logger/slog.go

@@ -3,6 +3,7 @@ package logger
 import (
 	"context"
 	"fmt"
+	"io"
 	"log/slog"
 	"net/http"
 	"os"
@@ -135,6 +136,48 @@ func New(prefix string) *SlogLogger {
 	// logger.V(4).Infof("new logger created name=%v flags=%s level=%s", prefix, flags.level, FromSlogLevel(lvl.Level()).String())
 	return logger
 }
+
+// NewWithWriter creates a new SlogLogger that writes to the specified writer.
+// This is useful for integrating with test frameworks or custom output destinations.
+func NewWithWriter(writer io.Writer) *SlogLogger {
+	var logger *SlogLogger
+	var lvl = &slog.LevelVar{}
+
+	reportCaller := properties.On(flags.reportCaller, "log.caller")
+	logJson := properties.On(flags.jsonLogs, "log.json")
+	logColor := properties.On(flags.color, "log.color")
+
+	var rootLevel string
+	if flags.level != "" {
+		rootLevel = flags.level
+	} else {
+		rootLevel = properties.String("info", "log.level")
+	}
+
+	if logJson {
+		logger = &SlogLogger{
+			Level: lvl,
+			Logger: slog.New(slog.NewJSONHandler(writer, &slog.HandlerOptions{
+				AddSource: reportCaller,
+				Level:     lvl,
+			})),
+		}
+	} else {
+		logger = &SlogLogger{
+			Logger: slog.New(tint.NewHandler(writer, &tint.Options{
+				Level:      lvl,
+				NoColor:    !logColor,
+				AddSource:  reportCaller,
+				TimeFormat: properties.String("15:04:05.999", "log.time.format"),
+			})),
+			Level: lvl,
+		}
+	}
+
+	logger.SetLogLevel(rootLevel)
+	return logger
+}
+
 func UseSlog() {
 	if currentLogger != nil {
 		return