Merge pull request #3 from schigh/add-zerolog-shim

added zerolog shim

Author: dselans

.gitignore

@@ -0,0 +1,2 @@
+.vscode
+.idea

README.md

@@ -75,6 +75,50 @@ output:
 time="2018-03-04T13:12:35-08:00" level=debug msg="this is a debug message"
 ```
 
+### Zerolog Logger
+This shim allows you to use [zerolog](https://github.com/rs/zerolog) as your logging implementation.  If you pass `nil` into `New(...)`, 
+you will get a default `zerolog.Logger` writing to `stdout` with a timestamp attached.
+
+Alternatively, you can pass your own instance of `zerolog.Logger` to `New(...)`.
+
+Using the `zerolog` default logger:
+```go
+import "github.com/InVisionApp/go-logger/shims/zerolog"
+
+func main() {
+	logger := zerolog.New(nil)
+    logger.Debug("this is a debug message!")
+}
+
+```
+
+Using your own logger:
+```go
+import (
+	"os"
+	
+	zl "github.com/rs/zerolog"
+	"github.com/InVisionApp/go-logger/shims/zerolog"
+)
+
+func main() {
+	// zerolog is a structured logger by default
+	structuredLogger := zl.New(os.Stdout).Logger()
+	sLogger := zerolog.New(structuredLogger)
+	sLogger.Debug("debug message")
+	// {"level":"debug", "message":"debug message"}
+	
+	// If you want to use zerolog for human-readable console logging, 
+	// you create a ConsoleWriter and use it as your io.Writer implementation
+	consoleLogger := zl.New(zl.ConsoleWriter{
+		Out: os.Stdout,
+	})
+	cLogger := zerolog.New(consoleLogger)
+	cLogger.Debug("debug message")
+	// |DEBUG| debug message
+}
+```
+
 ### Test Logger
 The test logger is for capturing logs during the execution of a test. It writes the logs to a byte buffer which can be dumped and inspected. It also tracks a call count of the total number of times the logger has been called.  
 **_Note:_** this logger is not meant to be used in production. It is purely designed for use in tests.

shims/zerolog/zerolog.go

@@ -0,0 +1,122 @@
+package zerolog
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/InVisionApp/go-logger"
+	"github.com/rs/zerolog"
+)
+
+type shim struct {
+	logger *zerolog.Logger
+}
+
+// New can be used to override the default logger.
+// Optionally pass in an existing zerolog logger or
+// pass in `nil` to use the default logger
+func New(logger *zerolog.Logger) log.Logger {
+	if logger == nil {
+		lg := zerolog.New(os.Stdout).With().Timestamp().Logger()
+		logger = &lg
+	}
+
+	return &shim{logger: logger}
+}
+
+// this will add a space between all elements in the slice
+// this func is needed because fmt.Sprint will not separate
+// inputs by a space in all cases, which makes the resulting
+// output very hard to read
+func spaceSep(a []interface{}) []interface{} {
+	aLen := len(a)
+	if aLen <= 1 {
+		return a
+	}
+
+	// we only allocate enough room to add a single space between
+	// all elements, so len(a) - 1
+	spaceSlice := make([]interface{}, aLen-1)
+	// add the empty space to the end of the original slice
+	a = append(a, spaceSlice...)
+
+	// stagger the values.  this will leave an empty slot between all
+	// values to be filled with a space
+	for i := aLen - 1; i > 0; i-- {
+		a[i+i] = a[i]
+		a[i+i-1] = " "
+	}
+
+	return a
+}
+
+func (s *shim) Debug(msg ...interface{}) {
+	s.logger.Debug().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Info(msg ...interface{}) {
+	s.logger.Info().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Warn(msg ...interface{}) {
+	s.logger.Warn().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Error(msg ...interface{}) {
+	s.logger.Error().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+/*******************************************************************
+*ln funcs
+zerolog is a json-only structured logger.
+To implement human-readable console logging,
+you must initialize the logger using zerolog.ConsoleWriter
+as your io.Writer.  Calling a *ln func when zerolog
+is in structured logging mode is a no-op
+*******************************************************************/
+
+func (s *shim) Debugln(msg ...interface{}) {
+	msg = append(msg, "\n")
+	s.logger.Debug().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Infoln(msg ...interface{}) {
+	msg = append(msg, "\n")
+	s.logger.Info().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Warnln(msg ...interface{}) {
+	msg = append(msg, "\n")
+	s.logger.Warn().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Errorln(msg ...interface{}) {
+	msg = append(msg, "\n")
+	s.logger.Error().Msg(fmt.Sprint(spaceSep(msg)...))
+}
+
+func (s *shim) Debugf(format string, args ...interface{}) {
+	s.logger.Debug().Msgf(format, args...)
+}
+
+func (s *shim) Infof(format string, args ...interface{}) {
+	s.logger.Info().Msgf(format, args...)
+}
+
+func (s *shim) Warnf(format string, args ...interface{}) {
+	s.logger.Warn().Msgf(format, args...)
+}
+
+func (s *shim) Errorf(format string, args ...interface{}) {
+	s.logger.Error().Msgf(format, args...)
+}
+
+// WithFields will return a new logger derived from the original
+// zerolog logger, with the provided fields added to the log string,
+// as a key-value pair
+func (s *shim) WithFields(fields log.Fields) log.Logger {
+	lg := s.logger.With().Fields(fields).Logger()
+	s.logger = &lg
+
+	return s
+}

shims/zerolog/zerolog_suite_test.go

@@ -0,0 +1,13 @@
+package zerolog_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestZerolog(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Zerolog Suite")
+}

shims/zerolog/zerolog_test.go

@@ -0,0 +1,191 @@
+package zerolog
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"math/rand"
+
+	"github.com/InVisionApp/go-logger"
+	"github.com/rs/zerolog"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"io"
+	"os"
+)
+
+var _ = Describe("satisfies interface", func() {
+	var _ log.Logger = &shim{}
+})
+
+var _ = Describe("zerolog logger", func() {
+	var (
+		newOut *bytes.Buffer
+		l      log.Logger
+	)
+	BeforeEach(func() {
+		newOut = &bytes.Buffer{}
+		zerolog.SetGlobalLevel(zerolog.DebugLevel)
+		zl := zerolog.New(newOut).With().Timestamp().Logger()
+		l = New(&zl)
+	})
+	Context("spaceSep", func() {
+		It("works on even length slices", func() {
+			s := []interface{}{
+				1, "cat", errors.New("foo"), struct{ Name string }{"bar"},
+			}
+			s = spaceSep(s)
+			Expect(len(s)).To(Equal(7))
+
+			sstr := fmt.Sprint(s...)
+			Expect(sstr).To(Equal("1 cat foo {bar}"))
+		})
+		It("works on odd length slices", func() {
+			s := []interface{}{
+				1, "cat", errors.New("foo"), struct{ Name string }{"bar"}, []string{},
+			}
+			s = spaceSep(s)
+			Expect(len(s)).To(Equal(9))
+
+			sstr := fmt.Sprint(s...)
+			Expect(sstr).To(Equal("1 cat foo {bar} []"))
+		})
+		It("works on big slices", func() {
+			s := make([]interface{}, 10000)
+			for i := 0; i < 10000; i++ {
+				s[i] = rand.Intn(10)
+			}
+			s = spaceSep(s)
+			Expect(len(s)).To(Equal(19999))
+
+			sstr := fmt.Sprint(s...)
+			Expect(len(sstr)).To(Equal(19999))
+		})
+		It("works on little slices", func() {
+			s := []interface{}{1, 2}
+
+			s = spaceSep(s)
+			Expect(len(s)).To(Equal(3))
+
+			sstr := fmt.Sprint(s...)
+			Expect(sstr).To(Equal("1 2"))
+		})
+		It("works on really little slices", func() {
+			s := []interface{}{1}
+
+			s = spaceSep(s)
+			Expect(len(s)).To(Equal(1))
+
+			sstr := fmt.Sprint(s...)
+			Expect(sstr).To(Equal("1"))
+		})
+	})
+	Context("log funcs", func() {
+		It("prints all the log levels", func() {
+			logFuncs := map[string]func(...interface{}){
+				"debug": l.Debug,
+				"info":  l.Info,
+				"warn":  l.Warn,
+				"error": l.Error,
+			}
+
+			for level, logFunc := range logFuncs {
+				logFunc("hi there")
+
+				b := newOut.Bytes()
+				newOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					ContainSubstring(`"level":"`+level+`"`),
+				))
+			}
+		})
+		It("prints all the log levels: *ln", func() {
+			zl := zerolog.New(zerolog.ConsoleWriter{
+				Out:     newOut,
+				NoColor: true,
+			})
+			l = New(&zl)
+			logFuncs := map[string]func(...interface{}){
+				"DEBUG?": l.Debugln,
+				"INFO":   l.Infoln,
+				"WARN":   l.Warnln,
+				"ERROR?": l.Errorln,
+			}
+			for level, logFunc := range logFuncs {
+				logFunc("hi", "there")
+
+				b := newOut.Bytes()
+				newOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					MatchRegexp(level),
+				))
+			}
+		})
+		It("prints all the log levels: *f", func() {
+			logFuncs := map[string]func(string, ...interface{}){
+				"debug": l.Debugf,
+				"info":  l.Infof,
+				"warn":  l.Warnf,
+				"error": l.Errorf,
+			}
+			for level, logFunc := range logFuncs {
+				logFunc("hi %s", "there")
+
+				b := newOut.Bytes()
+				newOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					ContainSubstring(`"level":"`+level+`"`),
+				))
+			}
+		})
+		It("nil logger", func() {
+			// need to intercept stdout
+			// https://stackoverflow.com/a/10476304
+			old := os.Stdout
+
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			l = New(nil)
+			l.Debug("i am default")
+
+			outC := make(chan string)
+			go func() {
+				var buf bytes.Buffer
+				io.Copy(&buf, r)
+				outC <- buf.String()
+			}()
+			w.Close()
+			os.Stdout = old
+
+			out := <-outC
+			Expect(out).To(MatchRegexp(`{"level":"debug","time":"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z?(-\d{2}:\d{2})?","message":"i am default"}`))
+		})
+	})
+	Context("fields", func() {
+		It("", func() {
+			l = l.WithFields(log.Fields{
+				"foo": "bar",
+				"tf":  true,
+				"pet": "cat",
+				"age": 1,
+			})
+
+			l.Debug("hi there")
+			b := newOut.Bytes()
+
+			Expect(string(b)).To(SatisfyAll(
+				ContainSubstring("hi there"),
+				ContainSubstring(`"level":"debug"`),
+				ContainSubstring(`"foo":"bar"`),
+				ContainSubstring(`"tf":true`),
+				ContainSubstring(`"pet":"cat"`),
+				ContainSubstring(`"age":1`),
+			))
+		})
+	})
+})