Tests and linter fix

README.md

@@ -3,7 +3,8 @@ logs-go
 
 [![CircleCI](https://circleci.com/gh/spacetab-io/logs-go.svg?style=shield)](https://circleci.com/gh/spacetab-io/logs-go) [![codecov](https://codecov.io/gh/spacetab-io/logs-go/graph/badge.svg)](https://codecov.io/gh/spacetab-io/logs-go)
 
-Wrapper for [zerolog](https://github.com/rs/zerolog) tuned to work with [configuration](https://github.com/spacetab-io/configuration-go) and sentry hook.
+Wrapper for [zerolog](https://github.com/rs/zerolog) tuned to work with [configuration](https://github.com/spacetab-io/configuration-go) and
+sentry hook.
 
 ## Usage
 
@@ -13,14 +14,17 @@ Initiate new logger with filled `log.Config` and use it as common zerolog
 package main
 
 import (
-	"github.com/spacetab-io/logs-go/v2"
+	log "github.com/spacetab-io/logs-go/v2"
 )
 
 func main() {
 	conf := log.Config{
-		Level:      "warn",
-		Format:     "text",
-		ShowCaller: true,
+		Level:  "warn",
+		Format: "text",
+		Caller: &log.CallerConfig{
+			Disabled:         false,
+			CallerSkipFrames: 2,
+		},
 		Sentry: &log.SentryConfig{
 			Enable: true,
 			DSN:    "http://dsn.sentry.com",

fasthttp_test.go

@@ -0,0 +1,18 @@
+package log
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFHLogger_Printf(t *testing.T) {
+	out := &bytes.Buffer{}
+	_ = initLog(out)
+	fhl := FHLogger{}
+	fhl.Printf("some %s", "data")
+
+	exp := "DBG |> some data <|"
+	assert.Contains(t, out.String(), exp)
+}

logger.go

@@ -18,10 +18,25 @@ import (
 const (
 	defaultLevel    = "debug"
 	ctxRequestIDKey = "request_id"
+
+	defaultCallerSkipFrames    = 2
+	standAloneCallerSkipFrames = 6
 )
 
+type zLogger struct {
+	zerolog.Logger
+	cfg Config
+}
+
 // logger is the global logger.
-var logger, _ = newZerolog(Config{Level: "debug", Format: FormatText, Caller: &CallerConfig{CallerSkipFrames: 6}}, os.Stdout)
+var logger, _ = newZerolog(
+	Config{
+		Level:  defaultLevel,
+		Format: FormatText,
+		Caller: &CallerConfig{CallerSkipFrames: standAloneCallerSkipFrames},
+	},
+	nil,
+)
 
 // set global Zerolog logger
 func Init(stage string, cfg Config, serviceAlias string, serviceVersion string, w io.Writer) (err error) {
@@ -35,7 +50,7 @@ func Init(stage string, cfg Config, serviceAlias string, serviceVersion string,
 
 	if cfg.Caller == nil {
 		cfg.Caller = &CallerConfig{
-			CallerSkipFrames: 2,
+			CallerSkipFrames: defaultCallerSkipFrames,
 		}
 	}
 
@@ -59,7 +74,7 @@ func Init(stage string, cfg Config, serviceAlias string, serviceVersion string,
 	return err
 }
 
-func newZerolog(cfg Config, w io.Writer) (logger zerolog.Logger, err error) {
+func newZerolog(cfg Config, w io.Writer) (logger zLogger, err error) {
 	// setup a global function that transforms any error passed to
 	// zerolog to an error with stack strace.
 	zerolog.ErrorMarshalFunc = func(err error) interface{} {
@@ -128,7 +143,8 @@ func newZerolog(cfg Config, w io.Writer) (logger zerolog.Logger, err error) {
 		lctx = lctx.Caller()
 	}
 
-	logger = lctx.Logger().Level(level)
+	logger.Logger = lctx.Logger().Level(level)
+	logger.cfg = cfg
 
 	stdlog.SetFlags(0)
 	stdlog.SetOutput(logger)
@@ -150,12 +166,13 @@ func getLevel(lvl string) (zerolog.Level, error) {
 }
 
 func Logger() zerolog.Logger {
-	return logger
+	return logger.Logger
 }
 
 // Output duplicates the global logger and sets w as its output.
 func Output(w io.Writer) zerolog.Logger {
-	return logger.Output(w)
+	l, _ := newZerolog(logger.cfg, w)
+	return l.Logger
 }
 
 // With creates a child logger with the field added to its context.

logger_test.go

@@ -6,87 +6,207 @@ import (
 	"io"
 	"testing"
 
+	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 )
 
+func TestInit(t *testing.T) {
+	t.Run("writer as buffer init", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		err := initLog(out)
+		assert.NoError(t, err, "logger init")
+	})
+	t.Run("nil writer init", func(t *testing.T) {
+		err := initLog(nil)
+		assert.NoError(t, err, "logger init")
+	})
+	t.Run("default format init", func(t *testing.T) {
+		err := Init("test", Config{
+			Level:   "trace",
+			NoColor: true,
+			Caller: &CallerConfig{
+				Disabled:         false,
+				CallerSkipFrames: 2,
+			},
+		}, "log", "v2.*.*", nil)
+		assert.NoError(t, err, "logger init")
+	})
+	t.Run("default level init", func(t *testing.T) {
+		err := Init("test", Config{
+			NoColor: true,
+			Caller: &CallerConfig{
+				Disabled:         false,
+				CallerSkipFrames: 2,
+			},
+		}, "log", "v2.*.*", nil)
+		assert.NoError(t, err, "logger init")
+	})
+	t.Run("default caller init", func(t *testing.T) {
+		err := Init("test", Config{
+			NoColor: true,
+			Caller:  nil,
+		}, "log", "v2.*.*", nil)
+		assert.NoError(t, err, "logger init")
+	})
+	t.Run("wrong level init", func(t *testing.T) {
+		err := Init("test", Config{
+			NoColor: true,
+			Level:   "fart",
+		}, "log", "v2.*.*", nil)
+		assert.Error(t, err, "logger init")
+	})
+}
+
+func TestOutput(t *testing.T) {
+	err := initLog(nil)
+	if !assert.NoError(t, err, "logger init") {
+		t.FailNow()
+	}
+
+	out := &bytes.Buffer{}
+	l := Output(out)
+	l.Trace().Msg("trace")
+
+	exp := "TRC |> trace <|"
+	assert.Contains(t, out.String(), exp)
+}
+
+func TestLevel(t *testing.T) {
+	out := &bytes.Buffer{}
+
+	err := initLog(out)
+	if !assert.NoError(t, err, "logger init") {
+		t.FailNow()
+	}
+
+	logger.Trace().Msg("test trace")
+
+	exp := "test trace"
+	assert.Contains(t, out.String(), exp)
+
+	l2 := Level(zerolog.WarnLevel)
+	l2.Trace().Msg("test trace")
+
+	exp = ""
+	assert.Contains(t, out.String(), exp)
+}
+
+func TestLevelString(t *testing.T) {
+	out := &bytes.Buffer{}
+
+	err := initLog(out)
+	if !assert.NoError(t, err, "logger init") {
+		t.FailNow()
+	}
+
+	logger.Trace().Msg("test trace")
+
+	exp := "test trace"
+	assert.Contains(t, out.String(), exp)
+
+	l2 := LevelString("warn")
+	l2.Trace().Msg("test trace")
+
+	exp = ""
+	assert.Contains(t, out.String(), exp)
+}
+
 func TestTrace(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
 	Trace().Msg("trace")
+
 	exp := "TRC |> trace <|"
 	assert.Contains(t, out.String(), exp)
 }
 
 func TestDebug(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
 	Debug().Msg("debug")
+
 	exp := "DBG |> debug <|"
 	assert.Contains(t, out.String(), exp)
 }
 
 func TestInfo(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
 	Info().Msg("info")
+
 	exp := "INF |> info <|"
 	assert.Contains(t, out.String(), exp)
 }
 
 func TestWarn(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
 	Warn().Msg("warn")
+
 	exp := "WRN |> warn <|"
 	assert.Contains(t, out.String(), exp)
 }
 
 func TestError(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
 	Error().Msg("error")
+
 	exp := "ERR |> error <|"
 	assert.Contains(t, out.String(), exp)
 }
 
 func TestErr(t *testing.T) {
 	out := &bytes.Buffer{}
+
 	err := initLog(out)
 	if !assert.NoError(t, err, "logger init") {
 		t.FailNow()
 	}
 
-	Error().Err(errors.New("some err")).Msg("error")
-	exp := "ERR |> error <| logger_test.go:79 > error=\"some err\""
+	Err(errors.New("some err")).Msg("error")
+
+	exp := "ERR |> error <| "
+	assert.Contains(t, out.String(), exp)
+
+	exp = " > error=\"some err\""
 	assert.Contains(t, out.String(), exp)
 }
 
 func initLog(w io.Writer) error {
 	return Init("test", Config{
-		Level:      "trace",
-		Format:     "text",
-		NoColor:    true,
-		ShowCaller: true,
-		Sentry:     nil,
+		Level:   "trace",
+		Format:  "text",
+		NoColor: true,
+		Caller: &CallerConfig{
+			Disabled:         false,
+			CallerSkipFrames: 2,
+		},
+		Sentry: nil,
 	}, "log", "v2.*.*", w)
 }

nsqd_test.go

@@ -0,0 +1,18 @@
+package log
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNSQLogger_Output(t *testing.T) {
+	out := &bytes.Buffer{}
+	_ = initLog(out)
+
+	nsqdLogger := NewNSQLogger("debug")
+	err := nsqdLogger.Output(2, "some log")
+	assert.NoError(t, err, "nsqdLogger.Output error")
+	assert.Contains(t, out.String(), "some log")
+}