🔥 feat: log.WithContext automatically includes context fields

log/default.go

@@ -14,11 +14,29 @@ import (
 var _ AllLogger[*log.Logger] = (*defaultLogger)(nil)
 
 type defaultLogger struct {
+	ctx    context.Context //nolint:containedctx // stored for deferred field extraction
 	stdlog *log.Logger
 	level  Level
 	depth  int
 }
 
+// writeContextFields appends extracted context key-value pairs to buf.
+// Each pair is written as "key=value " (trailing space included).
+func (l *defaultLogger) writeContextFields(buf *bytebufferpool.ByteBuffer) {
+	if l.ctx == nil || len(contextExtractors) == 0 {
+		return
+	}
+	for _, extractor := range contextExtractors {
+		key, value, ok := extractor(l.ctx)
+		if ok {
+			buf.WriteString(key)
+			buf.WriteByte('=')
+			buf.WriteString(utils.ToString(value))
+			buf.WriteByte(' ')
+		}
+	}
+}
+
 // privateLog logs a message at a given level log the default logger.
 // when the level is fatal, it will exit the program.
 func (l *defaultLogger) privateLog(lv Level, fmtArgs []any) {
@@ -28,6 +46,7 @@ func (l *defaultLogger) privateLog(lv Level, fmtArgs []any) {
 	level := lv.toString()
 	buf := bytebufferpool.Get()
 	buf.WriteString(level)
+	l.writeContextFields(buf)
 	fmt.Fprint(buf, fmtArgs...)
 
 	_ = l.stdlog.Output(l.depth, buf.String()) //nolint:errcheck // It is fine to ignore the error
@@ -51,6 +70,7 @@ func (l *defaultLogger) privateLogf(lv Level, format string, fmtArgs []any) {
 	level := lv.toString()
 	buf := bytebufferpool.Get()
 	buf.WriteString(level)
+	l.writeContextFields(buf)
 
 	if len(fmtArgs) > 0 {
 		_, _ = fmt.Fprintf(buf, format, fmtArgs...)
@@ -78,8 +98,7 @@ func (l *defaultLogger) privateLogw(lv Level, format string, keysAndValues []any
 	level := lv.toString()
 	buf := bytebufferpool.Get()
 	buf.WriteString(level)
-
-	// Write format privateLog buffer
+	l.writeContextFields(buf)
 	if format != "" {
 		buf.WriteString(format)
 	}
@@ -220,12 +239,15 @@ func (l *defaultLogger) Panicw(msg string, keysAndValues ...any) {
 	l.privateLogw(LevelPanic, msg, keysAndValues)
 }
 
-// WithContext returns a logger that shares the underlying output but adjusts the call depth.
-func (l *defaultLogger) WithContext(_ context.Context) CommonLogger {
+// WithContext returns a logger that shares the underlying output but carries
+// the provided context. Any registered ContextExtractor functions will be
+// called at log time to prepend key-value fields extracted from the context.
+func (l *defaultLogger) WithContext(ctx context.Context) CommonLogger {
 	return &defaultLogger{
 		stdlog: l.stdlog,
 		level:  l.level,
 		depth:  l.depth - 1,
+		ctx:    ctx,
 	}
 }
 

log/default_test.go

@@ -118,6 +118,86 @@ func Test_CtxLogger(t *testing.T) {
 		"[Panic] work panic\n", string(w.b))
 }
 
+type testContextKey struct{}
+
+func Test_WithContextExtractor(t *testing.T) {
+	// Save and restore global extractors
+	saved := contextExtractors
+	defer func() { contextExtractors = saved }()
+	contextExtractors = nil
+
+	RegisterContextExtractor(func(ctx context.Context) (string, any, bool) {
+		if v, ok := ctx.Value(testContextKey{}).(string); ok && v != "" {
+			return "request-id", v, true
+		}
+		return "", nil, false
+	})
+
+	t.Run("Info with context field", func(t *testing.T) {
+		var buf bytes.Buffer
+		l := &defaultLogger{
+			stdlog: log.New(&buf, "", 0),
+			level:  LevelTrace,
+			depth:  4,
+		}
+		ctx := context.WithValue(context.Background(), testContextKey{}, "abc-123")
+		l.WithContext(ctx).Info("hello")
+
+		require.Equal(t, "[Info] request-id=abc-123 hello\n", buf.String())
+	})
+
+	t.Run("Infof with context field", func(t *testing.T) {
+		var buf bytes.Buffer
+		l := &defaultLogger{
+			stdlog: log.New(&buf, "", 0),
+			level:  LevelTrace,
+			depth:  4,
+		}
+		ctx := context.WithValue(context.Background(), testContextKey{}, "abc-123")
+		l.WithContext(ctx).Infof("hello %s", "world")
+
+		require.Equal(t, "[Info] request-id=abc-123 hello world\n", buf.String())
+	})
+
+	t.Run("Infow with context field", func(t *testing.T) {
+		var buf bytes.Buffer
+		l := &defaultLogger{
+			stdlog: log.New(&buf, "", 0),
+			level:  LevelTrace,
+			depth:  4,
+		}
+		ctx := context.WithValue(context.Background(), testContextKey{}, "abc-123")
+		l.WithContext(ctx).Infow("hello", "key", "value")
+
+		require.Equal(t, "[Info] request-id=abc-123 hello key=value\n", buf.String())
+	})
+
+	t.Run("no context field when value absent", func(t *testing.T) {
+		var buf bytes.Buffer
+		l := &defaultLogger{
+			stdlog: log.New(&buf, "", 0),
+			level:  LevelTrace,
+			depth:  4,
+		}
+		ctx := context.Background()
+		l.WithContext(ctx).Info("hello")
+
+		require.Equal(t, "[Info] hello\n", buf.String())
+	})
+
+	t.Run("no context field without WithContext", func(t *testing.T) {
+		var buf bytes.Buffer
+		l := &defaultLogger{
+			stdlog: log.New(&buf, "", 0),
+			level:  LevelTrace,
+			depth:  4,
+		}
+		l.Info("hello")
+
+		require.Equal(t, "[Info] hello\n", buf.String())
+	})
+}
+
 func Test_LogfKeyAndValues(t *testing.T) {
 	tests := []struct {
 		name          string

log/log.go

@@ -8,6 +8,28 @@ import (
 	"os"
 )
 
+// ContextExtractor extracts a key-value pair from the given context for
+// inclusion in log output when using WithContext.
+// It returns the log field name, its value, and whether extraction succeeded.
+type ContextExtractor func(ctx context.Context) (string, any, bool)
+
+// contextExtractors holds all registered context field extractors.
+//
+// This slice is read during logging and written during registration.
+// All calls to RegisterContextExtractor must happen during program
+// initialization (e.g. in init functions or before starting goroutines),
+// before any logging occurs, to avoid data races.
+var contextExtractors []ContextExtractor
+
+// RegisterContextExtractor registers a function that extracts a key-value pair
+// from context for inclusion in log output when using WithContext.
+//
+// Note that this function is not concurrent-safe and must be called during
+// program initialization (e.g. in an init function), before any logging occurs.
+func RegisterContextExtractor(extractor ContextExtractor) {
+	contextExtractors = append(contextExtractors, extractor)
+}
+
 // baseLogger defines the minimal logger functionality required by the package.
 // It allows storing any logger implementation regardless of its generic type.
 type baseLogger interface {

middleware/requestid/requestid.go

@@ -1,7 +1,10 @@
 package requestid
 
 import (
+	"context"
+
 	"github.com/gofiber/fiber/v3"
+	"github.com/gofiber/fiber/v3/log"
 	"github.com/gofiber/utils/v2"
 )
 
@@ -14,6 +17,16 @@ const (
 	requestIDKey contextKey = iota
 )
 
+func init() {
+	// Register a context extractor so that log.WithContext(c) automatically
+	// includes the request ID when the requestid middleware is in use.
+	// An empty request ID (no middleware or middleware skipped) is omitted.
+	log.RegisterContextExtractor(func(ctx context.Context) (string, any, bool) {
+		rid := FromContext(ctx)
+		return "request-id", rid, rid != ""
+	})
+}
+
 // New creates a new middleware handler
 func New(config ...Config) fiber.Handler {
 	// Set default config

middleware/requestid/requestid_test.go

@@ -1,11 +1,14 @@
 package requestid
 
 import (
+	"bytes"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
+	fiberlog "github.com/gofiber/fiber/v3/log"
 	"github.com/stretchr/testify/require"
 )
 
@@ -233,3 +236,29 @@ func Test_RequestID_FromContext_Types(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 }
+
+func Test_RequestID_LogWithContext(t *testing.T) {
+	reqID := "test-request-id-456"
+
+	app := fiber.New()
+	app.Use(New(Config{
+		Generator: func() string {
+			return reqID
+		},
+	}))
+
+	var logOutput bytes.Buffer
+	fiberlog.SetOutput(&logOutput)
+	defer fiberlog.SetOutput(os.Stderr)
+
+	app.Get("/", func(c fiber.Ctx) error {
+		fiberlog.WithContext(c).Info("hello from handler")
+		return c.SendStatus(fiber.StatusOK)
+	})
+
+	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/", http.NoBody))
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Contains(t, logOutput.String(), "request-id="+reqID)
+	require.Contains(t, logOutput.String(), "hello from handler")
+}