[logger] rework bufferadapter to be safe for concurrent use

xobotyi · xobotyi · commit bb3745f9cc82 · 2025-11-07T17:27:56.000+01:00
- `bufferadapter.LogEntries` type reworked and now is thread-safe.
- `bufferadapter.New` now creates both, adapter and buffer.
- New method `bufferadapter.NewWithBuffer` allows usage of preexisting
 buffer.

Change-Id: I193e5f529eaa1591e88cf89bd24dec6042ada981
diff --git a/e/log_test.go b/e/log_test.go
@@ -16,8 +16,8 @@ import (
 func TestLog(t *testing.T) {
 	t.Parallel()
 
-	entries := make(bufferadapter.LogEntries, 0)
-	log := logger.New(bufferadapter.New(&entries), logger.DefaultLogLevel)
+	adapter, buff := bufferadapter.New()
+	log := logger.New(adapter, logger.DefaultLogLevel)
 
 	e1 := errors.New("e1") //nolint:err113
 	e2 := fmt.Errorf("e2: %w", e1)
@@ -31,7 +31,7 @@ func TestLog(t *testing.T) {
 	e.Log(e3, log.DebugE)
 	e.Log(e4, log.TraceE)
 
-	assert.Equal(t, bufferadapter.LogEntries{
+	assert.Equal(t, []bufferadapter.LogEntry{
 		{
 			LoggerName: "",
 			Level:      logger.LevelError,
@@ -67,5 +67,5 @@ func TestLog(t *testing.T) {
 			Error:      nil,
 			Fields:     nil,
 		},
-	}, entries)
+	}, buff.GetAll())
 }
diff --git a/logger/bufferadapter/adapter.go b/logger/bufferadapter/adapter.go
@@ -2,6 +2,7 @@ package bufferadapter
 
 import (
 	"slices"
+	"sync"
 
 	"dev.gaijin.team/go/golib/fields"
 	"dev.gaijin.team/go/golib/logger"
@@ -15,26 +16,67 @@ type LogEntry struct {
 	Fields     fields.List `exhaustruct:"optional"`
 }
 
-type LogEntries []LogEntry
+// LogEntries is a buffer for storing log entries in memory. It is safe for
+// concurrent use.
+type LogEntries struct {
+	mu      sync.RWMutex `exhaustruct:"optional"`
+	entries []LogEntry   `exhaustruct:"optional"`
+}
+
+// Add appends a log entry.
+func (le *LogEntries) Add(entry LogEntry) {
+	le.mu.Lock()
+	defer le.mu.Unlock()
+
+	le.entries = append(le.entries, entry)
+}
 
+// Reset clears all log entries, preserving capacity.
 func (le *LogEntries) Reset() {
-	*le = LogEntries{}
+	le.mu.Lock()
+	defer le.mu.Unlock()
+
+	le.entries = le.entries[:0]
+}
+
+// Len returns the number of log entries.
+func (le *LogEntries) Len() int {
+	le.mu.RLock()
+	defer le.mu.RUnlock()
+	return len(le.entries)
 }
 
-// Adapter is a logger.Adapter that writes logs to the provided [LogEntries]
-// slice.
-//
-// This adapter is designed for testing purposes and is not intended for
-// production use.
+// Get returns a copy of the log entry at the given index.
+// Panics if index is out of range.
+func (le *LogEntries) Get(i int) LogEntry {
+	le.mu.RLock()
+	defer le.mu.RUnlock()
+	return le.entries[i]
+}
+
+// GetAll returns a copy of log entries buffer.
+func (le *LogEntries) GetAll() []LogEntry {
+	le.mu.RLock()
+	defer le.mu.RUnlock()
+	return slices.Clone(le.entries)
+}
+
+// Adapter is a logger.Adapter implementation that writes logs to the provided
+// [LogEntries] collection.
 type Adapter struct {
-	buff *LogEntries
+	buff *LogEntries `exhaustruct:"optional"`
 	name string      `exhaustruct:"optional"`
 	fs   fields.List `exhaustruct:"optional"`
 }
 
-// New creates a new [Adapter] instance.
-func New(buff *LogEntries) *Adapter {
-	return &Adapter{buff: buff}
+// New creates a new [Adapter] instance along with a new [LogEntries] buffer that
+// will be used by adapter.
+func New() (*Adapter, *LogEntries) {
+	buff := &LogEntries{
+		entries: make([]LogEntry, 0),
+	}
+
+	return &Adapter{buff: buff}, buff
 }
 
 func (a *Adapter) Log(level int, msg string, err error, fs ...fields.Field) {
@@ -43,11 +85,10 @@ func (a *Adapter) Log(level int, msg string, err error, fs ...fields.Field) {
 		Level:      level,
 		Msg:        msg,
 		Error:      err,
+		Fields:     append(slices.Clone(a.fs), fs...),
 	}
 
-	e.Fields = append(slices.Clone(a.fs), fs...)
-
-	*a.buff = append(*a.buff, e)
+	a.buff.Add(e)
 }
 
 func (a *Adapter) WithFields(fs ...fields.Field) logger.Adapter {
diff --git a/logger/bufferadapter/adapter_test.go b/logger/bufferadapter/adapter_test.go
@@ -11,80 +11,134 @@ import (
 	"dev.gaijin.team/go/golib/logger/bufferadapter"
 )
 
+func Test_New(t *testing.T) {
+	t.Parallel()
+
+	adapter, buff := bufferadapter.New()
+	require.NotNil(t, adapter)
+	require.NotNil(t, buff)
+
+	adapter.Log(42, "test", nil)
+	require.Equal(t, 1, buff.Len())
+	assert.Equal(t, "test", buff.Get(0).Msg)
+}
+
 func TestAdapter(t *testing.T) {
 	t.Parallel()
 
 	t.Run(".Log()", func(t *testing.T) {
 		t.Parallel()
 
-		buff := bufferadapter.LogEntries{}
-		adapter := bufferadapter.New(&buff)
+		adapter, buff := bufferadapter.New()
 
 		adapter.Log(42, "foo", nil)
-		require.Len(t, buff, 1)
+		require.Equal(t, 1, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level: 42,
 			Msg:   "foo",
-		}, buff[0])
+		}, buff.Get(0))
 
 		err := e.New("some error")
 		adapter.Log(42, "foo", err, fields.F("foo", "bar"))
-		require.Len(t, buff, 2)
+		require.Equal(t, 2, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			Level:  42,
 			Msg:    "foo",
 			Error:  err,
 			Fields: fields.List{fields.F("foo", "bar")},
-		}, buff[1])
+		}, buff.Get(1))
 
 		buff.Reset()
-		assert.Empty(t, buff)
+		assert.Equal(t, 0, buff.Len())
 	})
 
 	t.Run(".WithFields()", func(t *testing.T) {
 		t.Parallel()
 
-		buff := bufferadapter.LogEntries{}
-		adapterSrc := bufferadapter.New(&buff)
+		adapterSrc, buff := bufferadapter.New()
 		adapter := adapterSrc.WithName("my-logger").WithFields(fields.F("foo", "bar"))
 
 		require.NotSame(t, adapterSrc, adapter)
 
 		adapter.Log(42, "foo", nil)
-		require.Len(t, buff, 1)
+		require.Equal(t, 1, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			LoggerName: "my-logger",
 			Level:      42,
 			Msg:        "foo",
 			Fields:     fields.List{fields.F("foo", "bar")},
-		}, buff[0])
+		}, buff.Get(0))
 
 		adapter.Log(42, "foo", nil, fields.F("baz", "qux"))
-		require.Len(t, buff, 2)
+		require.Equal(t, 2, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			LoggerName: "my-logger",
 			Level:      42,
 			Msg:        "foo",
 			Fields:     fields.List{fields.F("foo", "bar"), fields.F("baz", "qux")},
-		}, buff[1])
+		}, buff.Get(1))
 	})
 
 	t.Run(".WithName()", func(t *testing.T) {
 		t.Parallel()
 
-		buff := bufferadapter.LogEntries{}
-		adapterSrc := bufferadapter.New(&buff)
+		adapterSrc, buff := bufferadapter.New()
 		adapter := adapterSrc.WithFields(fields.F("foo", "bar")).WithName("my-logger")
 
 		require.NotSame(t, adapterSrc, adapter)
 
 		adapter.Log(42, "foo", nil)
-		require.Len(t, buff, 1)
+		require.Equal(t, 1, buff.Len())
 		assert.Equal(t, bufferadapter.LogEntry{
 			LoggerName: "my-logger",
 			Level:      42,
 			Msg:        "foo",
 			Fields:     fields.List{fields.F("foo", "bar")},
-		}, buff[0])
+		}, buff.Get(0))
+	})
+}
+
+func TestLogEntries(t *testing.T) {
+	t.Parallel()
+
+	t.Run("GetAll()", func(t *testing.T) {
+		t.Parallel()
+
+		adapter, buff := bufferadapter.New()
+
+		adapter.Log(10, "first", nil)
+		adapter.Log(20, "second", nil)
+		adapter.Log(30, "third", nil)
+
+		entries := buff.GetAll()
+		require.Len(t, entries, 3)
+		assert.Equal(t, "first", entries[0].Msg)
+		assert.Equal(t, "second", entries[1].Msg)
+		assert.Equal(t, "third", entries[2].Msg)
+	})
+
+	t.Run("Get() panics on out of range", func(t *testing.T) {
+		t.Parallel()
+
+		_, buff := bufferadapter.New()
+
+		assert.Panics(t, func() {
+			buff.Get(0)
+		})
+	})
+
+	t.Run("Reset() empties the buffer", func(t *testing.T) {
+		t.Parallel()
+
+		adapter, buff := bufferadapter.New()
+
+		for i := range 10 {
+			adapter.Log(i, "test", nil)
+		}
+
+		require.Equal(t, 10, buff.Len())
+
+		buff.Reset()
+		assert.Equal(t, 0, buff.Len())
 	})
 }
diff --git a/logger/bufferadapter/doc.go b/logger/bufferadapter/doc.go
@@ -0,0 +1,21 @@
+// Package bufferadapter provides an in-memory logger adapter for testing.
+//
+// This package implements the logger.Adapter interface by storing log entries in
+// memory, allowing tests to inspect what was logged. The adapter is safe for
+// concurrent use and designed specifically for testing purposes.
+//
+// # Usage
+//
+// Create a buffer adapter and use it with a logger:
+//
+//	adapter, buff := bufferadapter.New()
+//	log := logger.New(adapter, logger.LevelInfo)
+//
+//	log.Info("test message", fields.F("key", "value"))
+//
+//	// Assert in tests
+//	entries := buff.GetAll()
+//	require.Len(t, entries, 1)
+//	assert.Equal(t, "test message", entries[0].Msg)
+//	assert.Equal(t, logger.LevelInfo, entries[0].Level)
+package bufferadapter
