Add support random sample logger and update README doc

Author: mstmdev

README.md

@@ -20,15 +20,41 @@ Current support following loggers
 - console logger
 - file logger
 - multi logger
+- sample logger
 
 For example, init a file logger, to write logs.
 
 ```go
-log.InitDefaultLogger(log.NewFileLogger(log.DebugLevel, "./logs", ""))
-log.Debug("%s, test debug log", "hello")
-log.Info("%s, test info log", "hello")
-log.Warn("%s, test warn log", "hello")
-log.Error(errors.New("log err"), "%s, test error log", "hello")
-log.ErrorIf(errors.New("log err"), "%s, test error log", "hello")
-log.Log("%s, test log log", "hello")
+package main
+
+import (
+	"errors"
+
+	"github.com/no-src/log"
+)
+
+func main() {
+	// init default logger
+	if logger, err := log.NewFileLogger(log.DebugLevel, "./logs", ""); err == nil {
+		log.InitDefaultLoggerWithSample(logger, 0.6)
+	} else {
+		log.Error(err, "init file logger error")
+	}
+	defer log.Close()
+
+	// use default logger
+	log.Debug("%s, test debug log", "hello")
+	log.Info("%s, test info log", "hello")
+	log.Warn("%s, test warn log", "hello")
+	log.Error(errors.New("log err"), "%s, test error log", "hello")
+	log.ErrorIf(errors.New("log err"), "%s, test error log", "hello")
+	log.Log("%s, test log log", "hello")
+
+	// use default logger by random sampling
+	log.DebugSample("[sample] %s, test debug log", "hello")
+	log.InfoSample("[sample] %s, test info log", "hello")
+	log.WarnSample("[sample] %s, test warn log", "hello")
+	log.ErrorSample(errors.New("log err"), "[sample] %s,test error log", "hello")
+	log.ErrorIfSample(errors.New("log err from ErrorIfSample"), "[sample] %s, test error log", "hello")
+}
 ```

default_logger.go

@@ -1,14 +1,26 @@
 package log
 
-var defaultLogger Logger
+var (
+	defaultLogger       Logger
+	defaultSampleLogger Logger
+)
+
+const defaultSampleRate = 1
 
 // InitDefaultLogger init a default logger
-// if InitDefaultLogger is not called, default is consoleLogger with InfoLevel
+// if not specified, default is consoleLogger with InfoLevel, and default sample rate is 1
 func InitDefaultLogger(logger Logger) {
+	InitDefaultLoggerWithSample(logger, defaultSampleRate)
+}
+
+// InitDefaultLoggerWithSample init a default logger and sample logger
+// if not specified, default is consoleLogger with InfoLevel, and default sample rate is 1
+func InitDefaultLoggerWithSample(logger Logger, sampleRate float64) {
 	defaultLogger = logger
 	if defaultLogger == nil {
 		defaultLogger = NewEmptyLogger()
 	}
+	defaultSampleLogger = NewDefaultSampleLogger(defaultLogger, sampleRate)
 }
 
 // Debug write the debug log
@@ -39,6 +51,34 @@ func ErrorIf(err error, format string, args ...interface{}) error {
 	return err
 }
 
+// DebugSample write the debug log by random sampling
+func DebugSample(format string, args ...interface{}) {
+	defaultSampleLogger.Debug(format, args...)
+}
+
+// InfoSample write the info log by random sampling
+func InfoSample(format string, args ...interface{}) {
+	defaultSampleLogger.Info(format, args...)
+}
+
+// WarnSample write the warn log by random sampling
+func WarnSample(format string, args ...interface{}) {
+	defaultSampleLogger.Warn(format, args...)
+}
+
+// ErrorSample write the error log by random sampling
+func ErrorSample(err error, format string, args ...interface{}) {
+	defaultSampleLogger.Error(err, format, args...)
+}
+
+// ErrorIfSample write the error log by random sampling if err is not nil
+func ErrorIfSample(err error, format string, args ...interface{}) error {
+	if err != nil {
+		ErrorSample(err, format, args...)
+	}
+	return err
+}
+
 // Log write the log without level
 func Log(format string, args ...interface{}) {
 	defaultLogger.Log(format, args...)
@@ -55,7 +95,5 @@ func DefaultLogger() Logger {
 }
 
 func init() {
-	if defaultLogger == nil {
-		defaultLogger = NewConsoleLogger(InfoLevel)
-	}
+	InitDefaultLogger(NewConsoleLogger(InfoLevel))
 }

log_test.go

@@ -12,6 +12,7 @@ func TestLogs(t *testing.T) {
 	Error(errors.New("log err"), "%s,test error log", "hello")
 	ErrorIf(errors.New("log err from ErrorIf"), "%s, test error log", "hello")
 	ErrorIf(nil, "%s, this error log will not be printed", "hello")
+	testSampleLogs()
 	Log("%s, test log log", "hello")
 	Log("%s, test log log again", "world")
 	DefaultLogger().Write([]byte(""))

sample/sample.go

@@ -0,0 +1,21 @@
+package sample
+
+import (
+	"math/rand"
+	"time"
+)
+
+// SampleFunc the random sample function
+type SampleFunc func(rate float64) bool
+
+var random = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// DefaultSampleFunc the default random sample function
+var DefaultSampleFunc = func(rate float64) bool {
+	if rate < 0 {
+		rate = 0
+	} else if rate > 1 {
+		rate = 1
+	}
+	return random.Float64() <= rate
+}

sample/sample_test.go

@@ -0,0 +1,42 @@
+package sample
+
+import (
+	"testing"
+)
+
+func TestDefaultSampleFunc(t *testing.T) {
+	testCases := []struct {
+		name  string
+		total int
+		rate  float64
+	}{
+		{"sample rate -1", 1000, -1},
+		{"sample rate 0", 1000, 0},
+		{"sample rate 0.1", 1000, 0.1},
+		{"sample rate 0.2", 1000, 0.2},
+		{"sample rate 0.3", 1000, 0.3},
+		{"sample rate 0.4", 1000, 0.4},
+		{"sample rate 0.5", 1000, 0.5},
+		{"sample rate 0.6", 1000, 0.6},
+		{"sample rate 0.7", 1000, 0.7},
+		{"sample rate 0.8", 1000, 0.8},
+		{"sample rate 0.9", 1000, 0.9},
+		{"sample rate 1", 1000, 1},
+		{"sample rate 2", 1000, 2},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			y := 0
+			n := 0
+			for i := 0; i < tc.total; i++ {
+				if DefaultSampleFunc(tc.rate) {
+					y++
+				} else {
+					n++
+				}
+			}
+			t.Logf("[DefaultSampleFunc] total:%d rate:%.2f hit rate:%.2f hit:%d miss:%d", tc.total, tc.rate, float64(y)/float64(tc.total), y, n)
+		})
+	}
+}

sample_logger.go

@@ -0,0 +1,64 @@
+package log
+
+import "github.com/no-src/log/sample"
+
+type sampleLogger struct {
+	sampleFunc sample.SampleFunc
+	rate       float64
+	logger     Logger
+}
+
+// NewDefaultSampleLogger get a sample logger with custom sample rate
+func NewDefaultSampleLogger(logger Logger, sampleRate float64) Logger {
+	return NewSampleLogger(logger, sample.DefaultSampleFunc, sampleRate)
+}
+
+// NewSampleLogger get a sample logger with custom sample rate and sample function
+func NewSampleLogger(logger Logger, sampleFunc sample.SampleFunc, sampleRate float64) Logger {
+	l := &sampleLogger{
+		sampleFunc: sampleFunc,
+		rate:       sampleRate,
+		logger:     logger,
+	}
+	return l
+}
+
+func (l *sampleLogger) Debug(format string, args ...interface{}) {
+	if l.sample() {
+		l.logger.Debug(format, args...)
+	}
+}
+
+func (l *sampleLogger) Info(format string, args ...interface{}) {
+	if l.sample() {
+		l.logger.Info(format, args...)
+	}
+}
+
+func (l *sampleLogger) Warn(format string, args ...interface{}) {
+	if l.sample() {
+		l.logger.Warn(format, args...)
+	}
+}
+
+func (l *sampleLogger) Error(err error, format string, args ...interface{}) {
+	if l.sample() {
+		l.logger.Error(err, format, args...)
+	}
+}
+
+func (l *sampleLogger) Log(format string, args ...interface{}) {
+	l.logger.Log(format, args...)
+}
+
+func (l *sampleLogger) Close() error {
+	return l.logger.Close()
+}
+
+func (l *sampleLogger) Write(p []byte) (n int, err error) {
+	return l.logger.Write(p)
+}
+
+func (l *sampleLogger) sample() bool {
+	return l.sampleFunc(l.rate)
+}

sample_logger_test.go

@@ -0,0 +1,36 @@
+package log
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestSampleLogger(t *testing.T) {
+	testCases := []struct {
+		name       string
+		sampleRate float64
+	}{
+		{"sample rate less than zero", -1},
+		{"sample rate equals zero", 0},
+		{"normal sample rate", 0.5},
+		{"sample rate equals one", 1},
+		{"sample rate greater than one", 2},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			InitDefaultLogger(NewDefaultSampleLogger(NewConsoleLogger(DebugLevel), tc.sampleRate))
+			TestLogs(t)
+			Close()
+		})
+	}
+}
+
+func testSampleLogs() {
+	DebugSample("[sample] %s, test debug log", "hello")
+	InfoSample("[sample] %s, test info log", "hello")
+	WarnSample("[sample] %s, test warn log", "hello")
+	ErrorSample(errors.New("log err"), "[sample] %s,test error log", "hello")
+	ErrorIfSample(errors.New("log err from ErrorIfSample"), "[sample] %s, test error log", "hello")
+	ErrorIfSample(nil, "[sample] %s, this error log will not be printed", "hello")
+}