skip check error in example

upddate caller write method
Merge pull request 'update golang' (#4 ) from fields into master
2022-03-14 09:45:40 +03:00 · 2022-03-14 09:37:48 +03:00 · 2022-03-13 13:17:01 +03:00 · 2022-03-13 12:01:36 +03:00 · 2022-03-13 11:10:16 +03:00 · 2022-03-12 20:00:01 +03:00
19 changed files with 278 additions and 204 deletions
--- a/.drone.yml
+++ b/.drone.yml
@@ -3,7 +3,7 @@ name: default

 steps:
 - name: test 
-  image: golang:1.17.1
+  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

--- a/.golangci.yml
+++ b/.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
--- a/2
+++ b/2
@@ -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
--- a/entry/caller.go
+++ b/entry/caller.go
@@ -7,14 +7,14 @@ import (
 )

 func Caller(depth int, full bool) string {
-	const offset = 4
-	_, file, line, ok := runtime.Caller(depth + offset)
+	const offset = 3
+	_, file, line, has := runtime.Caller(depth + offset)

-	if !ok {
+	if !has {
 		file, line = "???", 0
 	}

-	if !full && ok {
+	if !full && has {
 		file = filepath.Base(file)
 	}

--- a/entry/entry.go
+++ b/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
 }
--- a/field/fields.go
+++ b/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
 }
--- a/field/fields_test.go
+++ b/field/fields_test.go
@@ -0,0 +1,17 @@
+package field_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gitoa.ru/go-4devs/log/field"
+)
+
+func TestFields_Append(t *testing.T) {
+	t.Parallel()
+
+	fields := field.Fields{field.Any("any", "value")}
+	fields = fields.Append(field.String("string", "value"))
+
+	require.Len(t, fields, 2)
+}
--- a/field/key.go
+++ b/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{
--- a/field/value.go
+++ b/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 {
--- a/go.mod
+++ b/go.mod
@@ -4,15 +4,19 @@ go 1.17

 require (
 	github.com/sirupsen/logrus v1.8.1
+	github.com/stretchr/testify v1.7.0
 	go.opentelemetry.io/otel v0.20.0
 	go.opentelemetry.io/otel/sdk v0.20.0
 	go.opentelemetry.io/otel/trace v0.20.0
-	go.uber.org/zap v1.19.1
+	go.uber.org/zap v1.21.0
 )

 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	go.opentelemetry.io/otel/metric v0.20.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -5,8 +5,10 @@ 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/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -34,10 +36,13 @@ go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723 h1:sHOAIxRGBp443oHZIPB+HsUGaksVCXVQENPxwTfQdH4=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/zap v1.19.1 h1:ue41HOKd1vGURxrmeKIgELGb3jPW9DMUDGtsinblHwI=
 go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI=
+go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
+go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
@@ -67,6 +72,7 @@ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/handler/logrus/logger.go
+++ b/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) {
-		lrgFields := make(logrus.Fields, e.Fields().Len())
-		for _, field := range e.Fields() {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
+		lrgFields := make(logrus.Fields, data.Fields().Len())
+		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
--- a/handler/otel/helpers.go
+++ b/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...))
 }
--- a/handler/zap/logger.go
+++ b/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 {
-	return func(ctx context.Context, e *entry.Entry) (int, error) {
-		zf := make([]zap.Field, e.Fields().Len())
-		for i, field := range e.Fields() {
+func New(logger *zap.Logger) log.Logger {
+	return func(ctx context.Context, data *entry.Entry) (int, error) {
+		zf := make([]zap.Field, data.Fields().Len())
+		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
--- a/logger.go
+++ b/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{}) {
-	writeOutput(l.write(ctx, level, msg, l.kv(ctx, args...)...))
-}
+func (l Logger) writef(ctx context.Context, level level.Level, format string, args ...interface{}) (int, error) {
+	data := entry.Get()

-func (l Logger) logKV(ctx context.Context, level level.Level, msg string, fields ...field.Field) {
-	writeOutput(l.write(ctx, level, msg, fields...))
-}
+	defer func() {
+		entry.Put(data)
+	}()

-func (l Logger) logf(ctx context.Context, level level.Level, format string, args ...interface{}) {
-	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...)))
+	return l(ctx, data.SetLevel(level).SetMessagef(format, 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
--- a/logger_example_caller_test.go
+++ b/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
 }
--- a/logger_example_test.go
+++ b/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.1","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.1
-	// msg="same info message" api-version=0.1 level=info go-version=go1.17.1
+	// 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.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.1
+	// 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.1
+	// Output: msg="same message" level=info client=http api=0.1.0 go=go1.17.8
 }

 func ExamplePrint() {
--- a/middleware.go
+++ b/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) {
-	for i, field := range e.Fields() {
+func WithClosure(ctx context.Context, data *entry.Entry, handler Logger) (int, error) {
+	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.
--- a/writter.go
+++ b/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)
-		b.Reset()
+		buf := pool.Get().(*bytes.Buffer)
+		buf.Reset()

 		defer func() {
-			pool.Put(b)
+			pool.Put(buf)
 		}()

-		b.WriteString("msg=\"")
-		b.WriteString(strings.TrimSpace(entry.Message()))
-		b.WriteString("\"")
+		buf.WriteString("msg=\"")
+		buf.WriteString(strings.TrimSpace(entry.Message()))
+		buf.WriteString("\"")

 		for _, field := range entry.Fields() {
-			b.WriteString(" ")
-			b.WriteString(string(field.Key()))
-			b.WriteString("=")
-			b.WriteString(field.Value().String())
+			buf.WriteString(" ")
+			buf.WriteString(string(field.Key()))
+			buf.WriteString("=")
+			buf.WriteString(field.Value().String())
 		}

-		b.WriteString("\n")
+		buf.WriteString("\n")

-		return b.Bytes(), nil
+		return buf.Bytes(), nil
 	}
 }
Author	SHA1	Message	Date
andrey1s	fac9762f72	skip check error in example All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/pr Build is passing Details continuous-integration/drone/tag Build is passing Details	2022-03-14 09:45:40 +03:00
andrey1s	0dc4c80cc2	upddate caller write method Some checks failed continuous-integration/drone/push Build is failing Details continuous-integration/drone/pr Build is failing Details	2022-03-14 09:37:48 +03:00
andrey	012e2ce197	Merge pull request 'update golang' (#4 ) from fields into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #4	2022-03-13 13:17:01 +03:00
andrey1s	51b844d50b	update golang All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/pr Build is passing Details	2022-03-13 12:01:36 +03:00
andrey	f70653066a	Merge pull request 'add test append fields' (#2 ) from fields into master Some checks failed continuous-integration/drone/push Build is failing Details Reviewed-on: #2	2022-03-13 11:10:16 +03:00
andrey1s	21c14e24be	update go version Some checks failed continuous-integration/drone/push Build is failing Details	2022-03-12 20:00:01 +03:00
andrey1s	d7310ed1df	add test append fields	2022-03-12 10:01:11 +03:00