[rk-logger] Combine zap & lumber config together [commit:dongxuny]

Author: dongxuny

README.md

@@ -9,15 +9,16 @@ Currently, support zap logger as default logger and lumberjack as log rotation
 `go get -u rookie-ninja/rk-logger`
 
 ## Quick Start
-In order to init zap logger with full log rotation, rk-logger support three different utility functions
-- With zap config file path
-- With zap config as byte array
-- With zap config
+We combined zap config and lumberjack config in the same config file
+Both of the configs could keep same format as it 
 
-**Caution! Since zap and lumberjack both support log file path, we rk-logger define log file path in zap config file only.**
+In order to init zap logger with full log rotation, rk-logger support three different utility functions
+- With zap+lumberjack config file path
+- With zap+lumberjack config as byte array
+- With zap config and lumberjack config
 
 ### With Config file path
-zap config:
+config:
 ```yaml
 ---
 level: debug
@@ -47,27 +48,21 @@ encoderConfig:
   sampling:
     initial: '3'
     thereafter: '10'
-```
-lumberjack config:
-```yaml
----
 maxsize: 1
 maxage: 7
 maxbackups: 3
 localtime: true
 compress: true
 ```
+
 Example:
 ```go
 func NewZapLoggerWithConfPathExample() {
     // get current working directory
     dir, _ := os.Getwd()
-    
-    // init lumberjack logger
-    lumberjack, _ := rk_logger.NewLumberjackLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/lumberjack.yaml")), rk_logger.YAML) 
-    
-    // init zap logger 
-    logger, _, _ := rk_logger.NewZapLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/zap.yaml")), rk_logger.YAML, lumberjack)
+
+    // init logger 
+    logger, _, _ := rk_logger.NewZapLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/zap.yaml")), rk_logger.YAML)
 
     // use it 
     logger.Info("NewZapLoggerWithConfPathExample")
@@ -77,7 +72,7 @@ func NewZapLoggerWithConfPathExample() {
 Example:
 ```go
 func NewZapLoggerWithBytesExample() {
-    zapBytes := []byte(`{
+    bytes := []byte(`{
       "level": "debug",
       "encoding": "console",
       "outputPaths": ["stdout", "logs/rk-logger.log"],
@@ -102,20 +97,15 @@ func NewZapLoggerWithBytesExample() {
             "initial": "3",
             "thereafter": "10"
         }
-      }
+      },
+      "maxsize": 1,
+      "maxage": 7,
+      "maxbackups": 3,
+      "localtime": true,
+      "compress": true
     }`)
-    
-    lumberBytes := []byte(`{
-        "maxsize": 1,
-        "maxage": 7,
-        "maxbackups": 3,
-        "localtime": true,
-        "compress": true
-    }`)
-
-    lumber, _ := rk_logger.NewLumberjackLoggerWithBytes(lumberBytes, rk_logger.JSON)
 
-    logger, _, err := rk_logger.NewZapLoggerWithBytes(zapBytes, rk_logger.JSON, lumber)
+    logger, _, err := rk_logger.NewZapLoggerWithBytes(bytes, rk_logger.JSON)
 
     logger.Info("NewZapLoggerWithBytesExample")
 }

assets/zap.yaml

@@ -25,4 +25,9 @@ encoderConfig:
   nameEncoder: full
   sampling:
     initial: '3'
-    thereafter: '10'
+    thereafter: '10'
+maxsize: 1
+maxage: 7
+maxbackups: 3
+localtime: true
+compress: true

example/example.go

@@ -72,10 +72,8 @@ func NewZapLoggerWithConfExample() {
 func NewZapLoggerWithConfPathExample() {
 	// get current working directory
 	dir, _ := os.Getwd()
-	// init lumberjack logger
-	lumberjack, _ := rk_logger.NewLumberjackLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/lumberjack.yaml")), rk_logger.YAML)
 	// init zap logger
-	logger, _, _ := rk_logger.NewZapLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/zap.yaml")), rk_logger.YAML, lumberjack)
+	logger, _, _ := rk_logger.NewZapLoggerWithConfPath(path.Clean(path.Join(dir, "/assets/zap.yaml")), rk_logger.YAML)
 	// use it
 	logger.Info("NewZapLoggerWithConfPathExample")
 }
@@ -106,23 +104,15 @@ func NewZapLoggerWithBytesExample() {
             "initial": "3",
             "thereafter": "10"
         }
-      }
-    }`)
-
-	lumberBytes := []byte(`{
+      },
      "maxsize": 1,
      "maxage": 7,
      "maxbackups": 3,
      "localtime": true,
      "compress": true
     }`)
 
-	lumber, err := rk_logger.NewLumberjackLoggerWithBytes(lumberBytes, rk_logger.JSON)
-	if err != nil {
-		panic(err)
-	}
-
-	logger, _, err := rk_logger.NewZapLoggerWithBytes(zapBytes, rk_logger.JSON, lumber)
+	logger, _, err := rk_logger.NewZapLoggerWithBytes(zapBytes, rk_logger.JSON)
 
 	if err != nil {
 		panic(err)

initializer.go

@@ -6,8 +6,6 @@ package rk_logger
 
 import (
 	"encoding/json"
-	"github.com/BurntSushi/toml"
-	"github.com/hashicorp/hcl"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
@@ -23,21 +21,17 @@ type FileType int
 // Config file type which support json, yaml, toml and hcl
 // JSON: https://www.json.org/
 // YAML: https://yaml.org/
-// TOML: https://github.com/toml-lang/toml
-// HCL : https://github.com/hashicorp/hcl
 const (
 	JSON FileType = 0
 	YAML FileType = 1
-	TOML FileType = 2
-	HCL  FileType = 3
 )
 
 // Stringfy above config file types.
 func (fileType FileType) String() string {
-	names := [...]string{"JSON", "YAML", "TOML", "HCL"}
+	names := [...]string{"JSON", "YAML"}
 
 	// Please do not forget to change the boundary while adding a new config file types
-	if fileType < JSON || fileType > HCL {
+	if fileType < JSON || fileType > YAML {
 		return "UNKNOWN"
 	}
 
@@ -47,7 +41,7 @@ func (fileType FileType) String() string {
 // Init zap logger with byte array from content of config file
 // lumberjack.Logger could be empty, if not provided,
 // then, we will use default write sync
-func NewZapLoggerWithBytes(raw []byte, fileType FileType, lumber *lumberjack.Logger, opts ...zap.Option) (*zap.Logger, *zap.Config, error) {
+func NewZapLoggerWithBytes(raw []byte, fileType FileType, opts ...zap.Option) (*zap.Logger, *zap.Config, error) {
 	if raw == nil {
 		return nil, nil, errors.New("input byte array is nil")
 	}
@@ -59,36 +53,33 @@ func NewZapLoggerWithBytes(raw []byte, fileType FileType, lumber *lumberjack.Log
 	// Initialize zap logger from config file
 	var logger *zap.Logger
 	var err error
-	config := &zap.Config{}
+	zapConfig := &zap.Config{}
+	lumberConfig := &lumberjack.Logger{}
 
 	if fileType == JSON {
-		// parse json file
-		if err := json.Unmarshal(raw, config); err != nil {
+		// parse zap json file
+		if err := json.Unmarshal(raw, zapConfig); err != nil {
 			return nil, nil, err
 		}
 
-		logger, err = NewZapLoggerWithConf(config, lumber, opts...)
-	} else if fileType == YAML {
-		// parse yaml file
-		if err := yaml.Unmarshal(raw, config); err != nil {
+		// parse lumberjack json file
+		if err := json.Unmarshal(raw, lumberConfig); err != nil {
 			return nil, nil, err
 		}
 
-		logger, err = NewZapLoggerWithConf(config, lumber, opts...)
-	} else if fileType == TOML {
-		// parse toml file
-		if err := toml.Unmarshal(raw, config); err != nil {
+		logger, err = NewZapLoggerWithConf(zapConfig, lumberConfig, opts...)
+	} else if fileType == YAML {
+		// parse zap yaml file
+		if err := yaml.Unmarshal(raw, zapConfig); err != nil {
 			return nil, nil, err
 		}
 
-		logger, err = NewZapLoggerWithConf(config, lumber, opts...)
-	} else if fileType == HCL {
-		// parse hcl file
-		if err := hcl.Decode(config, string(raw)); err != nil {
+		// parse lumberjack yaml file
+		if err := yaml.Unmarshal(raw, lumberConfig); err != nil {
 			return nil, nil, err
 		}
 
-		logger, err = NewZapLoggerWithConf(config, lumber, opts...)
+		logger, err = NewZapLoggerWithConf(zapConfig, lumberConfig, opts...)
 	} else {
 		logger, err = nil, errors.New("invalid config file")
 	}
@@ -98,14 +89,14 @@ func NewZapLoggerWithBytes(raw []byte, fileType FileType, lumber *lumberjack.Log
 		return nil, nil, err
 	}
 
-	return logger, config, err
+	return logger, zapConfig, err
 }
 
 // Init zap logger with config file path
 // File path needs to be absolute path
 // lumberjack.Logger could be empty, if not provided,
 // then, we will use default write sync
-func NewZapLoggerWithConfPath(filePath string, fileType FileType, lumber *lumberjack.Logger, opts ...zap.Option) (*zap.Logger, *zap.Config, error) {
+func NewZapLoggerWithConfPath(filePath string, fileType FileType, opts ...zap.Option) (*zap.Logger, *zap.Config, error) {
 	if len(filePath) == 0 {
 		return nil, nil, errors.New("file path is empty")
 	}
@@ -119,12 +110,11 @@ func NewZapLoggerWithConfPath(filePath string, fileType FileType, lumber *lumber
 
 	if err == nil {
 		bytes, readErr := ioutil.ReadFile(filePath)
-
-		if readErr == nil {
-			logger, config, err = NewZapLoggerWithBytes(bytes, fileType, lumber, opts...)
-		} else {
-			err = readErr
+		if readErr != nil {
+			return logger, config, readErr
 		}
+
+		logger, config, err = NewZapLoggerWithBytes(bytes, fileType, opts...)
 	}
 
 	return logger, config, err

initializer_test.go

@@ -15,15 +15,11 @@ import (
 func TestConfigFileType_Indexing(t *testing.T) {
 	assert.Equal(t, FileType(0), JSON)
 	assert.Equal(t, FileType(1), YAML)
-	assert.Equal(t, FileType(2), TOML)
-	assert.Equal(t, FileType(3), HCL)
 }
 
 func TestConfigFileType_String_HappyCase(t *testing.T) {
 	assert.Equal(t, "JSON", JSON.String())
 	assert.Equal(t, "YAML", YAML.String())
-	assert.Equal(t, "TOML", TOML.String())
-	assert.Equal(t, "HCL", HCL.String())
 }
 
 func TestConfigFileType_String_Overflow_LeftBoundary(t *testing.T) {
@@ -68,24 +64,6 @@ func TestNewZapLoggerWithBytes_With_InvalidYaml(t *testing.T) {
 	assert.NotNil(t, err)
 }
 
-// With invalid toml
-func TestNewZapLoggerWithBytes_With_InvalidToml(t *testing.T) {
-	invalidToml := `key: "value"`
-	logger, config, err := NewZapLoggerWithBytes([]byte(invalidToml), TOML, nil)
-	assert.Nil(t, logger)
-	assert.Nil(t, config)
-	assert.NotNil(t, err)
-}
-
-// With invalid toml
-func TestNewZapLoggerWithBytes_With_InvalidHCL(t *testing.T) {
-	invalidHCL := `"key" : "value"`
-	logger, config, err := NewZapLoggerWithBytes([]byte(invalidHCL), HCL, nil)
-	assert.Nil(t, logger)
-	assert.Nil(t, config)
-	assert.NotNil(t, err)
-}
-
 // With unmatched type
 func TestNewZapLoggerWithBytes_With_InvalidType(t *testing.T) {
 	json := `{"key":"value"}`
@@ -140,6 +118,11 @@ func TestNewZapLoggerWithBytes_HappyCase(t *testing.T) {
             "thereafter": "10"
         }
       }
+      "maxsize": 1,
+      "maxage": 7,
+      "maxbackups": 3,
+      "localtime": true,
+      "compress": true
     }`)
 	logger, config, err := NewZapLoggerWithBytes(bytes, JSON, nil)
 	assert.NotNil(t, logger)