whatcanGOwrong

go/pkg/mod/github.com/jackc/pgx/v4@v4.18.3/log/zerologadapter/adapter.go

@@ -0,0 +1,102 @@
+// Package zerologadapter provides a logger that writes to a github.com/rs/zerolog.
+package zerologadapter
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/rs/zerolog"
+)
+
+type Logger struct {
+	logger      zerolog.Logger
+	withFunc    func(context.Context, zerolog.Context) zerolog.Context
+	fromContext bool
+	skipModule  bool
+}
+
+// option options for configuring the logger when creating a new logger.
+type option func(logger *Logger)
+
+// WithContextFunc adds possibility to get request scoped values from the
+// ctx.Context before logging lines.
+func WithContextFunc(withFunc func(context.Context, zerolog.Context) zerolog.Context) option {
+	return func(logger *Logger) {
+		logger.withFunc = withFunc
+	}
+}
+
+// WithoutPGXModule disables adding module:pgx to the default logger context.
+func WithoutPGXModule() option {
+	return func(logger *Logger) {
+		logger.skipModule = true
+	}
+}
+
+// NewLogger accepts a zerolog.Logger as input and returns a new custom pgx
+// logging facade as output.
+func NewLogger(logger zerolog.Logger, options ...option) *Logger {
+	l := Logger{
+		logger: logger,
+	}
+	l.init(options)
+	return &l
+}
+
+// NewContextLogger creates logger that extracts the zerolog.Logger from the
+// context.Context by using `zerolog.Ctx`. The zerolog.DefaultContextLogger will
+// be used if no logger is associated with the context.
+func NewContextLogger(options ...option) *Logger {
+	l := Logger{
+		fromContext: true,
+	}
+	l.init(options)
+	return &l
+}
+
+func (pl *Logger) init(options []option) {
+	for _, opt := range options {
+		opt(pl)
+	}
+	if !pl.skipModule {
+		pl.logger = pl.logger.With().Str("module", "pgx").Logger()
+	}
+}
+
+func (pl *Logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
+	var zlevel zerolog.Level
+	switch level {
+	case pgx.LogLevelNone:
+		zlevel = zerolog.NoLevel
+	case pgx.LogLevelError:
+		zlevel = zerolog.ErrorLevel
+	case pgx.LogLevelWarn:
+		zlevel = zerolog.WarnLevel
+	case pgx.LogLevelInfo:
+		zlevel = zerolog.InfoLevel
+	case pgx.LogLevelDebug:
+		zlevel = zerolog.DebugLevel
+	default:
+		zlevel = zerolog.DebugLevel
+	}
+
+	var zctx zerolog.Context
+	if pl.fromContext {
+		logger := zerolog.Ctx(ctx)
+		zctx = logger.With()
+	} else {
+		zctx = pl.logger.With()
+	}
+	if pl.withFunc != nil {
+		zctx = pl.withFunc(ctx, zctx)
+	}
+
+	pgxlog := zctx.Logger()
+	event := pgxlog.WithLevel(zlevel)
+	if event.Enabled() {
+		if pl.fromContext && !pl.skipModule {
+			event.Str("module", "pgx")
+		}
+		event.Fields(data).Msg(msg)
+	}
+}

go/pkg/mod/github.com/jackc/pgx/v4@v4.18.3/log/zerologadapter/adapter_test.go

@@ -0,0 +1,98 @@
+package zerologadapter_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/pgx/v4/log/zerologadapter"
+	"github.com/rs/zerolog"
+)
+
+func TestLogger(t *testing.T) {
+
+	t.Run("default", func(t *testing.T) {
+		var buf bytes.Buffer
+		zlogger := zerolog.New(&buf)
+		logger := zerologadapter.NewLogger(zlogger)
+		logger.Log(context.Background(), pgx.LogLevelInfo, "hello", map[string]interface{}{"one": "two"})
+		const want = `{"level":"info","module":"pgx","one":"two","message":"hello"}
+`
+		got := buf.String()
+		if got != want {
+			t.Errorf("%s != %s", got, want)
+		}
+	})
+
+	t.Run("disable pgx module", func(t *testing.T) {
+		var buf bytes.Buffer
+		zlogger := zerolog.New(&buf)
+		logger := zerologadapter.NewLogger(zlogger, zerologadapter.WithoutPGXModule())
+		logger.Log(context.Background(), pgx.LogLevelInfo, "hello", nil)
+		const want = `{"level":"info","message":"hello"}
+`
+		got := buf.String()
+		if got != want {
+			t.Errorf("%s != %s", got, want)
+		}
+	})
+
+	t.Run("from context", func(t *testing.T) {
+		var buf bytes.Buffer
+		zlogger := zerolog.New(&buf)
+		ctx := zlogger.WithContext(context.Background())
+		logger := zerologadapter.NewContextLogger()
+		logger.Log(ctx, pgx.LogLevelInfo, "hello", map[string]interface{}{"one": "two"})
+		const want = `{"level":"info","module":"pgx","one":"two","message":"hello"}
+`
+
+		got := buf.String()
+		if got != want {
+			t.Log(got)
+			t.Log(want)
+			t.Errorf("%s != %s", got, want)
+		}
+	})
+
+	var buf bytes.Buffer
+	type key string
+	var ck key
+	zlogger := zerolog.New(&buf)
+	logger := zerologadapter.NewLogger(zlogger,
+		zerologadapter.WithContextFunc(func(ctx context.Context, logWith zerolog.Context) zerolog.Context {
+			// You can use zerolog.hlog.IDFromCtx(ctx) or even
+			// zerolog.log.Ctx(ctx) to fetch the whole logger instance from the
+			// context if you want.
+			id, ok := ctx.Value(ck).(string)
+			if ok {
+				logWith = logWith.Str("req_id", id)
+			}
+			return logWith
+		}),
+	)
+
+	t.Run("no request id", func(t *testing.T) {
+		buf.Reset()
+		ctx := context.Background()
+		logger.Log(ctx, pgx.LogLevelInfo, "hello", nil)
+		const want = `{"level":"info","module":"pgx","message":"hello"}
+`
+		got := buf.String()
+		if got != want {
+			t.Errorf("%s != %s", got, want)
+		}
+	})
+
+	t.Run("with request id", func(t *testing.T) {
+		buf.Reset()
+		ctx := context.WithValue(context.Background(), ck, "1")
+		logger.Log(ctx, pgx.LogLevelInfo, "hello", map[string]interface{}{"two": "2"})
+		const want = `{"level":"info","module":"pgx","req_id":"1","two":"2","message":"hello"}
+`
+		got := buf.String()
+		if got != want {
+			t.Errorf("%s != %s", got, want)
+		}
+	})
+}