Merge pull request #76 from splitio/extended-logger

Adding extended logger

Author: sarrubia

.gitignore

@@ -14,5 +14,5 @@
 .glide/
 
 *.swp
-
+.idea
 vendor/

CHANGES

@@ -1,3 +1,6 @@
+5.1.0 (Apr 7, 2022)
+ - Adding ExtendedLevelFilteredLoggerWrapper to improve performance parsing log calls parameters only if the set level applies
+
 5.0.3 (Jan 12, 2021)
  - Cleanup cache datastructure & multi-level revamp to support contexts
  - Fix HTTP-Proxy from env vars in sse client

logging/interface.go

@@ -10,3 +10,18 @@ type LoggerInterface interface {
 	Debug(msg ...interface{})
 	Verbose(msg ...interface{})
 }
+
+// ParamsFn is a function that returns a slice of interface{}
+type ParamsFn = func() []interface{}
+
+// ExtendedLoggerInterface ...
+// If a custom logger object is to be used, it should comply with the following
+// interface. (Standard go-lang library log.Logger.Println method signature)
+type ExtendedLoggerInterface interface {
+	LoggerInterface
+	ErrorFn(format string, params ParamsFn)
+	WarningFn(format string, params ParamsFn)
+	InfoFn(format string, params ParamsFn)
+	DebugFn(format string, params ParamsFn)
+	VerboseFn(format string, params ParamsFn)
+}

logging/levels.go

@@ -1,6 +1,7 @@
 package logging
 
 import (
+	"fmt"
 	"math"
 )
 
@@ -91,3 +92,48 @@ func Level(level string) int {
 	}
 	return l
 }
+
+// ExtendedLevelFilteredLoggerWrapper leveled logger improving message format performance
+type ExtendedLevelFilteredLoggerWrapper struct {
+	*LevelFilteredLoggerWrapper
+}
+
+// sprintf apply parameter function to parse the given message
+func (l *ExtendedLevelFilteredLoggerWrapper) sprintf(format string, params func() []interface{}) string {
+	return fmt.Sprintf(format, params()...)
+}
+
+// ErrorFn forwards error logging messages getting parameters from a function to improve performance
+func (l *ExtendedLevelFilteredLoggerWrapper) ErrorFn(format string, params ParamsFn) {
+	if l.level >= LevelError {
+		l.delegate.Error(l.sprintf(format, params))
+	}
+}
+
+// WarningFn forwards warning logging messages getting parameters from a function to improve performance
+func (l *ExtendedLevelFilteredLoggerWrapper) WarningFn(format string, params ParamsFn) {
+	if l.level >= LevelWarning {
+		l.delegate.Warning(l.sprintf(format, params))
+	}
+}
+
+// InfoFn forwards info logging messages getting parameters from a function to improve performance
+func (l *ExtendedLevelFilteredLoggerWrapper) InfoFn(format string, params ParamsFn) {
+	if l.level >= LevelInfo {
+		l.delegate.Info(l.sprintf(format, params))
+	}
+}
+
+// DebugFn forwards debug logging messages getting parameters from a function to improve performance
+func (l *ExtendedLevelFilteredLoggerWrapper) DebugFn(format string, params ParamsFn) {
+	if l.level >= LevelDebug {
+		l.delegate.Debug(l.sprintf(format, params))
+	}
+}
+
+// VerboseFn forwards verbose logging messages getting parameters from a function to improve performance
+func (l *ExtendedLevelFilteredLoggerWrapper) VerboseFn(format string, params ParamsFn) {
+	if l.level >= LevelVerbose {
+		l.delegate.Verbose(l.sprintf(format, params))
+	}
+}

logging/levels_test.go

@@ -255,3 +255,85 @@ func TestNoneLevel(t *testing.T) {
 		}
 	}
 }
+
+func writelog(logger *ExtendedLevelFilteredLoggerWrapper) {
+	logger.ErrorFn("hello %s", func() []interface{} { return []interface{}{"world"} })
+	logger.WarningFn("hello %s", func() []interface{} { return []interface{}{"world"} })
+	logger.InfoFn("hello %s", func() []interface{} { return []interface{}{"world"} })
+	logger.DebugFn("hello %s", func() []interface{} { return []interface{}{"world"} })
+	logger.VerboseFn("hello %s", func() []interface{} { return []interface{}{"world"} })
+}
+
+func assertWrites(t *testing.T, currentLevel string, delegate *mockedLogger, shouldBeCalled []string, shouldNotBeCalled []string) {
+	for _, level := range shouldBeCalled {
+		if !delegate.msgs[level] {
+			t.Errorf("Call to log level function \"%s\" should have been forwarded, current level=%s", level, currentLevel)
+		}
+	}
+
+	for _, level := range shouldNotBeCalled {
+		if delegate.msgs[level] {
+			t.Errorf("Call to log level function \"%s\" should NOT have been forwarded, current level=%s", level, currentLevel)
+		}
+	}
+}
+
+func TestExtendedLevelFilteredLogger(t *testing.T) {
+
+	delegate := &mockedLogger{}
+	delegate.reset()
+
+	logger := &ExtendedLevelFilteredLoggerWrapper{&LevelFilteredLoggerWrapper{
+		delegate: delegate,
+		level:    LevelError,
+	}}
+
+	t.Run("Error", func(t *testing.T) {
+		logger.level = LevelError
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "ERROR", delegate, []string{"Error"}, []string{"Warning", "Info", "Debug", "Verbose"})
+	})
+
+	t.Run("Waring", func(t *testing.T) {
+		logger.level = LevelWarning
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "WARNING", delegate, []string{"Error", "Warning"}, []string{"Info", "Debug", "Verbose"})
+	})
+
+	t.Run("Info", func(t *testing.T) {
+		logger.level = LevelInfo
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "INFO", delegate, []string{"Error", "Warning", "Info"}, []string{"Debug", "Verbose"})
+	})
+
+	t.Run("Debug", func(t *testing.T) {
+		logger.level = LevelDebug
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "DEBUG", delegate, []string{"Error", "Warning", "Info", "Debug"}, []string{"Verbose"})
+	})
+
+	t.Run("Verbose", func(t *testing.T) {
+		logger.level = LevelVerbose
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "VERBOSE", delegate, []string{"Error", "Warning", "Info", "Debug", "Verbose"}, []string{})
+	})
+
+	t.Run("All", func(t *testing.T) {
+		logger.level = LevelAll
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "ALL", delegate, []string{"Error", "Warning", "Info", "Debug", "Verbose"}, []string{})
+	})
+
+	t.Run("None", func(t *testing.T) {
+		logger.level = LevelNone
+		delegate.reset()
+		writelog(logger)
+		assertWrites(t, "NONE", delegate, []string{}, []string{"Error", "Warning", "Info", "Debug", "Verbose"})
+	})
+}

logging/logging.go

@@ -105,25 +105,46 @@ func normalizeOptions(options *LoggerOptions) *LoggerOptions {
 	return toRet
 }
 
-// NewLogger instantiates a new Logger instance. Requires a pointer to a LoggerOptions struct to be passed.
-func NewLogger(options *LoggerOptions) LoggerInterface {
-
-	options = normalizeOptions(options)
+// newLogger constructor of Logger instance.
+//  Returns: a pointer to *Logger
+//  Assumes: that options are alredy normalized
+func newLogger(options *LoggerOptions) *Logger {
 	prefix := ""
 	if options.Prefix != "" {
 		prefix = fmt.Sprintf("%s - ", options.Prefix)
 	}
-	logger := &Logger{
+	return &Logger{
 		debugLogger:   *log.New(options.DebugWriter, fmt.Sprintf("%sDEBUG - ", prefix), options.StandardLoggerFlags),
 		infoLogger:    *log.New(options.InfoWriter, fmt.Sprintf("%sINFO - ", prefix), options.StandardLoggerFlags),
 		warningLogger: *log.New(options.WarningWriter, fmt.Sprintf("%sWARNING - ", prefix), options.StandardLoggerFlags),
 		errorLogger:   *log.New(options.ErrorWriter, fmt.Sprintf("%sERROR - ", prefix), options.StandardLoggerFlags),
 		verboseLogger: *log.New(options.VerboseWriter, fmt.Sprintf("%sVERBOSE - ", prefix), options.StandardLoggerFlags),
 		framesToSkip:  3 + options.ExtraFramesToSkip,
 	}
+}
+
+// NewLogger instantiates a new Logger instance. Requires a pointer to a LoggerOptions struct to be passed.
+func NewLogger(options *LoggerOptions) LoggerInterface {
+
+	options = normalizeOptions(options)
+
+	logger := newLogger(options)
 
 	return &LevelFilteredLoggerWrapper{
 		delegate: logger,
 		level:    options.LogLevel,
 	}
 }
+
+// NewExtendedLogger instantiates a new Logger instance. Requires a pointer to a LoggerOptions struct to be passed.
+func NewExtendedLogger(options *LoggerOptions) ExtendedLoggerInterface {
+
+	options = normalizeOptions(options)
+
+	logger := newLogger(options)
+
+	return &ExtendedLevelFilteredLoggerWrapper{&LevelFilteredLoggerWrapper{
+		delegate: logger,
+		level:    options.LogLevel,
+	}}
+}