Support custom logger for plugins

lib/logging/leveled.go

@@ -0,0 +1,65 @@
+package logging
+
+import (
+	"strings"
+
+	log "github.com/go-pkgz/lgr"
+)
+
+// LeveledLogger contains log methods for all log levels of github.com/go-pkgz/lgr
+type LeveledLogger interface {
+	Tracef(format string, args ...interface{})
+	Debugf(format string, args ...interface{})
+	Infof(format string, args ...interface{})
+	Warnf(format string, args ...interface{})
+	Errorf(format string, args ...interface{})
+	Panicf(format string, args ...interface{})
+	Fatalf(format string, args ...interface{})
+}
+
+// LeveledLoggerAdapter implements logger interface and maps every Logf call
+// to a corresponding log method. Level prefixes are trimmed before the call.
+// If level is not detected, Infof method will be used.
+type LeveledLoggerAdapter struct {
+	logFns map[string]func(string, ...interface{})
+}
+
+var _ log.L = (*LeveledLoggerAdapter)(nil)
+
+// NewLeveledLoggerAdapter returns a new instance of LeveledLoggerAdapter
+func NewLeveledLoggerAdapter(leveled LeveledLogger) *LeveledLoggerAdapter {
+	return &LeveledLoggerAdapter{
+		logFns: map[string]func(string, ...interface{}){
+			"TRACE":   leveled.Tracef,
+			"[TRACE]": leveled.Tracef,
+			"DEBUG":   leveled.Debugf,
+			"[DEBUG]": leveled.Debugf,
+			"INFO":    leveled.Infof,
+			"[INFO]":  leveled.Infof,
+			"WARN":    leveled.Warnf,
+			"[WARN]":  leveled.Warnf,
+			"ERROR":   leveled.Errorf,
+			"[ERROR]": leveled.Errorf,
+			"PANIC":   leveled.Panicf,
+			"[PANIC]": leveled.Panicf,
+			"FATAL":   leveled.Fatalf,
+			"[FATAL]": leveled.Fatalf,
+		},
+	}
+}
+
+// Logf detects a log level and calls a corresponding log method
+func (l LeveledLoggerAdapter) Logf(format string, args ...interface{}) {
+	// Use INFO level by default
+	logFn := l.logFns["INFO"]
+	for level, fn := range l.logFns {
+		if strings.HasPrefix(format, level) {
+			logFn = fn
+			format = format[len(level):]
+			format = strings.TrimSpace(format)
+			break
+		}
+	}
+
+	logFn(format, args...)
+}

lib/logging/leveled_test.go

@@ -0,0 +1,70 @@
+package logging
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLeveledLoggerAdapter(t *testing.T) {
+	mock := &leveledLoggerMock{}
+
+	log := NewLeveledLoggerAdapter(mock)
+
+	t.Run("all levels", func(t *testing.T) {
+		const msg = "some msg"
+
+		for _, level := range []string{"TRACE", "DEBUG", "INFO", "ERROR", "PANIC", "FATAL"} {
+			for _, addBraces := range []bool{false, true} {
+				format := level
+				if addBraces {
+					format = "[" + level + "]"
+				}
+				format += " " + msg
+				log.Logf(format)
+
+				assert.Equal(t, level, mock.lastLevel)
+				assert.Equal(t, msg, mock.lastFormat)
+				assert.Empty(t, mock.lastArgs)
+			}
+		}
+	})
+
+	t.Run("logf with args", func(t *testing.T) {
+		args := []interface{}{1, "hello world"}
+
+		log.Logf("TRACE      start #%d - %s", args...)
+
+		assert.Equal(t, "TRACE", mock.lastLevel)
+		assert.Equal(t, "start #%d - %s", mock.lastFormat)
+		assert.Equal(t, args, mock.lastArgs)
+	})
+
+	t.Run("no level", func(t *testing.T) {
+		const msg = "msg without level"
+		log.Logf(msg)
+
+		assert.Equal(t, "INFO", mock.lastLevel)
+		assert.Equal(t, msg, mock.lastFormat)
+	})
+}
+
+type leveledLoggerMock struct {
+	lastLevel  string
+	lastFormat string
+	lastArgs   []interface{}
+}
+
+func (l *leveledLoggerMock) Tracef(f string, args ...interface{}) { l.saveCall("TRACE", f, args) }
+func (l *leveledLoggerMock) Debugf(f string, args ...interface{}) { l.saveCall("DEBUG", f, args) }
+func (l *leveledLoggerMock) Infof(f string, args ...interface{})  { l.saveCall("INFO", f, args) }
+func (l *leveledLoggerMock) Warnf(f string, args ...interface{})  { l.saveCall("WARN", f, args) }
+func (l *leveledLoggerMock) Errorf(f string, args ...interface{}) { l.saveCall("ERROR", f, args) }
+func (l *leveledLoggerMock) Panicf(f string, args ...interface{}) { l.saveCall("PANIC", f, args) }
+func (l *leveledLoggerMock) Fatalf(f string, args ...interface{}) { l.saveCall("FATAL", f, args) }
+
+func (l *leveledLoggerMock) saveCall(level, format string, args []interface{}) {
+	l.lastLevel = level
+	l.lastFormat = format
+	l.lastArgs = args
+}

lib/plugin.go

@@ -19,6 +19,10 @@ type Plugin struct {
 	Name    string   `json:"name"`
 	Address string   `json:"address"`
 	Methods []string `json:"methods"`
+
+	// Log can be used to set a custom logger. By default, all logs are sent directly
+	// to std logger. More logger implementations can be found in package lib/logging.
+	Log log.L `json:"-"`
 }
 
 // Do register the plugin, send info to reproxy conductor and activate RPC listener.
@@ -27,14 +31,17 @@ type Plugin struct {
 // func(req lib.Request, res *lib.Response) (err error)
 // see [examples/plugin]() for more info
 func (p *Plugin) Do(ctx context.Context, conductor string, rcvr interface{}) (err error) {
+	if p.Log == nil {
+		p.Log = log.Std
+	}
 
 	ctxCancel, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	if err = rpc.RegisterName(p.Name, rcvr); err != nil {
-		return fmt.Errorf("can't register plugin %s: %v", p.Name, err)
+		return fmt.Errorf("can't register plugin %s: %w", p.Name, err)
 	}
-	log.Printf("[INFO] register rpc %s:%s", p.Name, p.Address)
+	p.Log.Logf("[INFO] register rpc %s:%s", p.Name, p.Address)
 
 	client := http.Client{Timeout: time.Second}
 	time.AfterFunc(time.Millisecond*50, func() {
@@ -43,14 +50,14 @@ func (p *Plugin) Do(ctx context.Context, conductor string, rcvr interface{}) (er
 			return p.send(&client, conductor, "POST")
 		})
 		if err != nil {
-			log.Printf("[ERROR] can't register with reproxy for %s: %v", p.Name, err)
+			p.Log.Logf("[ERROR] can't register with reproxy for %s: %v", p.Name, err)
 			cancel()
 		}
 	})
 
 	defer func() {
 		if e := p.send(&client, conductor, "DELETE"); e != nil {
-			log.Printf("[WARN] can't unregister with reproxy for %s: %v", p.Name, err)
+			p.Log.Logf("[WARN] can't unregister with reproxy for %s: %v", p.Name, err)
 		}
 	}()
 
@@ -60,25 +67,25 @@ func (p *Plugin) Do(ctx context.Context, conductor string, rcvr interface{}) (er
 func (p *Plugin) listen(ctx context.Context) error {
 	listener, err := net.Listen("tcp", p.Address)
 	if err != nil {
-		return fmt.Errorf("can't listen on %s: %v", p.Address, err)
+		return fmt.Errorf("can't listen on %s: %w", p.Address, err)
 	}
 
 	go func() {
 		<-ctx.Done()
 		if err := listener.Close(); err != nil {
-			log.Printf("[WARN] can't lose plugin listener")
+			p.Log.Logf("[WARN] can't lose plugin listener")
 		}
 	}()
 
 	for {
-		log.Printf("[DEBUG] plugin listener for %s:%s activated", p.Name, p.Address)
+		p.Log.Logf("[DEBUG] plugin listener for %s:%s activated", p.Name, p.Address)
 		conn, err := listener.Accept()
 		if err != nil {
 			select {
 			case <-ctx.Done():
 				return ctx.Err()
 			default:
-				return fmt.Errorf("accept failed for %s: %v", p.Name, err)
+				return fmt.Errorf("accept failed for %s: %w", p.Name, err)
 			}
 		}
 		go rpc.ServeConn(conn)

lib/plugin_test.go

@@ -15,9 +15,7 @@ import (
 )
 
 func TestPlugin_Do(t *testing.T) {
-
-	var postCalls int32
-	var deleteCalls int32
+	var postCalls, deleteCalls int32
 	tsConductor := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.Method {
 		case "POST":