Revert "Remove Entry.With method"

This reverts commit 80d8c30

It turns out that this change is unsafe from concurrency perspective.

adapter/glogadapter/glog_test.go

@@ -59,8 +59,7 @@ func TestAdapter_Log(t *testing.T) {
 		entry := logger.Entry{
 			Level:   logger.ErrorLevel,
 			Message: message,
-		}
-		entry.Fields = append(entry.Fields, logger.Field{
+		}.With(logger.Field{
 			Key:   "k",
 			Value: "v",
 		})

adapter/internal/adaptertest/adaptertest.go

@@ -154,8 +154,7 @@ func Run(t *testing.T, subject Subject) { // nolint
 		for name, field := range fields {
 			var builder strings.Builder
 			adapter := subject.NewAdapter(&builder)
-			entryWithField := entry
-			entryWithField.Fields = append(entryWithField.Fields,
+			entryWithField := entry.With(
 				logger.Field{
 					Key:   name,
 					Value: field.value,
@@ -176,14 +175,13 @@ func Run(t *testing.T, subject Subject) { // nolint
 			stringFieldValue = "string"
 			intFieldValue    = 2
 		)
-		entryWithFields := entry
-		entryWithFields.Fields = append(entryWithFields.Fields,
+		entryWithFields := entry.With(
 			logger.Field{
 				Key:   "StringField",
 				Value: stringFieldValue,
 			},
 		)
-		entryWithFields.Fields = append(entryWithFields.Fields,
+		entryWithFields = entryWithFields.With(
 			logger.Field{
 				Key:   "IntField",
 				Value: intFieldValue,
@@ -204,8 +202,7 @@ func Run(t *testing.T, subject Subject) { // nolint
 			stringFieldValue = "string"
 			err              = "err"
 		)
-		entryWithFieldAndError := entry
-		entryWithFieldAndError.Fields = append(entryWithFieldAndError.Fields,
+		entryWithFieldAndError := entry.With(
 			logger.Field{
 				Key:   "StringField",
 				Value: stringFieldValue,

logger/_examples/caller/main.go

@@ -43,8 +43,8 @@ func (a ReportCallerAdapter) Log(ctx context.Context, entry logger.Entry) {
 	entry.SkippedCallerFrames++ // each middleware adapter must additionally skip one frame (at least)
 
 	if _, file, line, ok := runtime.Caller(entry.SkippedCallerFrames); ok {
-		entry.Fields = append(entry.Fields, logger.Field{Key: "file", Value: file})
-		entry.Fields = append(entry.Fields, logger.Field{Key: "line", Value: line})
+		entry = entry.With(logger.Field{Key: "file", Value: file})
+		entry = entry.With(logger.Field{Key: "line", Value: line})
 	}
 
 	a.NextAdapter.Log(ctx, entry)

logger/_examples/tags/main.go

@@ -36,12 +36,13 @@ type AddFieldFromContextAdapter struct {
 }
 
 func (a AddFieldFromContextAdapter) Log(ctx context.Context, entry logger.Entry) {
-	entry.Fields = append(entry.Fields,
+	// entry.With creates an entry and adds a new field to it
+	newEntry := entry.With(
 		logger.Field{
 			Key:   tag,
 			Value: ctx.Value(tag),
 		},
 	)
-	entry.SkippedCallerFrames++ // each middleware adapter must additionally skip one frame
-	a.NextAdapter.Log(ctx, entry)
+	newEntry.SkippedCallerFrames++ // each middleware adapter must additionally skip one frame
+	a.NextAdapter.Log(ctx, newEntry)
 }

logger/adapter.go

@@ -20,8 +20,9 @@ type Entry struct {
 
 	// Fields contains all accumulated fields, in the order they were appended.
 	//
-	// Please do not update fields in the slice as other go-routines may still read them. To add a new field
-	// please use append built-in function. To remove a field, please create a new slice and copy remaining fields.
+	// Please do not modify the slice directly as other go-routines may still read it.  To append a new field
+	// please use With method. It will create a new entry with copy of all fields, plus the new one. To remove a field,
+	// please create a new slice and copy remaining fields.
 	// To update fields you can rewrite entire slice.
 	//
 	// Fields can be nil.
@@ -32,6 +33,17 @@ type Entry struct {
 	SkippedCallerFrames int
 }
 
+// With creates a new entry with additional field.
+func (e Entry) With(field Field) Entry {
+	newLen := len(e.Fields) + 1
+	fields := make([]Field, newLen)
+	copy(fields, e.Fields)
+	e.Fields = fields
+	e.Fields[newLen-1] = field
+
+	return e
+}
+
 // Level is a severity level of message. Use Level.MoreSevereThan to compare two levels.
 type Level int8
 

logger/global.go

@@ -94,8 +94,7 @@ func (g *Global) Error(ctx context.Context, msg string) {
 
 // With creates a new child logger with field.
 func (g *Global) With(key string, value interface{}) *Global {
-	newEntry := g.entry
-	newEntry.Fields = append(newEntry.Fields, Field{Key: key, Value: value})
+	newEntry := g.entry.With(Field{Key: key, Value: value})
 
 	return &Global{
 		entry:       newEntry,

logger/logger.go

@@ -59,7 +59,7 @@ func (l Logger) Error(ctx context.Context, msg string) {
 
 // With creates a new logger with field.
 func (l Logger) With(key string, value interface{}) Logger {
-	l.entry.Fields = append(l.entry.Fields, Field{Key: key, Value: value})
+	l.entry = l.entry.With(Field{key, value})
 
 	return l
 }

logger/logger_test.go

@@ -311,6 +311,29 @@ func TestWithError(t *testing.T) {
 	}
 }
 
+func TestEntry_With(t *testing.T) {
+	field1 := logger.Field{Key: "k1", Value: "v1"}
+	field2 := logger.Field{Key: "k2", Value: "v2"}
+
+	t.Run("should add field to empty entry", func(t *testing.T) {
+		entry := logger.Entry{}
+		newEntry := entry.With(field1)
+		assert.Empty(t, entry.Fields)
+		require.Len(t, newEntry.Fields, 1)
+		assert.Equal(t, newEntry.Fields[0], field1)
+	})
+
+	t.Run("should add field to entry with one field", func(t *testing.T) {
+		entry := logger.Entry{}.With(field1)
+		newEntry := entry.With(field2)
+		require.Len(t, entry.Fields, 1)
+		require.Len(t, newEntry.Fields, 2)
+		assert.Equal(t, entry.Fields[0], field1)
+		assert.Equal(t, newEntry.Fields[0], field1)
+		assert.Equal(t, newEntry.Fields[1], field2)
+	})
+}
+
 func TestLevel_MoreSevereThan(t *testing.T) {
 	t.Run("should return true", func(t *testing.T) {
 		assert.True(t, logger.InfoLevel.MoreSevereThan(logger.DebugLevel))