fix the logger data race

common/logger/logger.go

@@ -20,6 +20,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 
 	rotatelogs "github.com/lestrrat/go-file-rotatelogs"
@@ -29,7 +30,8 @@ import (
 )
 
 var (
-	logger Logger
+	logger  Logger
+	logLock sync.RWMutex
 )
 
 var levelMap = map[string]zapcore.Level{
@@ -79,20 +81,28 @@ func init() {
 	}
 	zapLoggerConfig.EncoderConfig = zapLoggerEncoderConfig
 	zapLogger, _ := zapLoggerConfig.Build(zap.AddCallerSkip(1))
-	logger = &NacosLogger{zapLogger.Sugar()}
+	SetLogger(&NacosLogger{zapLogger.Sugar()})
 }
 
+// InitLogger is init global logger for nacos
 func InitLogger(config Config) (err error) {
+	logLock.Lock()
+	defer logLock.Unlock()
+	logger, err = InitNacosLogger(config)
+	return
+}
+
+// InitNacosLogger is init nacos default logger
+func InitNacosLogger(config Config) (Logger, error) {
 	logLevel := getLogLevel(config.Level)
 	encoder := getEncoder()
 	writer, err := getWriter(config.OutputPath, config.RotationTime, config.MaxAge)
 	if err != nil {
-		return
+		return nil, err
 	}
 	core := zapcore.NewCore(zapcore.NewConsoleEncoder(encoder), zapcore.AddSync(writer), logLevel)
 	zaplogger := zap.New(core, zap.AddCallerSkip(1))
-	logger = &NacosLogger{zaplogger.Sugar()}
-	return
+	return &NacosLogger{zaplogger.Sugar()}, nil
 }
 
 func getLogLevel(level string) zapcore.Level {
@@ -132,9 +142,13 @@ func getWriter(outputPath string, rotateTime string, maxAge int64) (writer io.Wr
 
 //SetLogger sets logger for sdk
 func SetLogger(log Logger) {
+	logLock.Lock()
+	defer logLock.Unlock()
 	logger = log
 }
 
 func GetLogger() Logger {
+	logLock.RLock()
+	defer logLock.RUnlock()
 	return logger
 }

common/logger/logger_test.go

@@ -17,11 +17,16 @@
 package logger
 
 import (
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+func reset() {
+	SetLogger(nil)
+}
+
 func TestInitLogger(t *testing.T) {
 	config := Config{
 		Level:        "degug",
@@ -31,4 +36,113 @@ func TestInitLogger(t *testing.T) {
 	}
 	err := InitLogger(config)
 	assert.NoError(t, err)
+	reset()
+}
+
+func TestGetLogger(t *testing.T) {
+	// not yet init get default log
+	log := GetLogger()
+	config := Config{
+		Level:        "degug",
+		OutputPath:   "/tmp/nacos",
+		RotationTime: "1h",
+		MaxAge:       2,
+	}
+	_ = InitLogger(config)
+	// after init logger
+	log2 := GetLogger()
+	assert.NotEqual(t, log, log2)
+
+	// the secend init logger
+	config.Level = "info"
+	_ = InitLogger(config)
+	log3 := GetLogger()
+	assert.NotEqual(t, log2, log3)
+	reset()
+}
+
+func TestSetLogger(t *testing.T) {
+	// not yet init get default log
+	log := GetLogger()
+	log1 := &mockLogger{}
+	SetLogger(log1)
+
+	// after set logger
+	log2 := GetLogger()
+	assert.NotEqual(t, log, log2)
+	assert.Equal(t, log1, log2)
+
+	config := Config{
+		Level:        "degug",
+		OutputPath:   "/tmp/nacos",
+		RotationTime: "1h",
+		MaxAge:       2,
+	}
+	_ = InitLogger(config)
+	// after init logger
+	log3 := GetLogger()
+	assert.NotEqual(t, log2, log3)
+	reset()
+}
+
+func TestRaceLogger(t *testing.T) {
+	wg := sync.WaitGroup{}
+	for i := 0; i < 100; i++ {
+		wg.Add(3)
+		go func() {
+			defer wg.Done()
+			SetLogger(&mockLogger{})
+		}()
+		go func() {
+			defer wg.Done()
+			_ = GetLogger()
+		}()
+		go func() {
+			defer wg.Done()
+			config := Config{
+				Level:        "degug",
+				OutputPath:   "/tmp/nacos",
+				RotationTime: "1h",
+				MaxAge:       2,
+			}
+			_ = InitLogger(config)
+		}()
+	}
+	wg.Wait()
+	reset()
+}
+
+type mockLogger struct {
+}
+
+func (m mockLogger) Info(args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Warn(args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Error(args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Debug(args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Infof(fmt string, args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Warnf(fmt string, args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Errorf(fmt string, args ...interface{}) {
+	panic("implement me")
+}
+
+func (m mockLogger) Debugf(fmt string, args ...interface{}) {
+	panic("implement me")
 }

common/logger/logging.go

@@ -18,40 +18,40 @@ package logger
 
 // Info is info level
 func Info(args ...interface{}) {
-	logger.Info(args...)
+	GetLogger().Info(args...)
 }
 
 // Warn is warning level
 func Warn(args ...interface{}) {
-	logger.Warn(args...)
+	GetLogger().Warn(args...)
 }
 
 // Error is error level
 func Error(args ...interface{}) {
-	logger.Error(args...)
+	GetLogger().Error(args...)
 }
 
 // Debug is debug level
 func Debug(args ...interface{}) {
-	logger.Debug(args...)
+	GetLogger().Debug(args...)
 }
 
 // Infof is format info level
 func Infof(fmt string, args ...interface{}) {
-	logger.Infof(fmt, args...)
+	GetLogger().Infof(fmt, args...)
 }
 
 // Warnf is format warning level
 func Warnf(fmt string, args ...interface{}) {
-	logger.Warnf(fmt, args...)
+	GetLogger().Warnf(fmt, args...)
 }
 
 // Errorf is format error level
 func Errorf(fmt string, args ...interface{}) {
-	logger.Errorf(fmt, args...)
+	GetLogger().Errorf(fmt, args...)
 }
 
 // Debugf is format debug level
 func Debugf(fmt string, args ...interface{}) {
-	logger.Debugf(fmt, args...)
+	GetLogger().Debugf(fmt, args...)
 }