skip check error in example

Reviewed-on: #4

.drone.yml

@@ -3,7 +3,7 @@ name: default
 
 steps:
 - name: test 
-  image: golang:1.17.6
+  image: golang:1.17.8
   volumes:
   - name: deps
     path: /go/src/mod
@@ -11,7 +11,7 @@ steps:
   - go test 
 
 - name: golangci-lint
-  image: golangci/golangci-lint:v1.42
+  image: golangci/golangci-lint:v1.44
   commands:
   - golangci-lint run
 

.golangci.yml

@@ -19,6 +19,12 @@ linters-settings:
       locale: US  
     exhaustive:
       default-signifies-exhaustive: true
+    varnamelen:
+      min-name-length: 2
+      ignore-names:
+        - err
+        - "n"
+        - i
     tagliatelle:
       case:
         use-field-name: true
@@ -39,3 +45,4 @@ issues:
       linters:
         - gomnd
         - exhaustivestruct
+        - ireturn

LICENSE

@@ -1,4 +1,4 @@
-MIT License Copyright (c) 2020 go-4devs
+MIT License Copyright (c) 2020-2022 4devs
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

entry/caller.go

@@ -7,14 +7,14 @@ import (
 )
 
 func Caller(depth int, full bool) string {
-	const offset = 4
+	const offset = 3
-	_, file, line, ok := runtime.Caller(depth + offset)
+	_, file, line, has := runtime.Caller(depth + offset)
 
-	if !ok {
+	if !has {
 		file, line = "???", 0
 	}
 
-	if !full && ok {
+	if !full && has {
 		file = filepath.Base(file)
 	}
 

entry/entry.go

@@ -1,6 +1,7 @@
 package entry
 
 import (
+	"fmt"
 	"strings"
 
 	"gitoa.ru/go-4devs/log/field"
@@ -27,7 +28,14 @@ func WithFields(fields ...field.Field) Option {
 
 func WithMessage(msg string) Option {
 	return func(e *Entry) {
-		e.msg = msg
+		e.format = msg
+	}
+}
+
+func WithMessagef(format string, args ...interface{}) Option {
+	return func(e *Entry) {
+		e.format = format
+		e.args = args
 	}
 }
 
@@ -38,28 +46,32 @@ func WithLevel(lvl level.Level) Option {
 }
 
 func New(opts ...Option) *Entry {
-	e := &Entry{
+	entry := &Entry{
 		fields: make(field.Fields, 0, defaultCap+1),
 		level:  level.Debug,
-		msg:    "",
+		format: "",
+		args:   make([]interface{}, 0, defaultCap+1),
 	}
 
 	for _, opt := range opts {
-		opt(e)
+		opt(entry)
 	}
 
-	return e
+	return entry
 }
 
 // Entry slice field.
 type Entry struct {
-	msg    string
+	format string
+	args   []interface{}
 	level  level.Level
 	fields field.Fields
 }
 
 func (e *Entry) Reset() {
 	e.fields = e.fields[:0]
+	e.args = e.args[:0]
+	e.format = ""
 }
 
 func (e *Entry) Fields() field.Fields {
@@ -73,7 +85,7 @@ func (e *Entry) String() string {
 	}
 
 	str := make([]string, len(e.fields)+1)
-	str[0] = e.msg
+	str[0] = e.Message()
 
 	for i, field := range e.fields {
 		str[i+1] = field.String()
@@ -83,7 +95,14 @@ func (e *Entry) String() string {
 }
 
 func (e *Entry) Message() string {
-	return e.msg
+	switch {
+	case len(e.args) > 0 && e.format != "":
+		return fmt.Sprintf(e.format, e.args...)
+	case len(e.args) > 0:
+		return fmt.Sprint(e.args...)
+	default:
+		return e.format
+	}
 }
 
 func (e *Entry) Level() level.Level {
@@ -109,7 +128,18 @@ func (e *Entry) SetMessage(msg string) *Entry {
 		return New().SetMessage(msg)
 	}
 
-	e.msg = msg
+	e.format = msg
+
+	return e
+}
+
+func (e *Entry) SetMessagef(format string, args ...interface{}) *Entry {
+	if e == nil {
+		return New().SetMessagef(format, args...)
+	}
+
+	e.format = format
+	e.args = append(e.args[:0], args...)
 
 	return e
 }

field/fields.go

@@ -19,11 +19,11 @@ func (f Fields) Len() int {
 }
 
 func (f Fields) AsMap() MapField {
-	m := make(MapField, len(f))
+	fields := make(MapField, len(f))
 
 	for _, field := range f {
-		m[field.Key()] = field.Value()
+		fields[field.Key()] = field.Value()
 	}
 
-	return m
+	return fields
 }

field/fields_test.go

@@ -8,6 +8,8 @@ import (
 )
 
 func TestFields_Append(t *testing.T) {
+	t.Parallel()
+
 	fields := field.Fields{field.Any("any", "value")}
 	fields = fields.Append(field.String("string", "value"))
 

field/key.go

@@ -8,113 +8,113 @@ type Key string
 
 //nolint: gocyclo,funlen,cyclop
 func (k Key) Any(value interface{}) Field {
-	switch v := value.(type) {
+	switch val := value.(type) {
 	case string:
-		return k.String(v)
+		return k.String(val)
 	case *string:
-		return k.Stringp(v)
+		return k.Stringp(val)
 	case []string:
-		return k.Strings(v...)
+		return k.Strings(val...)
 	case bool:
-		return k.Bool(v)
+		return k.Bool(val)
 	case *bool:
-		return k.Boolp(v)
+		return k.Boolp(val)
 	case []bool:
-		return k.Bools(v...)
+		return k.Bools(val...)
 	case int8:
-		return k.Int8(v)
+		return k.Int8(val)
 	case []int8:
-		return k.Int8s(v...)
+		return k.Int8s(val...)
 	case *int8:
-		return k.Int8p(v)
+		return k.Int8p(val)
 	case int16:
-		return k.Int16(v)
+		return k.Int16(val)
 	case []int16:
-		return k.Int16s(v...)
+		return k.Int16s(val...)
 	case *int16:
-		return k.Int16p(v)
+		return k.Int16p(val)
 	case int32:
-		return k.Int32(v)
+		return k.Int32(val)
 	case []int32:
-		return k.Int32s(v...)
+		return k.Int32s(val...)
 	case *int32:
-		return k.Int32p(v)
+		return k.Int32p(val)
 	case int64:
-		return k.Int64(v)
+		return k.Int64(val)
 	case []int64:
-		return k.Int64s(v...)
+		return k.Int64s(val...)
 	case *int64:
-		return k.Int64p(v)
+		return k.Int64p(val)
 	case uint:
-		return k.Uint(v)
+		return k.Uint(val)
 	case []uint:
-		return k.Uints(v...)
+		return k.Uints(val...)
 	case *uint:
-		return k.Uintp(v)
+		return k.Uintp(val)
 	case uint8:
-		return k.Uint8(v)
+		return k.Uint8(val)
 	case *uint8:
-		return k.Uint8p(v)
+		return k.Uint8p(val)
 	case uint16:
-		return k.Uint16(v)
+		return k.Uint16(val)
 	case []uint16:
-		return k.Uint16s(v...)
+		return k.Uint16s(val...)
 	case *uint16:
-		return k.Uint16p(v)
+		return k.Uint16p(val)
 	case uint32:
-		return k.Uint32(v)
+		return k.Uint32(val)
 	case []uint32:
-		return k.Uint32s(v...)
+		return k.Uint32s(val...)
 	case *uint32:
-		return k.Uint32p(v)
+		return k.Uint32p(val)
 	case uint64:
-		return k.Uint64(v)
+		return k.Uint64(val)
 	case []uint64:
-		return k.Uint64s(v...)
+		return k.Uint64s(val...)
 	case *uint64:
-		return k.Uint64p(v)
+		return k.Uint64p(val)
 	case float32:
-		return k.Float32(v)
+		return k.Float32(val)
 	case []float32:
-		return k.Float32s(v...)
+		return k.Float32s(val...)
 	case *float32:
-		return k.Float32p(v)
+		return k.Float32p(val)
 	case float64:
-		return k.Float64(v)
+		return k.Float64(val)
 	case []float64:
-		return k.Float64s(v...)
+		return k.Float64s(val...)
 	case *float64:
-		return k.Float64p(v)
+		return k.Float64p(val)
 	case complex64:
-		return k.Complex64(v)
+		return k.Complex64(val)
 	case []complex64:
-		return k.Complex64s(v...)
+		return k.Complex64s(val...)
 	case *complex64:
-		return k.Complex64p(v)
+		return k.Complex64p(val)
 	case uintptr:
-		return k.Uintptr(v)
+		return k.Uintptr(val)
 	case []uintptr:
-		return k.Uintptrs(v...)
+		return k.Uintptrs(val...)
 	case *uintptr:
-		return k.Uintptrp(v)
+		return k.Uintptrp(val)
 	case []byte:
-		return k.Bytes(v)
+		return k.Bytes(val)
 	case time.Duration:
-		return k.Dureation(v)
+		return k.Dureation(val)
 	case []time.Duration:
-		return k.Dureations(v)
+		return k.Dureations(val)
 	case *time.Duration:
-		return k.Dureationp(v)
+		return k.Dureationp(val)
 	case time.Time:
-		return k.Time(v)
+		return k.Time(val)
 	case []time.Time:
-		return k.Times(v...)
+		return k.Times(val...)
 	case *time.Time:
-		return k.Timep(v)
+		return k.Timep(val)
 	case error:
-		return k.Error(v)
+		return k.Error(val)
 	case []error:
-		return k.Errors(v...)
+		return k.Errors(val...)
 	}
 
 	return Field{

field/value.go

@@ -265,31 +265,45 @@ func (v Value) asFloat64() float64 {
 }
 
 func (v Value) asComplex64() complex64 {
-	return v.value.(complex64)
+	cmplex, _ := v.value.(complex64)
+
+	return cmplex
 }
 
 func (v Value) asComplex128() complex128 {
-	return v.value.(complex128)
+	cmplex, _ := v.value.(complex128)
+
+	return cmplex
 }
 
 func (v Value) asUintptr() uintptr {
-	return v.value.(uintptr)
+	val, _ := v.value.(uintptr)
+
+	return val
 }
 
 func (v Value) asBinary() []byte {
-	return v.value.([]byte)
+	bytes, _ := v.value.([]byte)
+
+	return bytes
 }
 
 func (v Value) asDuration() time.Duration {
-	return v.value.(time.Duration)
+	duration, _ := v.value.(time.Duration)
+
+	return duration
 }
 
 func (v Value) asTime() time.Time {
-	return v.value.(time.Time)
+	value, _ := v.value.(time.Time)
+
+	return value
 }
 
 func (v Value) asError() error {
-	return v.value.(error)
+	err, _ := v.value.(error)
+
+	return err
 }
 
 func nilValue(t Type) Value {

handler/logrus/logger.go

@@ -16,27 +16,27 @@ func Standard() log.Logger {
 
 // New create new logrus handler.
 func New(log *logrus.Logger) log.Logger {
-	return func(ctx context.Context, e *entry.Entry) (int, error) {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
-		lrgFields := make(logrus.Fields, e.Fields().Len())
+		lrgFields := make(logrus.Fields, data.Fields().Len())
-		for _, field := range e.Fields() {
+		for _, field := range data.Fields() {
 			lrgFields[string(field.Key())] = field.AsInterface()
 		}
 
 		entry := log.WithContext(ctx).WithFields(lrgFields)
 
-		switch e.Level() {
+		switch data.Level() {
 		case level.Emergency:
-			entry.Panic(e.Message())
+			entry.Panic(data.Message())
 		case level.Alert:
-			entry.Fatal(e.Message())
+			entry.Fatal(data.Message())
 		case level.Critical, level.Error:
-			entry.Error(e.Message())
+			entry.Error(data.Message())
 		case level.Warning:
-			entry.Warn(e.Message())
+			entry.Warn(data.Message())
 		case level.Notice, level.Info:
-			entry.Info(e.Message())
+			entry.Info(data.Message())
 		case level.Debug:
-			entry.Debug(e.Message())
+			entry.Debug(data.Message())
 		}
 
 		return 0, nil

handler/otel/helpers.go

@@ -38,19 +38,19 @@ func levels(lvl level.Level) Level {
 	return 0
 }
 
-func addEvent(ctx context.Context, e *entry.Entry) {
+func addEvent(ctx context.Context, data *entry.Entry) {
 	span := trace.SpanFromContext(ctx)
-	attrs := make([]attribute.KeyValue, 0, e.Fields().Len()+levelFields)
+	attrs := make([]attribute.KeyValue, 0, data.Fields().Len()+levelFields)
 
-	lvl := levels(e.Level())
+	lvl := levels(data.Level())
 	attrs = append(attrs,
 		attribute.String(fieldSeverityText, lvl.String()),
 		attribute.Int(fieldSeverityNumber, int(lvl)),
 	)
 
-	for _, field := range e.Fields() {
+	for _, field := range data.Fields() {
 		attrs = append(attrs, attribute.String(string(field.Key()), field.Value().String()))
 	}
 
-	span.AddEvent(e.Message(), trace.WithAttributes(attrs...))
+	span.AddEvent(data.Message(), trace.WithAttributes(attrs...))
 }

handler/zap/logger.go

@@ -36,26 +36,26 @@ func Development(options ...zap.Option) log.Logger {
 }
 
 // New create handler by zap logger.
-func New(z *zap.Logger) log.Logger {
+func New(logger *zap.Logger) log.Logger {
-	return func(ctx context.Context, e *entry.Entry) (int, error) {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
-		zf := make([]zap.Field, e.Fields().Len())
+		zf := make([]zap.Field, data.Fields().Len())
-		for i, field := range e.Fields() {
+		for i, field := range data.Fields() {
 			zf[i] = zap.Any(string(field.Key()), field.AsInterface())
 		}
 
-		switch e.Level() {
+		switch data.Level() {
 		case level.Emergency:
-			z.Fatal(e.Message(), zf...)
+			logger.Fatal(data.Message(), zf...)
 		case level.Alert:
-			z.Panic(e.Message(), zf...)
+			logger.Panic(data.Message(), zf...)
 		case level.Critical, level.Error:
-			z.Error(e.Message(), zf...)
+			logger.Error(data.Message(), zf...)
 		case level.Warning:
-			z.Warn(e.Message(), zf...)
+			logger.Warn(data.Message(), zf...)
 		case level.Notice, level.Info:
-			z.Info(e.Message(), zf...)
+			logger.Info(data.Message(), zf...)
 		case level.Debug:
-			z.Debug(e.Message(), zf...)
+			logger.Debug(data.Message(), zf...)
 		}
 
 		return 0, nil

logger.go

@@ -28,56 +28,46 @@ func writeOutput(_ int, err error) {
 // Logger logged message.
 type Logger func(ctx context.Context, entry *entry.Entry) (int, error)
 
-func (l Logger) log(ctx context.Context, level level.Level, args ...interface{}) {
-	writeOutput(l.write(ctx, level, fmt.Sprint(args...)))
-}
-
 func (l Logger) Write(in []byte) (int, error) {
 	return l.write(context.Background(), level.Info, string(in))
 }
 
 func (l Logger) write(ctx context.Context, level level.Level, msg string, fields ...field.Field) (int, error) {
-	e := entry.Get()
+	data := entry.Get()
 
 	defer func() {
-		entry.Put(e)
+		entry.Put(data)
 	}()
 
-	return l(ctx, e.SetLevel(level).SetMessage(msg).Add(fields...))
+	return l(ctx, data.SetLevel(level).SetMessage(msg).Add(fields...))
 }
 
-func (l Logger) logKVs(ctx context.Context, level level.Level, msg string, args ...interface{}) {
+func (l Logger) writef(ctx context.Context, level level.Level, format string, args ...interface{}) (int, error) {
-	writeOutput(l.write(ctx, level, msg, l.kv(ctx, args...)...))
+	data := entry.Get()
-}
 
-func (l Logger) logKV(ctx context.Context, level level.Level, msg string, fields ...field.Field) {
+	defer func() {
-	writeOutput(l.write(ctx, level, msg, fields...))
+		entry.Put(data)
-}
+	}()
 
-func (l Logger) logf(ctx context.Context, level level.Level, format string, args ...interface{}) {
+	return l(ctx, data.SetLevel(level).SetMessagef(format, args...))
-	writeOutput(l.write(ctx, level, fmt.Sprintf(format, args...)))
-}
-
-func (l Logger) logln(ctx context.Context, level level.Level, args ...interface{}) {
-	writeOutput(l.write(ctx, level, fmt.Sprintln(args...)))
 }
 
 func (l Logger) kv(ctx context.Context, args ...interface{}) field.Fields {
-	e := entry.Get()
+	kvEntry := entry.Get()
 
 	defer func() {
-		entry.Put(e)
+		entry.Put(kvEntry)
 	}()
 
 	for i := 0; i < len(args); i++ {
 		if f, ok := args[i].(field.Field); ok {
-			e = e.Add(f)
+			kvEntry = kvEntry.Add(f)
 
 			continue
 		}
 
 		if i == len(args)-1 {
-			l.logKV(ctx, level.Critical, fmt.Sprint("Ignored key without a value.", args[i]), e.Fields()...)
+			writeOutput(l.write(ctx, level.Critical, fmt.Sprint("Ignored key without a value.", args[i]), kvEntry.Fields()...))
 
 			break
 		}
@@ -86,15 +76,15 @@ func (l Logger) kv(ctx context.Context, args ...interface{}) field.Fields {
 
 		key, val := args[i-1], args[i]
 		if keyStr, ok := key.(string); ok {
-			e = e.AddAny(keyStr, val)
+			kvEntry = kvEntry.AddAny(keyStr, val)
 
 			continue
 		}
 
-		l.logKV(ctx, level.Critical, fmt.Sprint("Ignored key-value pairs with non-string keys.", key, val), e.Fields()...)
+		writeOutput(l.write(ctx, level.Critical, fmt.Sprint("Ignored key-value pairs with non-string keys.", key, val), kvEntry.Fields()...))
 	}
 
-	return e.Fields()
+	return kvEntry.Fields()
 }
 
 // With adds middlewares to logger.
@@ -104,207 +94,207 @@ func (l Logger) With(mw ...Middleware) Logger {
 
 // Emerg log by emergency level.
 func (l Logger) Emerg(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Emergency, args...)
+	writeOutput(l.writef(ctx, level.Emergency, "", args...))
 }
 
 // Alert log by alert level.
 func (l Logger) Alert(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Alert, args...)
+	writeOutput(l.writef(ctx, level.Alert, "", args...))
 }
 
 // Crit log by critical level.
 func (l Logger) Crit(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Critical, args...)
+	writeOutput(l.writef(ctx, level.Critical, "", args...))
 }
 
 // Err log by error level.
 func (l Logger) Err(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Error, args...)
+	writeOutput(l.writef(ctx, level.Error, "", args...))
 }
 
 // Warn log by warning level.
 func (l Logger) Warn(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Warning, args...)
+	writeOutput(l.writef(ctx, level.Warning, "", args...))
 }
 
 // Notice log by notice level.
 func (l Logger) Notice(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Notice, args...)
+	writeOutput(l.writef(ctx, level.Notice, "", args...))
 }
 
 // Info log by info level.
 func (l Logger) Info(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Info, args...)
+	writeOutput(l.writef(ctx, level.Info, "", args...))
 }
 
 // Debug log by debug level.
 func (l Logger) Debug(ctx context.Context, args ...interface{}) {
-	l.log(ctx, level.Debug, args...)
+	writeOutput(l.writef(ctx, level.Debug, "", args...))
 }
 
 // Print log by info level and arguments.
 func (l Logger) Print(args ...interface{}) {
-	l.log(context.Background(), level.Info, args...)
+	writeOutput(l.writef(context.Background(), level.Info, "", args...))
 }
 
 // Fatal log by alert level and arguments.
 func (l Logger) Fatal(args ...interface{}) {
-	l.log(context.Background(), level.Alert, args...)
+	writeOutput(l.writef(context.Background(), level.Alert, "", args...))
 }
 
 // Panic log by emergency level and arguments.
 func (l Logger) Panic(args ...interface{}) {
-	l.log(context.Background(), level.Emergency, args...)
+	writeOutput(l.writef(context.Background(), level.Emergency, "", args...))
 }
 
 // Println log by info level and arguments.
 func (l Logger) Println(args ...interface{}) {
-	l.logln(context.Background(), level.Info, args...)
+	writeOutput(l.write(context.Background(), level.Info, fmt.Sprintln(args...)))
 }
 
 // Fatalln log by alert level and arguments.
 func (l Logger) Fatalln(args ...interface{}) {
-	l.logln(context.Background(), level.Alert, args...)
+	writeOutput(l.write(context.Background(), level.Alert, fmt.Sprintln(args...)))
 }
 
 // Panicln log by emergency level and arguments.
 func (l Logger) Panicln(args ...interface{}) {
-	l.logln(context.Background(), level.Emergency, args...)
+	writeOutput(l.write(context.Background(), level.Emergency, fmt.Sprintln(args...)))
 }
 
 // EmergKVs sugared log by emergency level and key-values.
 func (l Logger) EmergKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Emergency, msg, args...)
+	writeOutput(l.write(ctx, level.Emergency, msg, l.kv(ctx, args...)...))
 }
 
 // AlertKVs sugared log by alert level and key-values.
 func (l Logger) AlertKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Alert, msg, args...)
+	writeOutput(l.write(ctx, level.Alert, msg, l.kv(ctx, args...)...))
 }
 
 // CritKVs sugared log by critcal level and key-values.
 func (l Logger) CritKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Critical, msg, args...)
+	writeOutput(l.write(ctx, level.Critical, msg, l.kv(ctx, args...)...))
 }
 
 // ErrKVs sugared log by error level and key-values.
 func (l Logger) ErrKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Error, msg, args...)
+	writeOutput(l.write(ctx, level.Error, msg, l.kv(ctx, args...)...))
 }
 
 // WarnKVs sugared log by warning level and key-values.
 func (l Logger) WarnKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Warning, msg, args...)
+	writeOutput(l.write(ctx, level.Warning, msg, l.kv(ctx, args...)...))
 }
 
 // NoticeKVs sugared log by notice level and key-values.
 func (l Logger) NoticeKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Notice, msg, args...)
+	writeOutput(l.write(ctx, level.Notice, msg, l.kv(ctx, args...)...))
 }
 
 // InfoKVs sugared log by info level and key-values.
 func (l Logger) InfoKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Info, msg, args...)
+	writeOutput(l.write(ctx, level.Info, msg, l.kv(ctx, args...)...))
 }
 
 // DebugKVs sugared log by debug level and key-values.
 func (l Logger) DebugKVs(ctx context.Context, msg string, args ...interface{}) {
-	l.logKVs(ctx, level.Debug, msg, args...)
+	writeOutput(l.write(ctx, level.Debug, msg, l.kv(ctx, args...)...))
 }
 
 // EmergKV log by emergency level and key-values.
 func (l Logger) EmergKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Emergency, msg, args...)
+	writeOutput(l.write(ctx, level.Emergency, msg, args...))
 }
 
 // AlertKV log by alert level and key-values.
 func (l Logger) AlertKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Alert, msg, args...)
+	writeOutput(l.write(ctx, level.Alert, msg, args...))
 }
 
 // CritKV log by critcal level and key-values.
 func (l Logger) CritKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Critical, msg, args...)
+	writeOutput(l.write(ctx, level.Critical, msg, args...))
 }
 
 // ErrKV log by error level and key-values.
 func (l Logger) ErrKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Error, msg, args...)
+	writeOutput(l.write(ctx, level.Error, msg, args...))
 }
 
 // WarnKV log by warning level and key-values.
 func (l Logger) WarnKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Warning, msg, args...)
+	writeOutput(l.write(ctx, level.Warning, msg, args...))
 }
 
 // NoticeKV log by notice level and key-values.
 func (l Logger) NoticeKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Notice, msg, args...)
+	writeOutput(l.write(ctx, level.Notice, msg, args...))
 }
 
 // InfoKV log by info level and key-values.
 func (l Logger) InfoKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Info, msg, args...)
+	writeOutput(l.write(ctx, level.Info, msg, args...))
 }
 
 // DebugKV log by debug level and key-values.
 func (l Logger) DebugKV(ctx context.Context, msg string, args ...field.Field) {
-	l.logKV(ctx, level.Debug, msg, args...)
+	writeOutput(l.write(ctx, level.Debug, msg, args...))
 }
 
 // Emergf log by emergency level by format and arguments.
 func (l Logger) Emergf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Emergency, format, args...)
+	writeOutput(l.writef(ctx, level.Emergency, format, args...))
 }
 
 // Alertf log by alert level by format and arguments.
 func (l Logger) Alertf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Alert, format, args...)
+	writeOutput(l.writef(ctx, level.Alert, format, args...))
 }
 
 // Critf log by critical level by format and arguments.
 func (l Logger) Critf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Critical, format, args...)
+	writeOutput(l.writef(ctx, level.Critical, format, args...))
 }
 
 // Errf log by error level by format and arguments.
 func (l Logger) Errf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Error, format, args...)
+	writeOutput(l.writef(ctx, level.Error, format, args...))
 }
 
 // Warnf log by warning level by format and arguments.
 func (l Logger) Warnf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Warning, format, args...)
+	writeOutput(l.writef(ctx, level.Warning, format, args...))
 }
 
 // Noticef log by notice level by format and arguments.
 func (l Logger) Noticef(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Notice, format, args...)
+	writeOutput(l.writef(ctx, level.Notice, format, args...))
 }
 
 // Infof log by info level by format and arguments.
 func (l Logger) Infof(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Info, format, args...)
+	writeOutput(l.writef(ctx, level.Info, format, args...))
 }
 
 // Debugf log by debug level by format and arguments.
 func (l Logger) Debugf(ctx context.Context, format string, args ...interface{}) {
-	l.logf(ctx, level.Debug, format, args...)
+	writeOutput(l.writef(ctx, level.Debug, format, args...))
 }
 
 // Printf log by info level by format and arguments without context.
 func (l Logger) Printf(format string, args ...interface{}) {
-	l.logf(context.Background(), level.Info, format, args...)
+	writeOutput(l.writef(context.Background(), level.Info, format, args...))
 }
 
 // Fatalf log by alert level by format and arguments without context.
 func (l Logger) Fatalf(format string, args ...interface{}) {
-	l.logf(context.Background(), level.Alert, format, args...)
+	writeOutput(l.writef(context.Background(), level.Alert, format, args...))
 }
 
 // Panicf log by emergency level and arguments without context.
 func (l Logger) Panicf(format string, args ...interface{}) {
-	l.logf(context.Background(), level.Emergency, format, args...)
+	writeOutput(l.writef(context.Background(), level.Emergency, format, args...))
 }
 
 func (l Logger) Writer(ctx context.Context, level level.Level, fields ...field.Field) io.Writer {
@@ -316,6 +306,7 @@ func (l Logger) Writer(ctx context.Context, level level.Level, fields ...field.F
 	}
 }
 
+//nolint: containedctx
 type writer struct {
 	ctx    context.Context
 	level  level.Level

logger_example_caller_test.go

@@ -13,8 +13,10 @@ func ExampleNew_withCaller() {
 	)
 	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 info message" api-version=0.1 level=info caller=logger_example_caller_test.go:15
+	// msg="same write message" level=info caller=logger_example_caller_test.go:16
 }

logger_example_test.go

@@ -52,13 +52,16 @@ func ExampleNew_debugKV() {
 
 func ExampleNew_level() {
 	logger := log.New(log.WithStdout()).With(log.WithLevel("level", level.Error))
-	logger.Info(ctx, "same message")
-	// Output:
-
 	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.Info(ctx, "same message")
+	// Output:
+}
+
 func ExampleNew_jsonFormat() {
 	logger := log.New(log.WithStdout(), log.WithJSONFormat()).
 		With(
@@ -66,7 +69,7 @@ func ExampleNew_jsonFormat() {
 			log.GoVersion("go-version"),
 		)
 	logger.Err(ctx, "same error message")
-	// Output: {"go-version":"go1.17.6","level":"error","msg":"same error message"}
+	// Output: {"go-version":"go1.17.8","level":"error","msg":"same error message"}
 }
 
 func ExampleNew_textEncoding() {
@@ -79,8 +82,8 @@ func ExampleNew_textEncoding() {
 	logger.InfoKVs(ctx, "same info message", "api-version", 0.1)
 
 	// Output:
-	// msg="same error message" level=error go-version=go1.17.6
+	// msg="same error message" level=error go-version=go1.17.8
-	// msg="same info message" api-version=0.1 level=info go-version=go1.17.6
+	// msg="same info message" api-version=0.1 level=info go-version=go1.17.8
 }
 
 type ctxKey string
@@ -102,7 +105,7 @@ func ExampleWith() {
 		levelInfo, 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.17.6
+	// Output: msg="same message" level=info requestID=6a5fa048-7181-11ea-bc55-0242ac130003 api=0.1.0 go=go1.17.8
 }
 
 func ExampleLogger_Print() {
@@ -111,7 +114,7 @@ func ExampleLogger_Print() {
 		levelInfo, 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.17.6
+	// Output: msg="same message" level=info client=http api=0.1.0 go=go1.17.8
 }
 
 func ExamplePrint() {

middleware.go

@@ -30,7 +30,7 @@ func With(logger Logger, mw ...Middleware) Logger {
 
 	lastI := len(mw) - 1
 
-	return func(ctx context.Context, e *entry.Entry) (int, error) {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
 		var (
 			chainHandler func(context.Context, *entry.Entry) (int, error)
 			curI         int
@@ -47,7 +47,7 @@ func With(logger Logger, mw ...Middleware) Logger {
 			return n, err
 		}
 
-		return mw[0](ctx, e, chainHandler)
+		return mw[0](ctx, data, chainHandler)
 	}
 }
 
@@ -62,16 +62,16 @@ func WithLevel(key string, lvl level.Level) Middleware {
 	}
 }
 
-func WithClosure(ctx context.Context, e *entry.Entry, handler Logger) (int, error) {
+func WithClosure(ctx context.Context, data *entry.Entry, handler Logger) (int, error) {
-	for i, field := range e.Fields() {
+	for i, field := range data.Fields() {
 		if field.Type().IsAny() {
 			if f, ok := field.AsInterface().(func() string); ok {
-				e.Fields().Set(i, field.Key().String(f()))
+				data.Fields().Set(i, field.Key().String(f()))
 			}
 		}
 	}
 
-	return handler(ctx, e)
+	return handler(ctx, data)
 }
 
 // KeyValue add field by const key value.

writter.go

@@ -15,19 +15,19 @@ import (
 
 // New creates standart logger.
 func New(opts ...Option) Logger {
-	l := log{e: stringFormat(), w: os.Stderr}
+	logger := log{e: stringFormat(), w: os.Stderr}
 
 	for _, opt := range opts {
-		opt(&l)
+		opt(&logger)
 	}
 
 	return func(_ context.Context, entry *entry.Entry) (int, error) {
-		b, err := l.e(entry)
+		b, err := logger.e(entry)
 		if err != nil {
 			return 0, fmt.Errorf("enode err: %w", err)
 		}
 
-		n, err := l.w.Write(b)
+		n, err := logger.w.Write(b)
 		if err != nil {
 			return 0, fmt.Errorf("failed write: %w", err)
 		}
@@ -85,27 +85,27 @@ func stringFormat() func(entry *entry.Entry) ([]byte, error) {
 	}
 
 	return func(entry *entry.Entry) ([]byte, error) {
-		b := pool.Get().(*bytes.Buffer)
+		buf := pool.Get().(*bytes.Buffer)
-		b.Reset()
+		buf.Reset()
 
 		defer func() {
-			pool.Put(b)
+			pool.Put(buf)
 		}()
 
-		b.WriteString("msg=\"")
+		buf.WriteString("msg=\"")
-		b.WriteString(strings.TrimSpace(entry.Message()))
+		buf.WriteString(strings.TrimSpace(entry.Message()))
-		b.WriteString("\"")
+		buf.WriteString("\"")
 
 		for _, field := range entry.Fields() {
-			b.WriteString(" ")
+			buf.WriteString(" ")
-			b.WriteString(string(field.Key()))
+			buf.WriteString(string(field.Key()))
-			b.WriteString("=")
+			buf.WriteString("=")
-			b.WriteString(field.Value().String())
+			buf.WriteString(field.Value().String())
 		}
 
-		b.WriteString("\n")
+		buf.WriteString("\n")
 
-		return b.Bytes(), nil
+		return buf.Bytes(), nil
 	}
 }