Merge pull request 'update ling and go version' (#17) from format into master

Reviewed-on: #17

.drone.yml

@@ -1,9 +1,11 @@
+---
 kind: pipeline
-name: default
+type: docker
+name: logger
 
 steps:
 - name: test 
-  image: golang:1.21.5
+  image: golang:1.22.2
   volumes:
   - name: deps
     path: /go/src/mod
@@ -11,7 +13,7 @@ steps:
   - go test 
 
 - name: golangci-lint
-  image: golangci/golangci-lint:v1.55
+  image: golangci/golangci-lint:v1.57
   commands:
   - golangci-lint run
 

.golangci.yml

@@ -1,3 +1,6 @@
+run:
+  timeout: 5m
+
 linters-settings:
     dupl:
       threshold: 100
@@ -52,6 +55,7 @@ linters:
       - maligned
 
       - depguard # need configure
+      - nolintlint # use with space
 
 issues:
   # Excluding configuration per-path, per-linter, per-text and per-source
@@ -66,3 +70,7 @@ issues:
       linters:
         - lll
         - goerr113
+    - path: example/*
+      linters:
+        - gomnd
+        - lll

bench_test.go

@@ -166,7 +166,9 @@ func BenchmarkDisabledAccumulatedContext(b *testing.B) {
 
 	b.Run("4devs/log.Context", func(b *testing.B) {
 		b.ResetTimer()
+
 		logger := NewLogger().With(log.GoVersion("goversion"))
+
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
 				logger.InfoKV(ctx, getMessage(0), fakeFields()...)

entry/entry.go

@@ -161,3 +161,24 @@ func (e *Entry) AddAny(key string, value interface{}) *Entry {
 func (e *Entry) AddString(key, value string) *Entry {
 	return e.Add(field.String(key, value))
 }
+
+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
+	})
+
+	if !has {
+		e.AddAny(key, value)
+	}
+
+	return e
+}

example/log.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/field"
+)
+
+func main() {
+	ctx := context.Background()
+
+	log.DebugKV(ctx, "debug message")
+	log.ErrKV(ctx, "error message")
+	log.Errf(ctx, "format error message:%v", 42)
+	log.Err(ctx, "error message", 42)
+	service(ctx, log.Log())
+
+	logger := log.New(log.WithJSONFormat()).With(log.WithSource(10, log.TrimPath), log.WithTime(log.KeyTime, time.RFC3339))
+	logger.AlertKV(ctx, "alert message new logger", field.String("string", "value"))
+	service(ctx, logger)
+
+	strLogger := log.New(log.WithFormat(log.FormatWithBracket(field.NewEncoderText()))).With(log.WithSource(10, log.TrimPath), log.WithTime(log.KeyTime, time.RFC3339))
+	strLogger.AlertKV(ctx, "alert message new txt logger", field.String("string", "value"))
+	service(ctx, strLogger)
+}
+
+func service(ctx context.Context, logger log.Logger) {
+	logger = logger.With(log.WithName("service"))
+	logger.WarnKV(ctx, "warn service message")
+	otherService(ctx, logger)
+}
+
+func otherService(ctx context.Context, logger log.Logger) {
+	logger = logger.With(log.WithName("other_service"))
+	logger.WarnKV(ctx, "warn other service message")
+}

field/encoder.go

@@ -174,6 +174,7 @@ func needsQuoting(in string) bool {
 			if char != '\\' && (char == ' ' || char == '=' || !safeSet[char]) {
 				return true
 			}
+
 			i++
 
 			continue

field/encoder_text.go

@@ -1,6 +1,7 @@
 package field
 
 import (
+	"encoding"
 	"fmt"
 )
 
@@ -8,8 +9,18 @@ func NewEncoderText(opts ...func(*BaseEncoder)) BaseEncoder {
 	opts = append([]func(*BaseEncoder){
 		WithGropuConfig(0, 0, ' '),
 		WithNullValue("<nil>"),
-		WithDefaultValue(func(dst []byte, _ Encoder, val Value) []byte {
+		WithDefaultValue(func(dst []byte, enc Encoder, val Value) []byte {
-			return fmt.Appendf(dst, "%+v", val.Any())
+			switch value := val.Any().(type) {
+			case encoding.TextMarshaler:
+				data, err := value.MarshalText()
+				if err != nil {
+					return enc.AppendValue(dst, ErrorValue(err))
+				}
+
+				return enc.AppendValue(dst, StringValue(string(data)))
+			default:
+				return fmt.Appendf(dst, "%+v", val.Any())
+			}
 		}),
 	}, opts...)
 

field/field.go

@@ -501,3 +501,14 @@ type Field struct {
 func (f Field) String() string {
 	return fmt.Sprintf("%s=%+v", f.Key, f.Value)
 }
+
+// String implent stringer.
+func (f Field) IsKey(keys ...string) bool {
+	for _, key := range keys {
+		if key == f.Key {
+			return true
+		}
+	}
+
+	return false
+}

field/value.go

@@ -1,4 +1,4 @@
-//nolint: exhaustruct
+// nolint: exhaustruct
 package field
 
 import (
@@ -504,7 +504,7 @@ func (v Value) append(dst []byte) []byte {
 	}
 }
 
-//nolint: gocyclo,cyclop
+// nolint: gocyclo,cyclop
 func (v Value) Any() any {
 	switch v.Kind {
 	case KindAny, KindBinary:
@@ -542,7 +542,7 @@ func (v Value) Any() any {
 	return v.any
 }
 
-//nolint: forcetypeassert
+// nolint: forcetypeassert
 func (v Value) AsString() string {
 	if v.Kind != KindString {
 		return ""

global.go

@@ -3,14 +3,15 @@ package log
 import (
 	"context"
 	"io"
+	"time"
 
 	"gitoa.ru/go-4devs/log/field"
 	"gitoa.ru/go-4devs/log/level"
 )
 
-//nolint:gochecknoglobals
+//nolint:gochecknoglobals,gomnd
 var global = With(New(),
-	WithCaller(KeySource, 1, false),
+	WithTime(KeyTime, time.RFC3339),
 	WithLevel(KeyLevel, level.Debug),
 	WithExit(level.Alert),
 	WithPanic(level.Emergency),

global_example_test.go

@@ -0,0 +1,25 @@
+package log_test
+
+import (
+	"context"
+	"path/filepath"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+func ExampleDebug() {
+	logger := log.New(log.WithStdout()).With(
+		log.WithSource(2, filepath.Base),
+		log.WithLevel(log.KeyLevel, level.Debug),
+		log.WithExit(level.Alert),
+		log.WithPanic(level.Emergency),
+	)
+
+	log.SetLogger(logger)
+
+	ctx := context.Background()
+	log.Debug(ctx, "debug message")
+	// Output:
+	// msg="debug message" source=global_example_test.go:22 level=debug
+}

handler/logrus/go.mod

@@ -0,0 +1,10 @@
+module gitoa.ru/go-4devs/log/handler/logrus
+
+go 1.20
+
+require (
+	github.com/sirupsen/logrus v1.9.3
+	gitoa.ru/go-4devs/log v0.5.1
+)
+
+require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect

handler/logrus/go.sum

@@ -0,0 +1,17 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gitoa.ru/go-4devs/log v0.5.1 h1:rrIyjpUaw8AjDCf7ZuH0HgCRf370O3TV29yrU1xizWM=
+gitoa.ru/go-4devs/log v0.5.1/go.mod h1:tREtjEH2cTHl0p3uCVcH9g5tlqtsVNI/tDQVfq53Ty4=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

handler/logrus/logger.go

@@ -0,0 +1,49 @@
+package logrus
+
+import (
+	"context"
+
+	"github.com/sirupsen/logrus"
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+// Standard create new standart logrus handler.
+// Deprecated: delete after 0.7.0
+func Standard() log.Logger {
+	return New(logrus.StandardLogger())
+}
+
+// New create new logrus handler.
+// Deprecated: delete after 0.7.0
+func New(log *logrus.Logger) log.Logger {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
+		lrgFields := make(logrus.Fields, data.Fields().Len())
+		data.Fields().Fields(func(f field.Field) bool {
+			lrgFields[f.Key] = f.Value.Any()
+
+			return true
+		})
+
+		entry := log.WithContext(ctx).WithFields(lrgFields)
+
+		switch data.Level() {
+		case level.Emergency:
+			entry.Panic(data.Message())
+		case level.Alert:
+			entry.Fatal(data.Message())
+		case level.Critical, level.Error:
+			entry.Error(data.Message())
+		case level.Warning:
+			entry.Warn(data.Message())
+		case level.Notice, level.Info:
+			entry.Info(data.Message())
+		case level.Debug:
+			entry.Debug(data.Message())
+		}
+
+		return 0, nil
+	}
+}

handler/logrus/logger_example_test.go

@@ -0,0 +1,30 @@
+package logrus_test
+
+import (
+	"context"
+	"io"
+	"os"
+
+	slogrus "github.com/sirupsen/logrus"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/handler/logrus"
+)
+
+func ExampleNew_logrusHandler() {
+	ctx := context.Background()
+	lgrs := slogrus.New()
+	lgrs.SetOutput(os.Stdout)
+	lgrs.SetFormatter(&slogrus.TextFormatter{
+		DisableTimestamp: true,
+	})
+
+	log := logrus.New(lgrs)
+	log.Err(ctx, "log logrus")
+	log.ErrKV(ctx, "log logrus kv", field.Int("int", 42))
+	log.ErrKVs(ctx, "log logrus kv sugar", "err", io.EOF)
+
+	// Output:
+	// level=error msg="log logrus"
+	// level=error msg="log logrus kv" int=42
+	// level=error msg="log logrus kv sugar" err=EOF
+}

handler/logrus/logger_test.go

@@ -0,0 +1,38 @@
+package logrus_test
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+
+	lgr "github.com/sirupsen/logrus"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/handler/logrus"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+func TestNew(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	buf := &bytes.Buffer{}
+
+	lgrus := lgr.New()
+	lgrus.SetLevel(lgr.DebugLevel)
+	lgrus.SetOutput(buf)
+	lgrus.SetFormatter(&lgr.TextFormatter{
+		DisableTimestamp: true,
+	})
+
+	handler := logrus.New(lgrus)
+	expect := "level=info msg=\"handle logrus message\"\n"
+
+	if _, err := handler(ctx, entry.New(entry.WithLevel(level.Info), entry.WithMessage("handle logrus message"))); err != nil {
+		t.Error(err)
+	}
+
+	if !strings.HasSuffix(buf.String(), expect) {
+		t.Errorf("invalid suffix\n got: %s\nexpect:%s\n", buf.String(), expect)
+	}
+}

handler/otel/go.mod

@@ -0,0 +1,17 @@
+module gitoa.ru/go-4devs/log/handler/otel
+
+go 1.21.5
+
+require (
+	gitoa.ru/go-4devs/log v0.5.1
+	go.opentelemetry.io/otel v1.21.0
+	go.opentelemetry.io/otel/sdk v1.21.0
+	go.opentelemetry.io/otel/trace v1.21.0
+)
+
+require (
+	github.com/go-logr/logr v1.3.0 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	go.opentelemetry.io/otel/metric v1.21.0 // indirect
+	golang.org/x/sys v0.14.0 // indirect
+)

handler/otel/go.sum

@@ -0,0 +1,27 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.3.0 h1:2y3SDp0ZXuc6/cjLSZ+Q3ir+QB9T/iG5yYRXqsagWSY=
+github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+gitoa.ru/go-4devs/log v0.5.1 h1:rrIyjpUaw8AjDCf7ZuH0HgCRf370O3TV29yrU1xizWM=
+gitoa.ru/go-4devs/log v0.5.1/go.mod h1:tREtjEH2cTHl0p3uCVcH9g5tlqtsVNI/tDQVfq53Ty4=
+go.opentelemetry.io/otel v1.21.0 h1:hzLeKBZEL7Okw2mGzZ0cc4k/A7Fta0uoPgaJCr8fsFc=
+go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo=
+go.opentelemetry.io/otel/metric v1.21.0 h1:tlYWfeo+Bocx5kLEloTjbcDwBuELRrIFxwdQ36PlJu4=
+go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM=
+go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
+go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
+go.opentelemetry.io/otel/trace v1.21.0 h1:WD9i5gzvoUPuXIXH24ZNBudiarZDKuekPqi/E8fpfLc=
+go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ=
+golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
+golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

handler/otel/helpers.go

@@ -0,0 +1,59 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/level"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
+)
+
+const (
+	fieldSeverityNumber = "SeverityNumber"
+	fieldSeverityText   = "SeverityText"
+	levelFields         = 2
+)
+
+func levels(lvl level.Level) Level {
+	switch lvl {
+	case level.Emergency:
+		return levelError3
+	case level.Alert:
+		return levelFatal
+	case level.Critical:
+		return levelError2
+	case level.Error:
+		return levelError
+	case level.Warning:
+		return levelWarn
+	case level.Notice:
+		return levelInfo2
+	case level.Info:
+		return levelInfo
+	case level.Debug:
+		return levelDebug
+	}
+
+	return 0
+}
+
+func addEvent(ctx context.Context, data *entry.Entry) {
+	span := trace.SpanFromContext(ctx)
+	attrs := make([]attribute.KeyValue, 0, data.Fields().Len()+levelFields)
+
+	lvl := levels(data.Level())
+	attrs = append(attrs,
+		attribute.String(fieldSeverityText, lvl.String()),
+		attribute.Int(fieldSeverityNumber, int(lvl)),
+	)
+
+	data.Fields().Fields(func(f field.Field) bool {
+		attrs = append(attrs, attribute.String(f.Key, f.Value.String()))
+
+		return true
+	})
+
+	span.AddEvent(data.Message(), trace.WithAttributes(attrs...))
+}

handler/otel/level.go

@@ -0,0 +1,16 @@
+package otel
+
+//go:generate stringer -type=Level -linecomment -output=level_string.go
+
+type Level int
+
+const (
+	levelDebug  Level = 5  // DEBUG
+	levelInfo   Level = 9  // INFO
+	levelInfo2  Level = 10 // INFO2
+	levelWarn   Level = 13 // WARN
+	levelError  Level = 17 // ERROR
+	levelError2 Level = 18 // ERROR2
+	levelError3 Level = 19 // ERROR3
+	levelFatal  Level = 21 // FATAL
+)

handler/otel/level_string.go

@@ -0,0 +1,51 @@
+// Code generated by "stringer -type=Level -linecomment -output=level_string.go"; DO NOT EDIT.
+
+package otel
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[levelDebug-5]
+	_ = x[levelInfo-9]
+	_ = x[levelInfo2-10]
+	_ = x[levelWarn-13]
+	_ = x[levelError-17]
+	_ = x[levelError2-18]
+	_ = x[levelError3-19]
+	_ = x[levelFatal-21]
+}
+
+const (
+	_Level_name_0 = "DEBUG"
+	_Level_name_1 = "INFOINFO2"
+	_Level_name_2 = "WARN"
+	_Level_name_3 = "ERRORERROR2ERROR3"
+	_Level_name_4 = "FATAL"
+)
+
+var (
+	_Level_index_1 = [...]uint8{0, 4, 9}
+	_Level_index_3 = [...]uint8{0, 5, 11, 17}
+)
+
+func (i Level) String() string {
+	switch {
+	case i == 5:
+		return _Level_name_0
+	case 9 <= i && i <= 10:
+		i -= 9
+		return _Level_name_1[_Level_index_1[i]:_Level_index_1[i+1]]
+	case i == 13:
+		return _Level_name_2
+	case 17 <= i && i <= 19:
+		i -= 17
+		return _Level_name_3[_Level_index_3[i]:_Level_index_3[i+1]]
+	case i == 21:
+		return _Level_name_4
+	default:
+		return "Level(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}

handler/otel/logger.go

@@ -0,0 +1,17 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+)
+
+// Deprecated: delete after 0.7.0
+func New() log.Logger {
+	return func(ctx context.Context, e *entry.Entry) (int, error) {
+		addEvent(ctx, e)
+
+		return 0, nil
+	}
+}

handler/otel/logger_example_test.go

@@ -0,0 +1,62 @@
+package otel_test
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/handler/otel"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/trace"
+)
+
+func ExampleNew_withTrace() {
+	ctx := context.Background()
+	logger := log.New(log.WithStdout()).With(otel.Middleware())
+
+	sctx, span := startSpan(ctx)
+
+	logger.Err(sctx, "log logrus")
+	logger.ErrKV(sctx, "log logrus kv", field.Int("int", 42))
+	logger.ErrKVs(sctx, "log logrus kv sugar", "err", io.EOF)
+
+	span.End()
+
+	// Output:
+	// msg="log logrus"
+	// msg="log logrus kv" int=42
+	// msg="log logrus kv sugar" err=EOF
+	// event: log logrus, SeverityText = ERROR, SeverityNumber = 17
+	// event: log logrus kv, SeverityText = ERROR, SeverityNumber = 17, int = 42
+	// event: log logrus kv sugar, SeverityText = ERROR, SeverityNumber = 17, err = EOF
+}
+
+func startSpan(ctx context.Context) (context.Context, trace.Span) {
+	tp := sdktrace.NewTracerProvider(sdktrace.WithSyncer(exporter{}))
+
+	return tp.Tracer("logger").Start(ctx, "operation")
+}
+
+type exporter struct{}
+
+func (e exporter) Shutdown(_ context.Context) error {
+	return nil
+}
+
+func (e exporter) ExportSpans(_ context.Context, spanData []sdktrace.ReadOnlySpan) error {
+	for _, data := range spanData {
+		for _, events := range data.Events() {
+			fmt.Print("event: ", events.Name)
+
+			for _, attr := range events.Attributes {
+				fmt.Printf(", %v = %v", attr.Key, attr.Value.AsInterface())
+			}
+
+			fmt.Print("\n")
+		}
+	}
+
+	return nil
+}

handler/otel/middleware.go

@@ -0,0 +1,17 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+)
+
+// Deprecated: delete after 0.7.0
+func Middleware() log.Middleware {
+	return func(ctx context.Context, e *entry.Entry, handler log.Logger) (int, error) {
+		addEvent(ctx, e)
+
+		return handler(ctx, e)
+	}
+}

handler/zap/go.mod

@@ -0,0 +1,10 @@
+module gitoa.ru/go-4devs/log/handler/zap
+
+go 1.21.5
+
+require (
+	gitoa.ru/go-4devs/log v0.5.1
+	go.uber.org/zap v1.26.0
+)
+
+require go.uber.org/multierr v1.10.0 // indirect

handler/zap/go.sum

@@ -0,0 +1,16 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+gitoa.ru/go-4devs/log v0.5.1 h1:rrIyjpUaw8AjDCf7ZuH0HgCRf370O3TV29yrU1xizWM=
+gitoa.ru/go-4devs/log v0.5.1/go.mod h1:tREtjEH2cTHl0p3uCVcH9g5tlqtsVNI/tDQVfq53Ty4=
+go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
+go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
+go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

handler/zap/logger.go

@@ -0,0 +1,70 @@
+package zap
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/level"
+	"go.uber.org/zap"
+)
+
+// Deprecated: delete after 0.7.0
+func Nop() log.Logger {
+	return New(zap.NewNop())
+}
+
+// Deprecated: delete after 0.7.0
+func Example(options ...zap.Option) log.Logger {
+	return New(zap.NewExample(options...))
+}
+
+// Deprecated: delete after 0.7.0
+func Production(options ...zap.Option) log.Logger {
+	z, err := zap.NewProduction(options...)
+	if err != nil {
+		panic(err)
+	}
+
+	return New(z)
+}
+
+// Deprecated: delete after 0.7.0
+func Development(options ...zap.Option) log.Logger {
+	z, err := zap.NewDevelopment(options...)
+	if err != nil {
+		panic(err)
+	}
+
+	return New(z)
+}
+
+// New create handler by zap logger.
+func New(logger *zap.Logger) log.Logger {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
+		zf := make([]zap.Field, 0, data.Fields().Len())
+		data.Fields().Fields(func(f field.Field) bool {
+			zf = append(zf, zap.Any(f.Key, f.Value.Any()))
+
+			return true
+		})
+
+		switch data.Level() {
+		case level.Emergency:
+			logger.Fatal(data.Message(), zf...)
+		case level.Alert:
+			logger.Panic(data.Message(), zf...)
+		case level.Critical, level.Error:
+			logger.Error(data.Message(), zf...)
+		case level.Warning:
+			logger.Warn(data.Message(), zf...)
+		case level.Notice, level.Info:
+			logger.Info(data.Message(), zf...)
+		case level.Debug:
+			logger.Debug(data.Message(), zf...)
+		}
+
+		return 0, nil
+	}
+}

handler/zap/logger_example_test.go

@@ -0,0 +1,23 @@
+package zap_test
+
+import (
+	"context"
+	"io"
+
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/handler/zap"
+	uzap "go.uber.org/zap"
+)
+
+func ExampleNew_zapHandler() {
+	ctx := context.Background()
+	log := zap.New(uzap.NewExample())
+	log.Err(ctx, "log zap")
+	log.ErrKV(ctx, "log zap kv", field.Int("int", 42))
+	log.ErrKVs(ctx, "log zap kv sugar", "err", io.EOF)
+
+	// Output:
+	// {"level":"error","msg":"log zap"}
+	// {"level":"error","msg":"log zap kv","int":42}
+	// {"level":"error","msg":"log zap kv sugar","err":"EOF"}
+}

handler/zap/logger_test.go

@@ -0,0 +1,43 @@
+package zap_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	zlog "gitoa.ru/go-4devs/log/handler/zap"
+	"gitoa.ru/go-4devs/log/level"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func TestNew(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	buf := &bytes.Buffer{}
+	core := zapcore.NewCore(zapcore.NewJSONEncoder(zapcore.EncoderConfig{
+		MessageKey:     "msg",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.StringDurationEncoder,
+	}), zapcore.AddSync(buf), zapcore.DebugLevel)
+	logger := zlog.New(zap.New(core))
+	expect := `{"level":"info","msg":"handle zap message","env":"test"}` + "\n"
+
+	if _, err := logger(ctx, entry.New(
+		entry.WithFields(field.String("env", "test")),
+		entry.WithLevel(level.Notice),
+		entry.WithMessage("handle zap message"),
+	)); err != nil {
+		t.Error(err)
+	}
+
+	if buf.String() != expect {
+		t.Errorf("invalid message\n got: %s\nexpect:%s\n", buf.String(), expect)
+	}
+}

logger_example_caller_test.go

@@ -1,22 +1,23 @@
 package log_test
 
 import (
+	"path/filepath"
+
 	"gitoa.ru/go-4devs/log"
 	"gitoa.ru/go-4devs/log/level"
 )
 
 func ExampleNew_withCaller() {
-	logger := log.With(
+	logger := log.New(log.WithStdout()).With(
-		log.New(log.WithStdout()),
+		log.WithLevel(log.KeyLevel, level.Debug),
-		log.WithLevel("level", level.Debug),
+		log.WithSource(3, filepath.Base),
-		log.WithCaller("caller", 2, false),
 	)
 	logger.Err(ctx, "same error message")
 	logger.InfoKVs(ctx, "same info message", "api-version", 0.1)
 	_, _ = logger.Write([]byte("same write message"))
 
 	// Output:
-	// msg="same error message" level=error caller=logger_example_caller_test.go:14
+	// msg="same error message" level=error source=logger_example_caller_test.go:15
-	// msg="same info message" api-version=0.1 level=info caller=logger_example_caller_test.go:15
+	// msg="same info message" api-version=0.1 level=info source=logger_example_caller_test.go:16
-	// msg="same write message" level=info caller=logger_example_caller_test.go:16
+	// msg="same write message" level=info source=logger_example_caller_test.go:17
 }

logger_example_test.go

@@ -47,19 +47,19 @@ func ExampleNew_errf() {
 }
 
 func ExampleNew_debugKV() {
-	logger := log.New(log.WithStdout()).With(log.WithLevel("level", level.Debug))
+	logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Debug))
 	logger.DebugKVs(ctx, "same message", "error", os.ErrNotExist)
 	// Output: msg="same message" error="file does not exist" level=debug
 }
 
 func ExampleNew_level() {
-	logger := log.New(log.WithStdout()).With(log.WithLevel("level", level.Error))
+	logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Error))
 	logger.Err(ctx, "same error message")
 	// Output: msg="same error message" level=error
 }
 
 func ExampleNew_level_info() {
-	logger := log.New(log.WithStdout()).With(log.WithLevel("level", level.Error))
+	logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Error))
 	logger.Info(ctx, "same message")
 	// Output:
 }
@@ -92,7 +92,7 @@ var (
 	float64Val = float64(math.MaxFloat64)
 
 	minute  = time.Minute
-	timeVal = time.Unix(0, math.MaxInt32)
+	timeVal = time.Unix(0, math.MaxInt32).In(time.UTC)
 )
 
 func ExampleNew_anyField() {
@@ -108,7 +108,7 @@ func ExampleNew_anyField() {
 		field.Any("error", errors.New("error")),
 	)
 	// Output:
-	// {"msg":"any info message","obj":{"Name":"obj name","IsEnable":false},"obj":{"Name":"test obj","IsEnable":false},"int":9223372036854775807,"uint":18446744073709551615,"float":1.7976931348623157e+308,"time":"1970-01-01T03:00:02+03:00","duration":"1h0m0s","error":"error"}
+	// {"msg":"any info message","obj":{"Name":"obj name","IsEnable":false},"obj":{"Name":"test obj","IsEnable":false},"int":9223372036854775807,"uint":18446744073709551615,"float":1.7976931348623157e+308,"time":"1970-01-01T00:00:02Z","duration":"1h0m0s","error":"error"}
 }
 
 func ExampleNew_arrayField() {
@@ -130,11 +130,11 @@ func ExampleNew_arrayField() {
 		field.Complex64s("complex64s", 42, 24),
 		field.Complex128s("complex128s", 42, 24),
 		field.Durations("durations", time.Minute, time.Second),
-		field.Times("times", time.Unix(0, 42), time.Unix(0, 24)),
+		field.Times("times", time.Unix(0, 42).In(time.UTC), time.Unix(0, 24).In(time.UTC)),
 		field.Errors("errors", errors.New("error"), errors.New("error2")),
 	)
 	// Output:
-	// {"msg":"array info message","strings":["string","test str"],"bools":[true,false],"ints":[42,24],"int8s":[42,24],"int16s":[42,24],"int32s":[42,24],"int64s":[42,24],"uint8s":[255,0],"uint16s":[42,24],"uint32s":[42,24],"uint64s":[42,24],"float32s":[42,24],"float64s":[42,24],"complex64s":["(42+0i)","(24+0i)"],"complex128s":["(42+0i)","(24+0i)"],"durations":["1m0s","1s"],"times":["1970-01-01T03:00:00+03:00","1970-01-01T03:00:00+03:00"],"errors":["error","error2"]}
+	// {"msg":"array info message","strings":["string","test str"],"bools":[true,false],"ints":[42,24],"int8s":[42,24],"int16s":[42,24],"int32s":[42,24],"int64s":[42,24],"uint8s":[255,0],"uint16s":[42,24],"uint32s":[42,24],"uint64s":[42,24],"float32s":[42,24],"float64s":[42,24],"complex64s":["(42+0i)","(24+0i)"],"complex128s":["(42+0i)","(24+0i)"],"durations":["1m0s","1s"],"times":["1970-01-01T00:00:00Z","1970-01-01T00:00:00Z"],"errors":["error","error2"]}
 }
 
 func ExampleNew_pointerField() {
@@ -174,7 +174,7 @@ func ExampleNew_pointerField() {
 		field.Timep("timep", nil),
 	)
 	// Output:
-	// {"msg":"pointer info message","stringp":"test str","stringp":null,"boolp":true,"boolp":null,"intp":9223372036854775807,"intp":null,"int8p":127,"int8p":null,"int16p":32767,"int16p":null,"int32p":2147483647,"int32p":null,"int64p":9223372036854775807,"int64p":null,"uintp":18446744073709551615,"uintp":null,"uint8p":255,"uint8p":null,"uint16p":32767,"uint16p":null,"uint32p":2147483647,"uint32p":null,"uint64p":9223372036854775807,"uint64p":null,"float32p":3.4028235e+38,"float32p":null,"float64p":1.7976931348623157e+308,"float64p":null,"durationp":"1m0s","durationp":null,"timep":"1970-01-01T03:00:02+03:00","timep":null}
+	// {"msg":"pointer info message","stringp":"test str","stringp":null,"boolp":true,"boolp":null,"intp":9223372036854775807,"intp":null,"int8p":127,"int8p":null,"int16p":32767,"int16p":null,"int32p":2147483647,"int32p":null,"int64p":9223372036854775807,"int64p":null,"uintp":18446744073709551615,"uintp":null,"uint8p":255,"uint8p":null,"uint16p":32767,"uint16p":null,"uint32p":2147483647,"uint32p":null,"uint64p":9223372036854775807,"uint64p":null,"float32p":3.4028235e+38,"float32p":null,"float64p":1.7976931348623157e+308,"float64p":null,"durationp":"1m0s","durationp":null,"timep":"1970-01-01T00:00:02Z","timep":null}
 }
 
 func ExampleNew_fields() {
@@ -196,12 +196,12 @@ func ExampleNew_fields() {
 		field.Complex64("complex16", 42),
 		field.Complex128("complex128", 42),
 		field.Duration("duration", time.Minute),
-		field.Time("time", time.Unix(0, 42)),
+		field.Time("time", timeVal),
 		field.FormatTime("format_time", time.UnixDate, timeVal),
 		field.Error("error", errors.New("error")),
 	)
 	// Output:
-	// {"msg":"info message","string":"test str","bool":true,"int":42,"int8":42,"int16":42,"int32":42,"int64":42,"uint8":255,"uint16":42,"uint32":42,"uint64":42,"float32":42,"float64":42,"complex16":"(42+0i)","complex128":"(42+0i)","duration":"1m0s","time":"1970-01-01T03:00:00+03:00","format_time":"Thu Jan  1 03:00:02 MSK 1970","error":"error"}
+	// {"msg":"info message","string":"test str","bool":true,"int":42,"int8":42,"int16":42,"int32":42,"int64":42,"uint8":255,"uint16":42,"uint32":42,"uint64":42,"float32":42,"float64":42,"complex16":"(42+0i)","complex128":"(42+0i)","duration":"1m0s","time":"1970-01-01T00:00:02Z","format_time":"Thu Jan  1 00:00:02 UTC 1970","error":"error"}
 }
 
 func ExampleNew_jsonFormat() {
@@ -213,22 +213,22 @@ func ExampleNew_jsonFormat() {
 	logger.Err(ctx, "same error message")
 	logger.WarnKVs(ctx, "same warn message", "obj", Obj{Name: "obj name"})
 	// Output:
-	// {"msg":"same error message","level":"error","go-version":"go1.21.5"}
+	// {"msg":"same error message","level":"error","go-version":"go1.22.2"}
-	// {"msg":"same warn message","obj":{"Name":"obj name","IsEnable":false},"level":"warning","go-version":"go1.21.5"}
+	// {"msg":"same warn message","obj":{"Name":"obj name","IsEnable":false},"level":"warning","go-version":"go1.22.2"}
 }
 
 func ExampleNew_textEncoding() {
-	logger := log.With(
+	logger := log.New(log.WithStdout()).
-		log.New(log.WithStdout()),
+		With(
-		log.WithLevel(log.KeyLevel, level.Debug),
+			log.WithLevel(log.KeyLevel, level.Debug),
-		log.GoVersion("go-version"),
+			log.GoVersion("go-version"),
-	)
+		)
 	logger.Err(ctx, "same error message")
 	logger.InfoKVs(ctx, "same info message", "api-version", 0.1, "obj", Obj{Name: "text value", IsEnable: true})
 
 	// Output:
-	// msg="same error message" level=error go-version=go1.21.5
+	// msg="same error message" level=error go-version=go1.22.2
-	// msg="same info message" api-version=0.1 obj={Name:text value IsEnable:true} level=info go-version=go1.21.5
+	// msg="same info message" api-version=0.1 obj={Name:text value IsEnable:true} level=info go-version=go1.22.2
 }
 
 type ctxKey string
@@ -238,28 +238,32 @@ func (c ctxKey) String() string {
 }
 
 func levelInfo(ctx context.Context, entry *entry.Entry, handler log.Logger) (int, error) {
-	return handler(ctx, entry.Add(field.String("level", entry.Level().String())))
+	return handler(ctx, entry.Add(field.String(log.KeyLevel, entry.Level().String())))
 }
 
 func ExampleWith() {
 	var requestID ctxKey = "requestID"
 	vctx := context.WithValue(ctx, requestID, "6a5fa048-7181-11ea-bc55-0242ac130003")
 
-	logger := log.With(
+	logger := log.New(log.WithStdout()).With(
-		log.New(log.WithStdout()),
+		levelInfo,
-		levelInfo, log.WithContextValue(requestID), log.KeyValue("api", "0.1.0"), log.GoVersion("go"),
+		log.WithContextValue(requestID),
+		log.KeyValue("api", "0.1.0"),
+		log.GoVersion("go"),
 	)
 	logger.Info(vctx, "same message")
-	// Output: msg="same message" level=info requestID=6a5fa048-7181-11ea-bc55-0242ac130003 api=0.1.0 go=go1.21.5
+	// Output: msg="same message" level=info requestID=6a5fa048-7181-11ea-bc55-0242ac130003 api=0.1.0 go=go1.22.2
 }
 
 func ExampleLogger_Print() {
-	logger := log.With(
+	logger := log.New(log.WithStdout()).With(
-		log.New(log.WithStdout()),
+		levelInfo,
-		levelInfo, log.KeyValue("client", "http"), log.KeyValue("api", "0.1.0"), log.GoVersion("go"),
+		log.KeyValue("client", "http"),
+		log.KeyValue("api", "0.1.0"),
+		log.GoVersion("go"),
 	)
 	logger.Print("same message")
-	// Output: msg="same message" level=info client=http api=0.1.0 go=go1.21.5
+	// Output: msg="same message" level=info client=http api=0.1.0 go=go1.22.2
 }
 
 func ExamplePrint() {
@@ -277,7 +281,7 @@ func Example_fieldClosureFn() {
 		return d
 	})
 
-	log := log.With(log.New(log.WithStdout()), log.WithLevel("level", level.Info))
+	log := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Info))
 
 	log.DebugKVs(ctx, "debug message", "data", closure)
 	log.ErrKVs(ctx, "error message", "err", closure)
@@ -289,7 +293,9 @@ func Example_fieldClosureFn() {
 }
 
 func Example_withGroup() {
-	log := log.With(log.New(log.WithStdout()), log.WithLevel(log.KeyLevel, level.Info))
+	log := log.New(log.WithStdout()).With(
+		log.WithLevel(log.KeyLevel, level.Info),
+	)
 
 	log.ErrKVs(ctx, "error message",
 		field.Groups("grous_field",

logger_test.go

@@ -27,7 +27,7 @@ func TestFields(t *testing.T) {
 	ctx := context.Background()
 	buf := &bytes.Buffer{}
 	log := log.New(log.WithWriter(buf)).
-		With(log.WithLevel("level", level.Info))
+		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"
 
 	log.InfoKVs(ctx, "message",
@@ -65,7 +65,7 @@ func TestWriter(t *testing.T) {
 
 	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("level", level.Info))
+	logger := log.New(log.WithWriter(buf)).With(log.WithContextValue(requestID), log.WithLevel(log.KeyLevel, level.Info))
 
 	_, _ = logger.Writer(
 		context.WithValue(ctx, requestID, "6a5fa048-7181-11ea-bc55-0242ac1311113"),
@@ -91,7 +91,7 @@ func TestLogger(t *testing.T) {
 
 	ctx := context.Background()
 	buf := &bytes.Buffer{}
-	logger := log.New(log.WithWriter(buf)).With(log.WithContextValue(requestID), log.WithLevel("level", level.Info))
+	logger := log.New(log.WithWriter(buf)).With(log.WithContextValue(requestID), log.WithLevel(log.KeyLevel, level.Info))
 
 	_, err := logger(ctx, nil)
 	if err != nil {

middleware.go

@@ -38,6 +38,7 @@ func With(logger Logger, mw ...Middleware) Logger {
 			if curI == lastI {
 				return logger(currentCtx, currentEntry)
 			}
+
 			curI++
 			n, err := mw[curI](currentCtx, currentEntry, chainHandler)
 			curI--
@@ -85,7 +86,14 @@ func WithContextValue(keys ...fmt.Stringer) Middleware {
 	}
 }
 
+func WithName(name string) Middleware {
+	return func(ctx context.Context, data *entry.Entry, handler Logger) (int, error) {
+		return handler(ctx, data.Replace(KeyName, field.StringValue(name)))
+	}
+}
+
 // WithCaller adds called file.
+// Deprecated: use WithSource.
 func WithCaller(key string, depth int, full bool) Middleware {
 	const offset = 2
 

source.go

@@ -0,0 +1,94 @@
+package log
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+)
+
+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."
+	)
+
+	items += skip
+
+	return func(ctx context.Context, data *entry.Entry, handler Logger) (int, error) {
+		pc := make([]uintptr, items)
+		n := runtime.Callers(skip, pc)
+
+		if n == 0 {
+			return handler(ctx, data.Add(errSourceField(skip, items)))
+		}
+
+		pc = pc[:n] // pass only valid pcs to runtime.CallersFrames
+		frames := runtime.CallersFrames(pc)
+		prew := false
+
+		for {
+			frame, more := frames.Next()
+
+			has := strings.HasPrefix(frame.Function, funcPrefix)
+			if !has && prew {
+				if strings.HasPrefix(frame.Function, skipHelper) {
+					continue
+				}
+
+				return handler(ctx, data.AddAny(KeySource, Source{
+					Func: filepath.Base(frame.Function),
+					Line: frame.Line,
+					File: trimPath(frame.File),
+				}))
+			}
+
+			prew = has
+
+			if !more {
+				break
+			}
+		}
+
+		return handler(ctx, data.Add(errSourceField(skip, items)))
+	}
+}
+
+func TrimPath(file string) string {
+	idx := strings.LastIndexByte(file, '/')
+	if idx == -1 {
+		return filepath.Base(file)
+	}
+
+	// Find the penultimate separator.
+	idx = strings.LastIndexByte(file[:idx], '/')
+	if idx == -1 {
+		return filepath.Base(file)
+	}
+
+	return file[idx+1:]
+}
+
+// Source describes the location of a line of source code.
+type Source struct {
+	Func string `json:"func"`
+	File string `json:"file"`
+	Line int    `json:"line"`
+}
+
+func (l Source) MarshalText() ([]byte, error) {
+	return []byte(fmt.Sprintf("%s:%d", l.File, l.Line)), nil
+}
+
+func (l Source) MarshalJSON() ([]byte, error) {
+	return fmt.Appendf([]byte{}, `{"file":"%s","line":%d,"func":"%s"}`, l.File, l.Line, l.Func), nil
+}
+
+func errSourceField(skip, max int) field.Field {
+	return field.String(KeySource, fmt.Sprintf("source not found by frames[%d:%d]", skip, max))
+}

source_example_test.go

@@ -0,0 +1,26 @@
+package log_test
+
+import (
+	"context"
+	"path/filepath"
+
+	"gitoa.ru/go-4devs/log"
+)
+
+func ExampleWithSource() {
+	ctx := context.Background()
+	logger := log.New(log.WithStdout()).With(log.WithSource(1, filepath.Base))
+
+	logger.Debug(ctx, "debug message")
+	// Output:
+	// msg="debug message" source=source_example_test.go:14
+}
+
+func ExampleWithSource_json() {
+	ctx := context.Background()
+	logger := log.New(log.WithStdout(), log.WithJSONFormat()).With(log.WithSource(2, filepath.Base))
+
+	logger.Debug(ctx, "debug message")
+	// Output:
+	// {"msg":"debug message","source":{"file":"source_example_test.go","line":23,"func":"log_test.ExampleWithSource_json"}}
+}

writer_example_test.go

@@ -0,0 +1,37 @@
+package log_test
+
+import (
+	"context"
+	"math"
+	"path/filepath"
+	"time"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+func exampleWithTime(key, format string) log.Middleware {
+	return func(ctx context.Context, e *entry.Entry, handler log.Logger) (int, error) {
+		return handler(ctx, e.Add(field.FormatTime(key, format, time.Unix(math.MaxInt32, 0).In(time.UTC))))
+	}
+}
+
+func ExampleFormatWithBracket() {
+	ctx := context.Background()
+	logger := log.New(log.WithFormat(log.FormatWithBracket(field.NewEncoderText())), log.WithStdout()).With(
+		log.WithSource(10, filepath.Base),
+		// log.WithTime(log.KeyTime, time.RFC3339),
+		exampleWithTime(log.KeyTime, time.RFC3339),
+		log.WithLevel(log.KeyLevel, level.Info),
+	)
+
+	logger.InfoKV(ctx, "imfo message", field.Int64("num", 42))
+
+	serviceLogger := logger.With(log.WithName("service_name"))
+	serviceLogger.Err(ctx, "error message")
+	// Output:
+	// 2038-01-19T03:14:07Z [info] writer_example_test.go:30 "imfo message" num=42
+	// 2038-01-19T03:14:07Z [error][service_name] writer_example_test.go:33 "error message"
+}

writter.go

@@ -25,6 +25,8 @@ const (
 	// SourceKey is the key used by the built-in handlers for the source file
 	// and line of the log call. The associated value is a string.
 	KeySource = "source"
+	// KeyName logger name.
+	KeyName = "name"
 )
 
 func WithWriter(w io.Writer) func(*option) {
@@ -41,15 +43,18 @@ func WithStdout() func(*option) {
 
 // WithStringFormat sets format as simple string.
 func WithStringFormat() func(*option) {
-	return func(o *option) {
+	return WithFormat(FormatString(field.NewEncoderText()))
-		o.format = formatText()
-	}
 }
 
 // WithJSONFormat sets json output format.
 func WithJSONFormat() func(*option) {
+	return WithFormat(FormatJSON(field.NewEncoderJSON()))
+}
+
+// WithFormat sets custom output format.
+func WithFormat(format func(io.Writer, *entry.Entry) (int, error)) func(*option) {
 	return func(o *option) {
-		o.format = formatJSON()
+		o.format = format
 	}
 }
 
@@ -61,7 +66,7 @@ type option struct {
 // New creates standart logger.
 func New(opts ...func(*option)) Logger {
 	log := option{
-		format: formatText(),
+		format: FormatString(field.NewEncoderText()),
 		out:    os.Stderr,
 	}
 
@@ -74,9 +79,64 @@ func New(opts ...func(*option)) Logger {
 	}
 }
 
-func formatText() func(io.Writer, *entry.Entry) (int, error) {
+type Encoder interface {
-	enc := field.NewEncoderText()
+	AppendValue(dst []byte, val field.Value) []byte
+	AppendField(dst []byte, val field.Field) []byte
+}
 
+func FormatWithBracket(enc Encoder) func(io.Writer, *entry.Entry) (int, error) {
+	appendValue := func(buf *buffer.Buffer, data field.Fields, key, prefix, suffix string) *buffer.Buffer {
+		data.Fields(
+			func(f field.Field) bool {
+				if f.IsKey(key) {
+					_, _ = buf.WriteString(prefix)
+					*buf = enc.AppendValue(*buf, f.Value)
+					_, _ = buf.WriteString(suffix)
+
+					return false
+				}
+
+				return true
+			})
+
+		return buf
+	}
+
+	return func(w io.Writer, data *entry.Entry) (int, error) {
+		buf := buffer.New()
+		defer func() {
+			buf.Free()
+		}()
+
+		fields := data.Fields()
+		buf = appendValue(buf, fields, KeyTime, "", " ")
+		_, _ = buf.WriteString("[")
+		*buf = enc.AppendValue(*buf, field.StringValue(data.Level().String()))
+		_, _ = buf.WriteString("]")
+		buf = appendValue(buf, fields, KeyName, "[", "]")
+		buf = appendValue(buf, fields, KeySource, " ", " ")
+		*buf = enc.AppendValue(*buf, field.StringValue(data.Message()))
+
+		fields.Fields(func(f field.Field) bool {
+			if !f.IsKey(KeyTime, KeySource, KeyName, KeyLevel) {
+				*buf = enc.AppendField(*buf, f)
+			}
+
+			return true
+		})
+
+		_, _ = buf.WriteString("\n")
+
+		n, err := w.Write(*buf)
+		if err != nil {
+			return 0, fmt.Errorf("format text:%w", err)
+		}
+
+		return n, nil
+	}
+}
+
+func FormatString(enc Encoder) func(io.Writer, *entry.Entry) (int, error) {
 	return func(w io.Writer, entry *entry.Entry) (int, error) {
 		buf := buffer.New()
 		defer func() {
@@ -100,9 +160,7 @@ func formatText() func(io.Writer, *entry.Entry) (int, error) {
 	}
 }
 
-func formatJSON() func(w io.Writer, entry *entry.Entry) (int, error) {
+func FormatJSON(enc Encoder) func(w io.Writer, entry *entry.Entry) (int, error) {
-	enc := field.NewEncoderJSON()
-
 	return func(w io.Writer, entry *entry.Entry) (int, error) {
 		buf := buffer.New()
 		defer func() {