From e3a5e0bf85eecbb566d0c1d7710196e6c4180554 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eduardo=20Aguilar=20Y=C3=A9pez?= <dante.aguilar41@gmail.com>
Date: Wed, 17 Apr 2024 16:29:26 -0600
Subject: [PATCH] feat: add zerolog level methods (#30)

---
 adapters/zerolog/zerolog.go      | 32 +++++++++++----
 adapters/zerolog/zerolog_test.go | 70 +++++++++++++++++++++++++++++---
 2 files changed, 89 insertions(+), 13 deletions(-)

diff --git a/adapters/zerolog/zerolog.go b/adapters/zerolog/zerolog.go
index 37025fa..6e5cd88 100644
--- a/adapters/zerolog/zerolog.go
+++ b/adapters/zerolog/zerolog.go
@@ -7,10 +7,9 @@ import (
 	"runtime/debug"
 	"strings"
 
-	"github.com/rs/zerolog"
-
 	"github.com/danteay/golog/fields"
 	"github.com/danteay/golog/levels"
+	"github.com/rs/zerolog"
 )
 
 // Adapter is a zerolog adapter implementation
@@ -51,6 +50,18 @@ func (a *Adapter) Writer() io.Writer {
 // SetWriter sets the writer for the adapter
 func (a *Adapter) SetWriter(w io.Writer) {
 	a.writer = w
+	a.logger = a.logger.Output(w)
+}
+
+// Level returns the level for the adapter
+func (a *Adapter) Level() levels.Level {
+	return a.level
+}
+
+// SetLevel sets the level for the adapter
+func (a *Adapter) SetLevel(level levels.Level) {
+	a.level = level
+	a.logger = a.logger.Level(getLevels(level))
 }
 
 // Logger returns the zerolog logger instance
@@ -60,6 +71,10 @@ func (a *Adapter) Logger() zerolog.Logger {
 
 // Log logs a message with the given level, error, fields, and message
 func (a *Adapter) Log(level levels.Level, err error, logFields *fields.Fields, msg string, args ...any) {
+	if level <= levels.Disabled {
+		return
+	}
+
 	log := a.getLog(level)
 
 	addErrFields(level, err, log, a.withTrace)
@@ -75,12 +90,13 @@ func (a *Adapter) Log(level levels.Level, err error, logFields *fields.Fields, m
 
 func (a *Adapter) getLog(level levels.Level) *zerolog.Event {
 	events := map[levels.Level]func() *zerolog.Event{
-		levels.Debug: a.logger.Debug,
-		levels.Info:  a.logger.Info,
-		levels.Warn:  a.logger.Warn,
-		levels.Error: a.logger.Error,
-		levels.Fatal: a.logger.Fatal,
-		levels.Panic: a.logger.Panic,
+		levels.TraceLevel: a.logger.Trace,
+		levels.Debug:      a.logger.Debug,
+		levels.Info:       a.logger.Info,
+		levels.Warn:       a.logger.Warn,
+		levels.Error:      a.logger.Error,
+		levels.Fatal:      a.logger.Fatal,
+		levels.Panic:      a.logger.Panic,
 	}
 
 	event, exists := events[level]
diff --git a/adapters/zerolog/zerolog_test.go b/adapters/zerolog/zerolog_test.go
index 233f1f5..6ac0f12 100644
--- a/adapters/zerolog/zerolog_test.go
+++ b/adapters/zerolog/zerolog_test.go
@@ -14,11 +14,12 @@ import (
 )
 
 type testMsg struct {
-	Level   string `json:"level"`
-	Message string `json:"message"`
-	Error   string `json:"error"`
-	Key1    string `json:"key1"`
-	Key2    int    `json:"key2"`
+	Level   string   `json:"level"`
+	Message string   `json:"message"`
+	Error   string   `json:"error"`
+	Key1    string   `json:"key1"`
+	Key2    int      `json:"key2"`
+	Stack   []string `json:"stack"`
 }
 
 func TestAdapter_Log(t *testing.T) {
@@ -135,6 +136,65 @@ func TestAdapter_Log(t *testing.T) {
 
 		assert.Equal(t, "", logOutput.String())
 	})
+
+	t.Run("should log message with error and stack trace", func(t *testing.T) {
+		var logOutput bytes.Buffer
+
+		logger := New(WithLevel(levels.TraceLevel), WithWriter(&logOutput))
+
+		msg := "Test message"
+		err := errors.New("test error")
+
+		logger.Log(levels.TraceLevel, err, nil, msg)
+
+		res := testMsg{}
+
+		if errUnmarshall := json.Unmarshal(logOutput.Bytes(), &res); errUnmarshall != nil {
+			t.Fatal(errUnmarshall)
+		}
+
+		assert.Equal(t, levels.TraceLevel.String(), res.Level)
+		assert.Equal(t, msg, res.Message)
+		assert.Equal(t, err.Error(), res.Error)
+		assert.NotEmpty(t, res.Stack)
+	})
+
+	t.Run("should change level", func(t *testing.T) {
+		var logOutput bytes.Buffer
+
+		logger := New(WithLevel(levels.Info), WithWriter(&logOutput))
+
+		logger.Log(levels.Debug, nil, nil, "Test message")
+
+		assert.Equal(t, "", logOutput.String())
+
+		logger.SetLevel(levels.Debug)
+
+		logger.Log(levels.Debug, nil, nil, "Test message")
+
+		assert.NotEqual(t, "", logOutput.String())
+	})
+
+	t.Run("should change writer", func(t *testing.T) {
+		var logOutput bytes.Buffer
+
+		logger := New(WithLevel(levels.Debug), WithWriter(&logOutput))
+
+		logger.Log(levels.Debug, nil, nil, "Test message")
+
+		assert.NotEqual(t, "", logOutput.String())
+
+		logOutput.Reset()
+
+		var newOutput bytes.Buffer
+
+		logger.SetWriter(&newOutput)
+
+		logger.Log(levels.Debug, nil, nil, "Test message")
+
+		assert.NotEqual(t, "", newOutput.String())
+		assert.Equal(t, "", logOutput.String())
+	})
 }
 
 func TestGetLevels(t *testing.T) {