From c1562e7616c08449323fb8294e0233fd1b830d17 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 15:35:18 +0300
Subject: [PATCH 01/13] update name global log

---
 global.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/global.go b/global.go
index 74681ed..20fd171 100644
--- a/global.go
+++ b/global.go
@@ -209,7 +209,7 @@ func Noticef(ctx context.Context, format string, args ...any) {
 
 // Infof log by info level by format and arguments.
 func Infof(ctx context.Context, format string, args ...any) {
-	global.Noticef(ctx, format, args...)
+	global.Infof(ctx, format, args...)
 }
 
 // Debugf log by debug level by format and arguments.

From fa6615fd245b11e7f5a961949ef3879ba71adeea Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 16:11:14 +0300
Subject: [PATCH 02/13] update replace field

---
 entry/entry.go       | 13 +------------
 entry/entry_test.go  | 42 ++++++++++++++++++++++++++++++++++++++++++
 field/field.go       |  7 +++++++
 field/fields.go      | 13 +++++++++++++
 field/fields_test.go | 19 +++++++++++++++++++
 5 files changed, 82 insertions(+), 12 deletions(-)
 create mode 100644 entry/entry_test.go

diff --git a/entry/entry.go b/entry/entry.go
index ef4f9b0..06c5bf8 100644
--- a/entry/entry.go
+++ b/entry/entry.go
@@ -163,18 +163,7 @@ func (e *Entry) AddString(key, value string) *Entry {
 }
 
 func (e *Entry) Replace(key string, value field.Value) *Entry {
-	has := false
-
-	e.fields.Fields(func(f field.Field) bool {
-		if f.Key == key {
-			f.Value = value
-			has = true
-
-			return false
-		}
-
-		return true
-	})
+	_, has := e.fields.Replace(field.Any(key, value))
 
 	if !has {
 		e.AddAny(key, value)
diff --git a/entry/entry_test.go b/entry/entry_test.go
new file mode 100644
index 0000000..478dc74
--- /dev/null
+++ b/entry/entry_test.go
@@ -0,0 +1,42 @@
+package entry_test
+
+import (
+	"testing"
+	"time"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+)
+
+func TestEntry_Replace(t *testing.T) {
+	t.Parallel()
+
+	ent := entry.New(entry.WithFields(
+		field.Any("inti", "init date"),
+	))
+
+	ent = ent.Replace("date", field.StringValue("some date"))
+	ent = ent.Replace("date", field.TimeValue(time.Time{}))
+
+	fields := ent.Fields()
+
+	if len(fields) != 2 {
+		t.Fatalf("count must be 2 got %v", len(fields))
+	}
+
+	var has bool
+
+	fields.Fields(func(f field.Field) bool {
+		if f.Key == "date" && !f.Value.AsTime().IsZero() {
+			has = true
+
+			return false
+		}
+
+		return true
+	})
+
+	if !has {
+		t.Fatal("failed reace value")
+	}
+}
diff --git a/field/field.go b/field/field.go
index 51a56f0..032348a 100644
--- a/field/field.go
+++ b/field/field.go
@@ -6,6 +6,13 @@ import (
 	"time"
 )
 
+//nolint:gochecknoglobals
+var empty Field
+
+func Empty() Field {
+	return empty
+}
+
 func Any(key string, value any) Field {
 	return Field{
 		Key:   key,
diff --git a/field/fields.go b/field/fields.go
index 60ac5b5..3a1c212 100644
--- a/field/fields.go
+++ b/field/fields.go
@@ -32,3 +32,16 @@ func (f Fields) Set(idx int, field Field) {
 func (f Fields) Len() int {
 	return len(f)
 }
+
+func (f Fields) Replace(field Field) (Field, bool) {
+	for idx := range f {
+		if f[idx].Key == field.Key {
+			old := f[idx]
+			f[idx] = field
+
+			return old, true
+		}
+	}
+
+	return Empty(), false
+}
diff --git a/field/fields_test.go b/field/fields_test.go
index 04c0a0c..c8a2eca 100644
--- a/field/fields_test.go
+++ b/field/fields_test.go
@@ -16,3 +16,22 @@ func TestFields_Append(t *testing.T) {
 		t.Fatalf("require 2 field got %v", len(fields))
 	}
 }
+
+func TestFields_Replace(t *testing.T) {
+	t.Parallel()
+
+	fields := field.Fields{
+		field.Any("any", "any init"),
+		field.Any("replace", "replace init"),
+	}
+
+	old, ok := fields.Replace(field.Int64("replace", 42))
+	if !ok || old.Key != "replace" || old.Value != field.StringValue("replace init") {
+		t.Fatalf("failed replace value:%v", old)
+	}
+
+	o2, ok2 := fields.Replace(field.Any("new", "new data"))
+	if ok2 || o2.Key != "" {
+		t.Fatalf("failed set new data:%v", o2)
+	}
+}

From 2708104774d12afe9fd19afdd7f97e2b4877c751 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 16:38:03 +0300
Subject: [PATCH 03/13] update write kvs

---
 logger.go | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/logger.go b/logger.go
index 26895a3..f6c7f3f 100644
--- a/logger.go
+++ b/logger.go
@@ -105,42 +105,42 @@ func (l Logger) Panicln(args ...any) {
 
 // EmergKVs sugared log by emergency level and key-values.
 func (l Logger) EmergKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Emergency, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Emergency, msg, args))
 }
 
 // AlertKVs sugared log by alert level and key-values.
 func (l Logger) AlertKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Alert, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Alert, msg, args))
 }
 
 // CritKVs sugared log by critcal level and key-values.
 func (l Logger) CritKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Critical, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Critical, msg, args))
 }
 
 // ErrKVs sugared log by error level and key-values.
 func (l Logger) ErrKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Error, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Error, msg, args))
 }
 
 // WarnKVs sugared log by warning level and key-values.
 func (l Logger) WarnKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Warning, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Warning, msg, args))
 }
 
 // NoticeKVs sugared log by notice level and key-values.
 func (l Logger) NoticeKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Notice, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Notice, msg, args))
 }
 
 // InfoKVs sugared log by info level and key-values.
 func (l Logger) InfoKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Info, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Info, msg, args))
 }
 
 // DebugKVs sugared log by debug level and key-values.
 func (l Logger) DebugKVs(ctx context.Context, msg string, args ...any) {
-	writeOutput(l.write(ctx, level.Debug, msg, l.kv(ctx, args...)...))
+	writeOutput(l.writekvs(ctx, level.Debug, msg, args))
 }
 
 // EmergKV log by emergency level and key-values.
@@ -247,38 +247,39 @@ func (l Logger) Writer(ctx context.Context, level level.Level, fields ...field.F
 	}
 }
 
-func (l Logger) kv(_ context.Context, args ...any) field.Fields {
-	kvEntry := entry.Get()
+func (l Logger) writekvs(ctx context.Context, lvl level.Level, mst string, args []any) (int, error) {
+	data := entry.Get()
+	data = data.SetMessage(mst).SetLevel(lvl)
 
 	defer func() {
-		entry.Put(kvEntry)
+		entry.Put(data)
 	}()
 
 	for i := 0; i < len(args); i++ {
 		if f, ok := args[i].(field.Field); ok {
-			kvEntry = kvEntry.Add(f)
+			data = data.Add(f)
 
 			continue
 		}
 
 		if i == len(args)-1 {
-			kvEntry = kvEntry.AddAny(badKey, args[i])
+			data = data.AddAny(badKey, args[i])
 
 			break
 		}
 
 		key, val := args[i], args[i+1]
 		if keyStr, ok := key.(string); ok {
-			kvEntry = kvEntry.AddAny(keyStr, val)
+			data = data.AddAny(keyStr, val)
 			i++
 
 			continue
 		}
 
-		kvEntry = kvEntry.AddAny(badKey, args[i])
+		data = data.AddAny(badKey, args[i])
 	}
 
-	return kvEntry.Fields()
+	return l(ctx, data)
 }
 
 func (l Logger) write(ctx context.Context, level level.Level, msg string, fields ...field.Field) (int, error) {

From 811b78e1d2d951caf1d116accfee4d5e85664410 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 16:43:35 +0300
Subject: [PATCH 04/13] update unmarshal text

---
 field/kind.go | 38 +++++++++++++++++++++++++++++++++++---
 1 file changed, 35 insertions(+), 3 deletions(-)

diff --git a/field/kind.go b/field/kind.go
index 4dbee69..d07e44c 100644
--- a/field/kind.go
+++ b/field/kind.go
@@ -37,44 +37,76 @@ func (l Kind) MarshalText() ([]byte, error) {
 	return []byte(l.String()), nil
 }
 
-//nolint:gocyclo,cyclop
+//nolint:gocyclo,cyclop,funlen
 func (l *Kind) UnmarshalText(in []byte) error {
 	switch string(in) {
 	case KindAny.String():
 		*l = KindAny
+
+		return nil
 	case KindArray.String():
 		*l = KindArray
+
+		return nil
 	case KindNil.String():
 		*l = KindNil
+
+		return nil
 	case KindString.String():
 		*l = KindString
+
+		return nil
 	case KindBool.String():
 		*l = KindBool
+
+		return nil
 	case KindInt64.String():
 		*l = KindInt64
+
+		return nil
 	case KindUint64.String():
 		*l = KindUint64
+
+		return nil
 	case KindFloat32.String():
 		*l = KindFloat32
+
+		return nil
 	case KindFloat64.String():
 		*l = KindFloat64
+
+		return nil
 	case KindComplex128.String():
 		*l = KindComplex128
+
+		return nil
 	case KindBinary.String():
 		*l = KindBinary
+
+		return nil
 	case KindDuration.String():
 		*l = KindDuration
+
+		return nil
 	case KindTime.String():
 		*l = KindTime
+
+		return nil
 	case KindError.String():
 		*l = KindError
+
+		return nil
 	case KindGroup.String():
 		*l = KindGroup
+
+		return nil
 	case KindClosure.String():
 		*l = KindClosure
-	}
 
-	return fmt.Errorf("%w:filed(%v)", ErrUndefined, string(in))
+		return nil
+	default:
+		return fmt.Errorf("%w:filed(%v)", ErrUndefined, string(in))
+	}
 }
 
 func (l Kind) MarshalBinary() ([]byte, error) {

From 079ffa4a5fbff7862e488eeb4a012e8c2e739250 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 16:46:24 +0300
Subject: [PATCH 05/13] update parse level

---
 level/level.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/level/level.go b/level/level.go
index 883aa7d..453fe21 100644
--- a/level/level.go
+++ b/level/level.go
@@ -75,19 +75,19 @@ func (l *Level) UnmarshalBinary(in []byte) error {
 
 func Parse(lvl string) Level {
 	switch strings.ToLower(lvl) {
-	case "debug", "Debug", "DEBUG":
+	case "debug":
 		return Debug
-	case "info", "Info", "INFO":
+	case "info":
 		return Info
-	case "notice", "Notice", "NOTICE":
+	case "notice":
 		return Notice
-	case "warning", "Warning", "WARNING", "warm", "Warm", "WARN":
+	case "warning", "warn":
 		return Warning
-	case "error", "Error", "ERROR", "err", "Err", "ERR":
+	case "error", "err":
 		return Error
-	case "critical", "Critical", "CRITICAL", "crit", "Crit", "CRIT":
+	case "critical", "crit":
 		return Critical
-	case "alert", "Alert", "ALERT":
+	case "alert":
 		return Alert
 	default:
 		return Emergency

From eb1c583207a75dc3e36c43ed8d1b6d2de4bd0750 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 17:07:21 +0300
Subject: [PATCH 06/13] update middleware

---
 middleware.go | 26 +++++++++-----------------
 1 file changed, 9 insertions(+), 17 deletions(-)

diff --git a/middleware.go b/middleware.go
index 3b023cf..0a27a67 100644
--- a/middleware.go
+++ b/middleware.go
@@ -17,7 +17,9 @@ type Middleware func(ctx context.Context, e *entry.Entry, handler Logger) (int,
 
 // With add middleware to logger.
 func With(logger Logger, mw ...Middleware) Logger {
-	switch len(mw) {
+	num := len(mw)
+
+	switch num {
 	case 0:
 		return logger
 	case 1:
@@ -26,27 +28,17 @@ func With(logger Logger, mw ...Middleware) Logger {
 		}
 	}
 
-	lastI := len(mw) - 1
-
 	return func(ctx context.Context, data *entry.Entry) (int, error) {
-		var (
-			chainHandler func(context.Context, *entry.Entry) (int, error)
-			curI         int
-		)
+		currHandler := logger
 
-		chainHandler = func(currentCtx context.Context, currentEntry *entry.Entry) (int, error) {
-			if curI == lastI {
-				return logger(currentCtx, currentEntry)
+		for i := num - 1; i > 0; i-- {
+			innerHandler := currHandler
+			currHandler = func(currentCtx context.Context, currentEntry *entry.Entry) (int, error) {
+				return mw[i](currentCtx, currentEntry, innerHandler)
 			}
-
-			curI++
-			n, err := mw[curI](currentCtx, currentEntry, chainHandler)
-			curI--
-
-			return n, err
 		}
 
-		return mw[0](ctx, data, chainHandler)
+		return mw[0](ctx, data, currHandler)
 	}
 }
 

From c528d9fc22d0a7c42ef627babd268c6fdc1eecbe Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 17:23:58 +0300
Subject: [PATCH 07/13] update marshal source

---
 source.go      |  2 +-
 source_test.go | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)
 create mode 100644 source_test.go

diff --git a/source.go b/source.go
index 3acf6b8..94b7ee5 100644
--- a/source.go
+++ b/source.go
@@ -86,7 +86,7 @@ func (l Source) MarshalText() ([]byte, error) {
 }
 
 func (l Source) MarshalJSON() ([]byte, error) {
-	return fmt.Appendf([]byte{}, `{"file":"%s","line":%d,"func":"%s"}`, l.File, l.Line, l.Func), nil
+	return fmt.Appendf([]byte{}, `{"file":%q,"line":%d,"func":"%s"}`, l.File, l.Line, l.Func), nil
 }
 
 func errSourceField(skip, mframe int) field.Field {
diff --git a/source_test.go b/source_test.go
new file mode 100644
index 0000000..8587184
--- /dev/null
+++ b/source_test.go
@@ -0,0 +1,23 @@
+package log_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gitoa.ru/go-4devs/log"
+)
+
+func TestSource_MarshalJSON(t *testing.T) {
+	t.Parallel()
+
+	src := log.Source{
+		Func: "fn name",
+		File: `file " \n name`,
+		Line: 42,
+	}
+
+	data, err := json.Marshal(src)
+	if err != nil || len(data) == 0 || string(data) != `{"file":"file \" \\n name","line":42,"func":"fn name"}` {
+		t.Fatalf("failed marshal: err=%v, data=%v", err, string(data))
+	}
+}

From 3bcd00e54dd63584d291eaec1d374ca4f7d8b2b7 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 17:33:45 +0300
Subject: [PATCH 08/13] update encode err

---
 field/encoder.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/field/encoder.go b/field/encoder.go
index ae1a8db..968705a 100644
--- a/field/encoder.go
+++ b/field/encoder.go
@@ -269,7 +269,12 @@ func (b BaseEncoder) appendValue(dst []byte, val Value, prefix string, deli byte
 	case KindUint64:
 		return b.AppendUint(b.AppendDelimiter(dst, deli), val.AsUint64())
 	case KindError:
-		return b.AppendString(b.AppendDelimiter(dst, deli), val.AsError().Error())
+		var errData string
+		if err := val.AsError(); err != nil {
+			errData = err.Error()
+		}
+
+		return b.AppendString(b.AppendDelimiter(dst, deli), errData)
 	case KindString:
 		return b.AppendString(b.AppendDelimiter(dst, deli), val.AsString())
 	case KindDuration:

From 5b7f4e63cc1447b41506d9dbdcb2dfc18b281e10 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 17:50:10 +0300
Subject: [PATCH 09/13] update typo

---
 field/encoder.go         | 2 +-
 field/encoder_text.go    | 2 +-
 field/errors.go          | 2 +-
 field/field.go           | 2 +-
 global.go                | 4 ++--
 handler/logrus/logger.go | 2 +-
 logger.go                | 4 ++--
 writter.go => writer.go  | 2 +-
 8 files changed, 10 insertions(+), 10 deletions(-)
 rename writter.go => writer.go (99%)

diff --git a/field/encoder.go b/field/encoder.go
index 968705a..34dfa1d 100644
--- a/field/encoder.go
+++ b/field/encoder.go
@@ -31,7 +31,7 @@ func WithDelimeter(in byte) func(*BaseEncoder) {
 	}
 }
 
-func WithGropuConfig(start, end, deli byte) func(*BaseEncoder) {
+func WithGroupConfig(start, end, deli byte) func(*BaseEncoder) {
 	return func(be *BaseEncoder) {
 		be.group = groupConfig{
 			start: start,
diff --git a/field/encoder_text.go b/field/encoder_text.go
index e3be369..9db54b8 100644
--- a/field/encoder_text.go
+++ b/field/encoder_text.go
@@ -7,7 +7,7 @@ import (
 
 func NewEncoderText(opts ...func(*BaseEncoder)) BaseEncoder {
 	opts = append([]func(*BaseEncoder){
-		WithGropuConfig(0, 0, ' '),
+		WithGroupConfig(0, 0, ' '),
 		WithNullValue("<nil>"),
 		WithDefaultValue(func(dst []byte, enc Encoder, val Value) []byte {
 			switch value := val.Any().(type) {
diff --git a/field/errors.go b/field/errors.go
index a00ddde..bd30737 100644
--- a/field/errors.go
+++ b/field/errors.go
@@ -2,4 +2,4 @@ package field
 
 import "errors"
 
-var ErrUndefined = errors.New("indefined")
+var ErrUndefined = errors.New("undefined")
diff --git a/field/field.go b/field/field.go
index 032348a..33ddeac 100644
--- a/field/field.go
+++ b/field/field.go
@@ -505,7 +505,7 @@ type Field struct {
 	Value Value
 }
 
-// String implent stringer.
+// String implement stringer.
 func (f Field) String() string {
 	return fmt.Sprintf("%s=%+v", f.Key, f.Value)
 }
diff --git a/global.go b/global.go
index 20fd171..f196e49 100644
--- a/global.go
+++ b/global.go
@@ -107,7 +107,7 @@ func AlertKVs(ctx context.Context, msg string, args ...any) {
 	global.AlertKVs(ctx, msg, args...)
 }
 
-// CritKVs sugared log by critcal level and key-values.
+// CritKVs sugared log by critical level and key-values.
 func CritKVs(ctx context.Context, msg string, args ...any) {
 	global.CritKVs(ctx, msg, args...)
 }
@@ -147,7 +147,7 @@ func AlertKV(ctx context.Context, msg string, args ...field.Field) {
 	global.AlertKV(ctx, msg, args...)
 }
 
-// CritKV log by critcal level and key-values.
+// CritKV log by critical level and key-values.
 func CritKV(ctx context.Context, msg string, args ...field.Field) {
 	global.CritKV(ctx, msg, args...)
 }
diff --git a/handler/logrus/logger.go b/handler/logrus/logger.go
index c042793..8466c4f 100644
--- a/handler/logrus/logger.go
+++ b/handler/logrus/logger.go
@@ -10,7 +10,7 @@ import (
 	"gitoa.ru/go-4devs/log/level"
 )
 
-// Standard create new standart logrus handler.
+// Standard create new standard logrus handler.
 // Deprecated: delete after 0.7.0
 func Standard() log.Logger {
 	return New(logrus.StandardLogger())
diff --git a/logger.go b/logger.go
index f6c7f3f..a8548da 100644
--- a/logger.go
+++ b/logger.go
@@ -113,7 +113,7 @@ func (l Logger) AlertKVs(ctx context.Context, msg string, args ...any) {
 	writeOutput(l.writekvs(ctx, level.Alert, msg, args))
 }
 
-// CritKVs sugared log by critcal level and key-values.
+// CritKVs sugared log by critical level and key-values.
 func (l Logger) CritKVs(ctx context.Context, msg string, args ...any) {
 	writeOutput(l.writekvs(ctx, level.Critical, msg, args))
 }
@@ -153,7 +153,7 @@ func (l Logger) AlertKV(ctx context.Context, msg string, args ...field.Field) {
 	writeOutput(l.write(ctx, level.Alert, msg, args...))
 }
 
-// CritKV log by critcal level and key-values.
+// CritKV log by critical level and key-values.
 func (l Logger) CritKV(ctx context.Context, msg string, args ...field.Field) {
 	writeOutput(l.write(ctx, level.Critical, msg, args...))
 }
diff --git a/writter.go b/writer.go
similarity index 99%
rename from writter.go
rename to writer.go
index 44d3835..105ebaf 100644
--- a/writter.go
+++ b/writer.go
@@ -63,7 +63,7 @@ type option struct {
 	out    io.Writer
 }
 
-// New creates standart logger.
+// New creates standard logger.
 func New(opts ...func(*option)) Logger {
 	log := option{
 		format: FormatString(field.NewEncoderText()),

From e715c43e14116bb83204e690011b8a9bc72c2f52 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 17:58:26 +0300
Subject: [PATCH 10/13] add bc method name

---
 field/encoder.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/field/encoder.go b/field/encoder.go
index 34dfa1d..02f397e 100644
--- a/field/encoder.go
+++ b/field/encoder.go
@@ -31,6 +31,13 @@ func WithDelimeter(in byte) func(*BaseEncoder) {
 	}
 }
 
+// WithGropuConfig set group config.
+//
+// Deprecated: use WithGroupConfig.
+func WithGropuConfig(start, end, deli byte) func(*BaseEncoder) {
+	return WithGroupConfig(start, end, deli)
+}
+
 func WithGroupConfig(start, end, deli byte) func(*BaseEncoder) {
 	return func(be *BaseEncoder) {
 		be.group = groupConfig{

From 4f7d56f4a6e61c848065f5d77204fcad08174565 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 18:11:15 +0300
Subject: [PATCH 11/13] update use default logger

---
 global.go | 84 +++++++++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/global.go b/global.go
index f196e49..88b1422 100644
--- a/global.go
+++ b/global.go
@@ -29,209 +29,209 @@ func Log() Logger {
 
 // Emerg log by emergency level.
 func Emerg(ctx context.Context, args ...any) {
-	global.Emerg(ctx, args...)
+	Log().Emerg(ctx, args...)
 }
 
 // Alert log by alert level.
 func Alert(ctx context.Context, args ...any) {
-	global.Alert(ctx, args...)
+	Log().Alert(ctx, args...)
 }
 
 // Crit log by critical level.
 func Crit(ctx context.Context, args ...any) {
-	global.Crit(ctx, args...)
+	Log().Crit(ctx, args...)
 }
 
 // Err log by error level.
 func Err(ctx context.Context, args ...any) {
-	global.Err(ctx, args...)
+	Log().Err(ctx, args...)
 }
 
 // Warn logs by warning level.
 func Warn(ctx context.Context, args ...any) {
-	global.Warn(ctx, args...)
+	Log().Warn(ctx, args...)
 }
 
 // Notice log by notice level.
 func Notice(ctx context.Context, args ...any) {
-	global.Notice(ctx, args...)
+	Log().Notice(ctx, args...)
 }
 
 // Info log by info level.
 func Info(ctx context.Context, args ...any) {
-	global.Info(ctx, args...)
+	Log().Info(ctx, args...)
 }
 
 // Debug log by debug level.
 func Debug(ctx context.Context, args ...any) {
-	global.Debug(ctx, args...)
+	Log().Debug(ctx, args...)
 }
 
 // Print log by info level and arguments.
 func Print(args ...any) {
-	global.Print(args...)
+	Log().Print(args...)
 }
 
 // Fatal log by alert level and arguments.
 func Fatal(args ...any) {
-	global.Fatal(args...)
+	Log().Fatal(args...)
 }
 
 // Panic log by emergency level and arguments.
 func Panic(args ...any) {
-	global.Panic(args...)
+	Log().Panic(args...)
 }
 
 // Println log by info level and arguments.
 func Println(args ...any) {
-	global.Println(args...)
+	Log().Println(args...)
 }
 
 // Fatalln log by alert level and arguments.
 func Fatalln(args ...any) {
-	global.Fatalln(args...)
+	Log().Fatalln(args...)
 }
 
 // Panicln log by emergency level and arguments.
 func Panicln(args ...any) {
-	global.Panicln(args...)
+	Log().Panicln(args...)
 }
 
 // EmergKVs sugared log by emergency level and key-values.
 func EmergKVs(ctx context.Context, msg string, args ...any) {
-	global.EmergKVs(ctx, msg, args...)
+	Log().EmergKVs(ctx, msg, args...)
 }
 
 // AlertKVs sugared log by alert level and key-values.
 func AlertKVs(ctx context.Context, msg string, args ...any) {
-	global.AlertKVs(ctx, msg, args...)
+	Log().AlertKVs(ctx, msg, args...)
 }
 
 // CritKVs sugared log by critical level and key-values.
 func CritKVs(ctx context.Context, msg string, args ...any) {
-	global.CritKVs(ctx, msg, args...)
+	Log().CritKVs(ctx, msg, args...)
 }
 
 // ErrKVs sugared log by error level and key-values.
 func ErrKVs(ctx context.Context, msg string, args ...any) {
-	global.ErrKVs(ctx, msg, args...)
+	Log().ErrKVs(ctx, msg, args...)
 }
 
 // WarnKVs sugared log by warning level and key-values.
 func WarnKVs(ctx context.Context, msg string, args ...any) {
-	global.WarnKVs(ctx, msg, args...)
+	Log().WarnKVs(ctx, msg, args...)
 }
 
 // NoticeKVs sugared log by notice level and key-values.
 func NoticeKVs(ctx context.Context, msg string, args ...any) {
-	global.NoticeKVs(ctx, msg, args...)
+	Log().NoticeKVs(ctx, msg, args...)
 }
 
 // InfoKVs sugared log by info level and key-values.
 func InfoKVs(ctx context.Context, msg string, args ...any) {
-	global.InfoKVs(ctx, msg, args...)
+	Log().InfoKVs(ctx, msg, args...)
 }
 
 // DebugKVs sugared log by debug level and key-values.
 func DebugKVs(ctx context.Context, msg string, args ...any) {
-	global.DebugKVs(ctx, msg, args...)
+	Log().DebugKVs(ctx, msg, args...)
 }
 
 // EmergKV  log by emergency level and key-values.
 func EmergKV(ctx context.Context, msg string, args ...field.Field) {
-	global.EmergKV(ctx, msg, args...)
+	Log().EmergKV(ctx, msg, args...)
 }
 
 // AlertKV log by alert level and key-values.
 func AlertKV(ctx context.Context, msg string, args ...field.Field) {
-	global.AlertKV(ctx, msg, args...)
+	Log().AlertKV(ctx, msg, args...)
 }
 
 // CritKV log by critical level and key-values.
 func CritKV(ctx context.Context, msg string, args ...field.Field) {
-	global.CritKV(ctx, msg, args...)
+	Log().CritKV(ctx, msg, args...)
 }
 
 // ErrKV log by error level and key-values.
 func ErrKV(ctx context.Context, msg string, args ...field.Field) {
-	global.ErrKV(ctx, msg, args...)
+	Log().ErrKV(ctx, msg, args...)
 }
 
 // WarnKV log by warning level and key-values.
 func WarnKV(ctx context.Context, msg string, args ...field.Field) {
-	global.WarnKV(ctx, msg, args...)
+	Log().WarnKV(ctx, msg, args...)
 }
 
 // NoticeKV log by notice level and key-values.
 func NoticeKV(ctx context.Context, msg string, args ...field.Field) {
-	global.NoticeKV(ctx, msg, args...)
+	Log().NoticeKV(ctx, msg, args...)
 }
 
 // InfoKV log by info level and key-values.
 func InfoKV(ctx context.Context, msg string, args ...field.Field) {
-	global.InfoKV(ctx, msg, args...)
+	Log().InfoKV(ctx, msg, args...)
 }
 
 // DebugKV log by debug level and key-values.
 func DebugKV(ctx context.Context, msg string, args ...field.Field) {
-	global.DebugKV(ctx, msg, args...)
+	Log().DebugKV(ctx, msg, args...)
 }
 
 // Emergf log by emergency level by format and arguments.
 func Emergf(ctx context.Context, format string, args ...any) {
-	global.Emergf(ctx, format, args...)
+	Log().Emergf(ctx, format, args...)
 }
 
 // Alertf log by alert level by format and arguments.
 func Alertf(ctx context.Context, format string, args ...any) {
-	global.Alertf(ctx, format, args...)
+	Log().Alertf(ctx, format, args...)
 }
 
 // Critf log by critical level by format and arguments.
 func Critf(ctx context.Context, format string, args ...any) {
-	global.Critf(ctx, format, args...)
+	Log().Critf(ctx, format, args...)
 }
 
 // Errf log by error level by format and arguments.
 func Errf(ctx context.Context, format string, args ...any) {
-	global.Errf(ctx, format, args...)
+	Log().Errf(ctx, format, args...)
 }
 
 // Warnf log by warning level by format and arguments.
 func Warnf(ctx context.Context, format string, args ...any) {
-	global.Warnf(ctx, format, args...)
+	Log().Warnf(ctx, format, args...)
 }
 
 // Noticef log by notice level by format and arguments.
 func Noticef(ctx context.Context, format string, args ...any) {
-	global.Noticef(ctx, format, args...)
+	Log().Noticef(ctx, format, args...)
 }
 
 // Infof log by info level by format and arguments.
 func Infof(ctx context.Context, format string, args ...any) {
-	global.Infof(ctx, format, args...)
+	Log().Infof(ctx, format, args...)
 }
 
 // Debugf log by debug level by format and arguments.
 func Debugf(ctx context.Context, format string, args ...any) {
-	global.Debugf(ctx, format, args...)
+	Log().Debugf(ctx, format, args...)
 }
 
 // Printf log by info level by format and arguments without context.
 func Printf(format string, args ...any) {
-	global.Printf(format, args...)
+	Log().Printf(format, args...)
 }
 
 // Fatalf log by alert level by format and arguments without context.
 func Fatalf(format string, args ...any) {
-	global.Fatalf(format, args...)
+	Log().Fatalf(format, args...)
 }
 
 // Panicf log by emergency level and arguments without context.
 func Panicf(format string, args ...any) {
-	global.Panicf(format, args...)
+	Log().Panicf(format, args...)
 }
 
 func Writer(ctx context.Context, level level.Level) io.Writer {
-	return global.Writer(ctx, level)
+	return Log().Writer(ctx, level)
 }

From b98f4514af31e80852f2fa41f25ea805dfac3168 Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 18:31:48 +0300
Subject: [PATCH 12/13] update mw source

---
 source.go | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/source.go b/source.go
index 94b7ee5..8874445 100644
--- a/source.go
+++ b/source.go
@@ -11,14 +11,21 @@ import (
 	"gitoa.ru/go-4devs/log/field"
 )
 
+const funcName = "Logger"
+
 func WithSource(items int, trimPath func(string) string) Middleware {
 	const (
-		skip       = 4
-		funcPrefix = "gitoa.ru/go-4devs/log.Logger"
-		skipHelper = "gitoa.ru/go-4devs/log."
+		skip    = 4
+		pkgName = "gitoa.ru/go-4devs/log"
 	)
 
+	return WithCallers(items, skip, pkgName, trimPath)
+}
+
+func WithCallers(items, skip int, logPkg string, trimPath func(string) string) Middleware {
 	items += skip
+	skipHelper := logPkg + "."
+	funcPrefix := skipHelper + funcName
 
 	return func(ctx context.Context, data *entry.Entry, handler Logger) (int, error) {
 		pc := make([]uintptr, items)

From 079d40b48f4f0be17750e85edde1dc198b6a892a Mon Sep 17 00:00:00 2001
From: andrey <andrey@4devs.io>
Date: Mon, 2 Mar 2026 18:48:41 +0300
Subject: [PATCH 13/13] update linter

---
 .gitea/workflows/goaction.yml |  2 +-
 .golangci.yml                 | 10 +---------
 field/encoder.go              |  2 +-
 field/kind.go                 |  2 +-
 field/value.go                |  2 +-
 logger_test.go                |  6 ++++--
 6 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/.gitea/workflows/goaction.yml b/.gitea/workflows/goaction.yml
index 7f7abe9..88cab2a 100644
--- a/.gitea/workflows/goaction.yml
+++ b/.gitea/workflows/goaction.yml
@@ -17,7 +17,7 @@ jobs:
       - name: Run golangci-lint
         uses: golangci/golangci-lint-action@v8 # Use the golangci-lint action
         with:
-          version: v2.7.2 # Specify the linter version
+          version: v2.10.1 # Specify the linter version
           # Optional: additional arguments
           args: --verbose
 
diff --git a/.golangci.yml b/.golangci.yml
index ce6313f..22c7103 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -4,6 +4,7 @@ linters:
   disable:
     - wsl
     - noinlineerr
+    - revive
   settings:
     depguard:
       rules:
@@ -21,20 +22,11 @@ linters:
         - "*.UnmarshalText" 
         - "*.UnmarshalJSON"
         - "*.UnmarshalBinary"
-    dupl:
-      threshold: 100
     exhaustive:
       default-signifies-exhaustive: true
     funlen:
       lines: 100
       statements: 50
-    goconst:
-      min-len: 2
-      min-occurrences: 2
-    gocyclo:
-      min-complexity: 15
-    lll:
-      line-length: 140
     misspell:
       locale: US
     tagliatelle:
diff --git a/field/encoder.go b/field/encoder.go
index 02f397e..78ddf5d 100644
--- a/field/encoder.go
+++ b/field/encoder.go
@@ -250,7 +250,7 @@ func (b BaseEncoder) appendField(dst []byte, field Field, prefix string, deli by
 	return b.appendValue(dst, field.Value, field.Key+".", deli)
 }
 
-//nolint:mnd,gocyclo,cyclop
+//nolint:mnd,cyclop
 func (b BaseEncoder) appendValue(dst []byte, val Value, prefix string, deli byte) []byte {
 	switch val.Kind {
 	case KindGroup:
diff --git a/field/kind.go b/field/kind.go
index d07e44c..a97c52b 100644
--- a/field/kind.go
+++ b/field/kind.go
@@ -37,7 +37,7 @@ func (l Kind) MarshalText() ([]byte, error) {
 	return []byte(l.String()), nil
 }
 
-//nolint:gocyclo,cyclop,funlen
+//nolint:cyclop,funlen
 func (l *Kind) UnmarshalText(in []byte) error {
 	switch string(in) {
 	case KindAny.String():
diff --git a/field/value.go b/field/value.go
index 0cd3801..9f72819 100644
--- a/field/value.go
+++ b/field/value.go
@@ -469,7 +469,7 @@ func (v Value) String() string {
 	return string(v.append(buf))
 }
 
-//nolint:gocyclo,cyclop
+//nolint:cyclop
 func (v Value) Any() any {
 	switch v.Kind {
 	case KindAny, KindBinary:
diff --git a/logger_test.go b/logger_test.go
index 950aab2..ba5756f 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -28,7 +28,8 @@ func TestFields(t *testing.T) {
 	buf := &bytes.Buffer{}
 	log := log.New(log.WithWriter(buf)).
 		With(log.WithLevel(log.KeyLevel, level.Info))
-	success := "msg=message err=\"file already exists\" version=0.1.0 obj={id:uid} closure=\"some closure data\" level=info\n"
+	success := "msg=message err=\"file already exists\"" +
+		" version=0.1.0 obj={id:uid} closure=\"some closure data\" level=info\n"
 
 	log.InfoKVs(ctx, "message",
 		"err", os.ErrExist,
@@ -63,7 +64,8 @@ func TestWriter(t *testing.T) {
 
 	ctx := context.Background()
 
-	success := "msg=\"info message\" err=\"file already exists\" requestID=6a5fa048-7181-11ea-bc55-0242ac1311113 level=info\n"
+	success := "msg=\"info message\" err=\"file already exists\"" +
+		" requestID=6a5fa048-7181-11ea-bc55-0242ac1311113 level=info\n"
 	buf := &bytes.Buffer{}
 	logger := log.New(log.WithWriter(buf)).With(log.WithContextValue(requestID), log.WithLevel(log.KeyLevel, level.Info))