Remove external log adapters
This commit is contained in:
Jack Christensen
@@ -1,39 +0,0 @@
|
||||
package kitlogadapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/go-kit/log"
|
||||
kitlevel "github.com/go-kit/log/level"
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
type Logger struct {
|
||||
l log.Logger
|
||||
}
|
||||
|
||||
func NewLogger(l log.Logger) *Logger {
|
||||
return &Logger{l: l}
|
||||
}
|
||||
|
||||
func (l *Logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
|
||||
logger := l.l
|
||||
for k, v := range data {
|
||||
logger = log.With(logger, k, v)
|
||||
}
|
||||
|
||||
switch level {
|
||||
case pgx.LogLevelTrace:
|
||||
logger.Log("PGX_LOG_LEVEL", level, "msg", msg)
|
||||
case pgx.LogLevelDebug:
|
||||
kitlevel.Debug(logger).Log("msg", msg)
|
||||
case pgx.LogLevelInfo:
|
||||
kitlevel.Info(logger).Log("msg", msg)
|
||||
case pgx.LogLevelWarn:
|
||||
kitlevel.Warn(logger).Log("msg", msg)
|
||||
case pgx.LogLevelError:
|
||||
kitlevel.Error(logger).Log("msg", msg)
|
||||
default:
|
||||
logger.Log("INVALID_PGX_LOG_LEVEL", level, "error", msg)
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
// Package log15adapter provides a logger that writes to a github.com/inconshreveable/log15.Logger
|
||||
// log.
|
||||
package log15adapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
// Log15Logger interface defines the subset of
|
||||
// github.com/inconshreveable/log15.Logger that this adapter uses.
|
||||
type Log15Logger interface {
|
||||
Debug(msg string, ctx ...interface{})
|
||||
Info(msg string, ctx ...interface{})
|
||||
Warn(msg string, ctx ...interface{})
|
||||
Error(msg string, ctx ...interface{})
|
||||
Crit(msg string, ctx ...interface{})
|
||||
}
|
||||
|
||||
type Logger struct {
|
||||
l Log15Logger
|
||||
}
|
||||
|
||||
func NewLogger(l Log15Logger) *Logger {
|
||||
return &Logger{l: l}
|
||||
}
|
||||
|
||||
func (l *Logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
|
||||
logArgs := make([]interface{}, 0, len(data))
|
||||
for k, v := range data {
|
||||
logArgs = append(logArgs, k, v)
|
||||
}
|
||||
|
||||
switch level {
|
||||
case pgx.LogLevelTrace:
|
||||
l.l.Debug(msg, append(logArgs, "PGX_LOG_LEVEL", level)...)
|
||||
case pgx.LogLevelDebug:
|
||||
l.l.Debug(msg, logArgs...)
|
||||
case pgx.LogLevelInfo:
|
||||
l.l.Info(msg, logArgs...)
|
||||
case pgx.LogLevelWarn:
|
||||
l.l.Warn(msg, logArgs...)
|
||||
case pgx.LogLevelError:
|
||||
l.l.Error(msg, logArgs...)
|
||||
default:
|
||||
l.l.Error(msg, append(logArgs, "INVALID_PGX_LOG_LEVEL", level)...)
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
// Package logrusadapter provides a logger that writes to a github.com/sirupsen/logrus.Logger
|
||||
// log.
|
||||
package logrusadapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type Logger struct {
|
||||
l logrus.FieldLogger
|
||||
}
|
||||
|
||||
func NewLogger(l logrus.FieldLogger) *Logger {
|
||||
return &Logger{l: l}
|
||||
}
|
||||
|
||||
func (l *Logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
|
||||
var logger logrus.FieldLogger
|
||||
if data != nil {
|
||||
logger = l.l.WithFields(data)
|
||||
} else {
|
||||
logger = l.l
|
||||
}
|
||||
|
||||
switch level {
|
||||
case pgx.LogLevelTrace:
|
||||
logger.WithField("PGX_LOG_LEVEL", level).Debug(msg)
|
||||
case pgx.LogLevelDebug:
|
||||
logger.Debug(msg)
|
||||
case pgx.LogLevelInfo:
|
||||
logger.Info(msg)
|
||||
case pgx.LogLevelWarn:
|
||||
logger.Warn(msg)
|
||||
case pgx.LogLevelError:
|
||||
logger.Error(msg)
|
||||
default:
|
||||
logger.WithField("INVALID_PGX_LOG_LEVEL", level).Error(msg)
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
// Package zapadapter provides a logger that writes to a go.uber.org/zap.Logger.
|
||||
package zapadapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"go.uber.org/zap"
|
||||
"go.uber.org/zap/zapcore"
|
||||
)
|
||||
|
||||
type Logger struct {
|
||||
logger *zap.Logger
|
||||
}
|
||||
|
||||
func NewLogger(logger *zap.Logger) *Logger {
|
||||
return &Logger{logger: logger.WithOptions(zap.AddCallerSkip(1))}
|
||||
}
|
||||
|
||||
func (pl *Logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
|
||||
fields := make([]zapcore.Field, len(data))
|
||||
i := 0
|
||||
for k, v := range data {
|
||||
fields[i] = zap.Any(k, v)
|
||||
i++
|
||||
}
|
||||
|
||||
switch level {
|
||||
case pgx.LogLevelTrace:
|
||||
pl.logger.Debug(msg, append(fields, zap.Stringer("PGX_LOG_LEVEL", level))...)
|
||||
case pgx.LogLevelDebug:
|
||||
pl.logger.Debug(msg, fields...)
|
||||
case pgx.LogLevelInfo:
|
||||
pl.logger.Info(msg, fields...)
|
||||
case pgx.LogLevelWarn:
|
||||
pl.logger.Warn(msg, fields...)
|
||||
case pgx.LogLevelError:
|
||||
pl.logger.Error(msg, fields...)
|
||||
default:
|
||||
pl.logger.Error(msg, append(fields, zap.Stringer("PGX_LOG_LEVEL", level))...)
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
// Package zerologadapter provides a logger that writes to a github.com/rs/zerolog.
|
||||
package zerologadapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"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)
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
package zerologadapter_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/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)
|
||||
}
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user