[logger] rework logger name, stacktrace and error passthrough

- Finalize logger documentation.
- Add stacktrace capture.
- Change the way name and error being passed to adapter. Since many
backends lacks, for example, named loggers - consistent way is to pass
these parameters as fields, rather handle them special way per adapter.
Though, adapters still able to handle these fields if needed, manually
processing fields and extracting required fields.

Change-Id: I083ba13131f87773ec6cff4cf1f12a4f598b92a5

Author: xobotyi

e/log_test.go

@@ -17,7 +17,7 @@ func TestLog(t *testing.T) {
 	t.Parallel()
 
 	adapter, buff := bufferadapter.New()
-	log := logger.New(adapter, logger.DefaultLogLevel)
+	log := logger.New(adapter, logger.WithLevel(logger.LevelTrace))
 
 	e1 := errors.New("e1") //nolint:err113
 	e2 := fmt.Errorf("e2: %w", e1)
@@ -35,31 +35,26 @@ func TestLog(t *testing.T) {
 		{
 			Level:  logger.LevelError,
 			Msg:    e1.Error(),
-			Error:  nil,
 			Fields: nil,
 		},
 		{
 			Level:  logger.LevelWarning,
 			Msg:    e1.Error(),
-			Error:  nil,
 			Fields: nil,
 		},
 		{
 			Level:  logger.LevelInfo,
 			Msg:    e2.Error(),
-			Error:  nil,
 			Fields: nil,
 		},
 		{
 			Level:  logger.LevelDebug,
 			Msg:    e3.Reason(),
-			Error:  e1,
-			Fields: e3.Fields(),
+			Fields: fields.List{fields.F("foo", "bar"), fields.F("error", "e1")},
 		},
 		{
 			Level:  logger.LevelTrace,
 			Msg:    e4.Reason(),
-			Error:  nil,
 			Fields: nil,
 		},
 	}, buff.GetAll())

logger/adapter.go

@@ -13,18 +13,15 @@ import (
 //
 // For examples of adapter implementations, see the adapters subpackages.
 type Adapter interface {
-	// Log logs a message with the provided level, message, optional error, and
-	// additional fields. The level parameter is one of the logger level constants
-	// (LevelError, LevelWarning, LevelInfo, LevelDebug, LevelTrace) or a custom
-	// level value.
+	// Log logs a message with the provided level, message, and fields.
 	//
-	// The err parameter may be nil if no error is associated with the log message.
-	// Adapters should handle nil errors gracefully.
+	// The level parameter is one of the logger level constants (LevelError,
+	// LevelWarning, LevelInfo, LevelDebug, LevelTrace) or a custom level value.
 	//
 	// The fs parameter contains zero or more fields that should be attached to the
 	// log entry. This may include both fields from WithFields calls and fields
 	// passed directly to the Log call.
-	Log(level int, msg string, err error, fs ...fields.Field)
+	Log(level int, msg string, fs ...fields.Field)
 
 	// WithFields returns a new adapter instance with the given fields attached.
 	// The returned adapter should include these fields in all subsequent Log calls.

logger/bufferadapter/adapter.go

@@ -11,7 +11,6 @@ import (
 type LogEntry struct {
 	Level  int
 	Msg    string
-	Error  error       `exhaustruct:"optional"`
 	Fields fields.List `exhaustruct:"optional"`
 }
 
@@ -77,11 +76,10 @@ func New() (*Adapter, *LogEntries) {
 	return &Adapter{buff: buff}, buff
 }
 
-func (a *Adapter) Log(level int, msg string, err error, fs ...fields.Field) {
+func (a *Adapter) Log(level int, msg string, fs ...fields.Field) {
 	e := LogEntry{
 		Level:  level,
 		Msg:    msg,
-		Error:  err,
 		Fields: append(slices.Clone(a.fs), fs...),
 	}
 

logger/bufferadapter/adapter_test.go

@@ -18,7 +18,7 @@ func Test_New(t *testing.T) {
 	require.NotNil(t, adapter)
 	require.NotNil(t, buff)
 
-	adapter.Log(42, "test", nil)
+	adapter.Log(42, "test")
 	require.Equal(t, 1, buff.Len())
 	assert.Equal(t, "test", buff.Get(0).Msg)
 }
@@ -31,21 +31,20 @@ func TestAdapter(t *testing.T) {
 
 		adapter, buff := bufferadapter.New()
 
-		adapter.Log(42, "foo", nil)
+		adapter.Log(42, "foo")
 		require.Equal(t, 1, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level: 42,
 			Msg:   "foo",
 		}, buff.Get(0))
 
 		err := e.New("some error")
-		adapter.Log(42, "foo", err, fields.F("foo", "bar"))
+		adapter.Log(42, "foo", fields.F("error", err), fields.F("foo", "bar"))
 		require.Equal(t, 2, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level:  42,
 			Msg:    "foo",
-			Error:  err,
-			Fields: fields.List{fields.F("foo", "bar")},
+			Fields: fields.List{fields.F("error", err), fields.F("foo", "bar")},
 		}, buff.Get(1))
 
 		buff.Reset()
@@ -60,15 +59,15 @@ func TestAdapter(t *testing.T) {
 
 		require.NotSame(t, adapterSrc, adapter)
 
-		adapter.Log(42, "foo", nil)
+		adapter.Log(42, "foo")
 		require.Equal(t, 1, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level:  42,
 			Msg:    "foo",
 			Fields: fields.List{fields.F("foo", "bar")},
 		}, buff.Get(0))
 
-		adapter.Log(42, "foo", nil, fields.F("baz", "qux"))
+		adapter.Log(42, "foo", fields.F("baz", "qux"))
 		require.Equal(t, 2, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level:  42,
@@ -86,9 +85,9 @@ func TestLogEntries(t *testing.T) {
 
 		adapter, buff := bufferadapter.New()
 
-		adapter.Log(10, "first", nil)
-		adapter.Log(20, "second", nil)
-		adapter.Log(30, "third", nil)
+		adapter.Log(10, "first")
+		adapter.Log(20, "second")
+		adapter.Log(30, "third")
 
 		entries := buff.GetAll()
 		require.Len(t, entries, 3)
@@ -113,7 +112,7 @@ func TestLogEntries(t *testing.T) {
 		adapter, buff := bufferadapter.New()
 
 		for i := range 10 {
-			adapter.Log(i, "test", nil)
+			adapter.Log(i, "test")
 		}
 
 		require.Equal(t, 10, buff.Len())

logger/ctx_test.go

@@ -0,0 +1,58 @@
+package logger_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"dev.gaijin.team/go/golib/logger"
+	"dev.gaijin.team/go/golib/logger/bufferadapter"
+)
+
+func TestToAndFromCtx(t *testing.T) {
+	t.Parallel()
+
+	adapter, _ := bufferadapter.New()
+	lgr := logger.New(adapter)
+
+	ctxEmpty := context.Background()
+	ctxLogger := logger.ToCtx(ctxEmpty, lgr)
+
+	require.NotEqual(t, ctxLogger, ctxEmpty, "ToCtx creates a new context")
+
+	{
+		lgrCtx, ok := logger.FromCtx(ctxEmpty)
+		assert.False(t, ok, "should return false for empty context")
+		assert.True(t, lgrCtx.IsZero(), "should return zero-value logger for empty context")
+	}
+
+	{
+		lgrCtx, ok := logger.FromCtx(ctxLogger)
+		assert.True(t, ok, "should return true for context with logger")
+		assert.False(t, lgrCtx.IsZero(), "should not return zero-value logger for context with logger")
+		assert.Equal(t, lgr, lgrCtx, "should return same logger as stored in context")
+	}
+}
+
+func TestFromCtxOrNop(t *testing.T) {
+	t.Parallel()
+
+	adapter, _ := bufferadapter.New()
+	lgr := logger.New(adapter)
+
+	ctxEmpty := context.Background()
+	ctxLogger := logger.ToCtx(ctxEmpty, lgr)
+
+	{
+		lgrCtx := logger.FromCtxOrNop(ctxEmpty)
+		assert.True(t, lgrCtx.IsNop(), "should return nop logger for empty context")
+	}
+
+	{
+		lgrCtx := logger.FromCtxOrNop(ctxLogger)
+		assert.False(t, lgrCtx.IsNop(), "should not return nop logger for context with logger")
+		assert.Equal(t, lgr, lgrCtx, "should return same logger as stored in context")
+	}
+}