diff --git a/README.md b/README.md
index d71896f..3a5d5d6 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ func main(){
 	// logger will print on STDOUT with default line format
 	l := logger.NewLogger(handler.Stream(os.Stdout, formatter.NewDefaultFormatter(formatter.WithContext(true))))
 	
-	l.Debug("Go debug informations", logger.String("go_os", runtime.GOOS), logger.String("go_arch", runtime.GOARCH))
+	l.Debug("Go debug information", logger.String("go_os", runtime.GOOS), logger.String("go_arch", runtime.GOARCH))
 	// <debug> MyExample message {"go_arch":"amd64","go_os":"darwin"}
 	
 	l.Info("Another")
@@ -97,11 +97,11 @@ Available formatters:
 
 ## Middlewares
 
-The middleware are handler decorator/wrapper. It will allow you to do some process arround child handler 
+The middleware are handler decorator/wrapper. It will allow you to do some process around child handler 
 
 Available middleware:
 - **caller** _it will add caller file/line to context_ `<file:/my/example/path/file> <line:31>`
-- **context** _it permit to have a default context value_ usefull when you want to set global context value
+- **context** _it permit to have a default context value_ useful when you want to set global context value
 - **error** _it will print provided handler error_ (can be configure to silent it)
 - **filter** _it will permit to filter log entry_ level filter are available or you can use your own callback filter
 - **placeholder** _it will replace log message placeholder with contextual value_
@@ -126,7 +126,7 @@ Available writer:
     - socket server
     - https://craig.is/writing/chrome-logger
     - fingercross
-    - grpc / protobuff
+    - grpc / protobuf
     - curl
     - Mail
     - Slack
diff --git a/benchmarks/context_test.go b/benchmarks/context_test.go
index 9ec0a33..a44bce3 100644
--- a/benchmarks/context_test.go
+++ b/benchmarks/context_test.go
@@ -11,8 +11,8 @@ func Benchmark_Context_Typed(b *testing.B) {
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		logger.NewContext().
-			Binary("my binary", []byte{1, 2, 3}). // 2 allocs
-			ByteString("my byte string", []byte{1, 2, 3}) // 2 allocs
+			Binary("my binary", []byte{1, 2, 3}). // 2 allocations
+			ByteString("my byte string", []byte{1, 2, 3}) // 2 allocations
 	}
 }
 
@@ -21,7 +21,7 @@ func Benchmark_Context_Add(b *testing.B) {
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		logger.NewContext().
-			Add("my binary", []byte{1, 2, 3}). // 3 allocs
-			Add("my byte string", []byte{1, 2, 3}) // 3 allocs
+			Add("my binary", []byte{1, 2, 3}). // 3 allocations
+			Add("my byte string", []byte{1, 2, 3}) // 3 allocations
 	}
 }
diff --git a/benchmarks/handler/group_test.go b/benchmarks/handler/group_test.go
index bc44aa0..e045843 100644
--- a/benchmarks/handler/group_test.go
+++ b/benchmarks/handler/group_test.go
@@ -17,6 +17,6 @@ func BenchmarkGroupHandler(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		groupHandler(logger.Entry{Message: "This log message goes nowhere.", Level: logger.InfoLevel})
+		_ = groupHandler(logger.Entry{Message: "This log message goes nowhere.", Level: logger.InfoLevel})
 	}
 }
diff --git a/benchmarks/handler/stream_test.go b/benchmarks/handler/stream_test.go
index 4ccc0d6..ed2eb31 100644
--- a/benchmarks/handler/stream_test.go
+++ b/benchmarks/handler/stream_test.go
@@ -9,7 +9,7 @@ import (
 
 type NopWriter struct{}
 
-func (w *NopWriter) Write(p []byte) (n int, err error) {
+func (w *NopWriter) Write(_ []byte) (n int, err error) {
 	return 0, nil
 }
 
@@ -20,6 +20,6 @@ func BenchmarkStdoutStreamHandler(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		streamHandler(logger.Entry{Message: "This log message goes nowhere.", Level: logger.InfoLevel})
+		_ = streamHandler(logger.Entry{Message: "This log message goes nowhere.", Level: logger.InfoLevel})
 	}
 }
diff --git a/benchmarks/logger_test.go b/benchmarks/logger_test.go
index 327707e..6b038ac 100644
--- a/benchmarks/logger_test.go
+++ b/benchmarks/logger_test.go
@@ -11,7 +11,7 @@ import (
 
 type NopWriter struct{}
 
-func (w *NopWriter) Write(p []byte) (n int, err error) {
+func (w *NopWriter) Write(_ []byte) (n int, err error) {
 	return 0, nil
 }
 
diff --git a/context_test.go b/context_test.go
index 72ac908..a71faa7 100644
--- a/context_test.go
+++ b/context_test.go
@@ -10,24 +10,24 @@ import (
 
 func TestContext_Merge(t *testing.T) {
 	context1 := logger.Context(map[string]logger.Field{
-		"my_key":                  logger.Field{Name: "my_key", Value: "my_value"},
-		"key_gonna_be_overwrited": logger.Field{Name: "key_gonna_be_overwrited", Value: "my_initial_value"},
+		"my_key":                  {Name: "my_key", Value: "my_value"},
+		"key_gonna_be_overwritten": {Name: "key_gonna_be_overwritten", Value: "my_initial_value"},
 	})
 	context2 := logger.Context(map[string]logger.Field{
-		"key_gonna_be_overwrited": logger.Field{Name: "key_gonna_be_overwrited", Value: 2},
-		"new_key":                 logger.Field{Name: "new_key", Value: "my_new_value"},
+		"key_gonna_be_overwritten": {Name: "key_gonna_be_overwritten", Value: 2},
+		"new_key":                 {Name: "new_key", Value: "my_new_value"},
 	})
 
 	(&context1).Merge(context2)
 
 	assert.Equal(t, "my_value", context1["my_key"].Value)
-	assert.Equal(t, 2, context1["key_gonna_be_overwrited"].Value)
+	assert.Equal(t, 2, context1["key_gonna_be_overwritten"].Value)
 	assert.Equal(t, "my_new_value", context1["new_key"].Value)
 }
 
 func TestContext_Has(t *testing.T) {
 	context1 := logger.Context(map[string]logger.Field{
-		"my_key": logger.Field{Name: "my_key", Value: "my_value"},
+		"my_key": {Name: "my_key", Value: "my_value"},
 	})
 
 	assert.True(t, context1.Has("my_key"))
@@ -36,7 +36,7 @@ func TestContext_Has(t *testing.T) {
 
 func TestContext_Get(t *testing.T) {
 	context := logger.Context(map[string]logger.Field{
-		"my_key": logger.Field{Name: "my_key", Value: "my_value"},
+		"my_key": {Name: "my_key", Value: "my_value"},
 	})
 
 	defaultValue := &logger.Field{}
diff --git a/entry.go b/entry.go
index b4a4bab..da67818 100644
--- a/entry.go
+++ b/entry.go
@@ -3,7 +3,7 @@ package logger
 import "strings"
 
 // Entry represents a log in its entirety
-// it is composed of a level, a message and context
+// it is composed of a level, a message and a context
 type Entry struct {
 	Message string
 	Level   Level
diff --git a/field.go b/field.go
index 6378a9a..817d0bf 100644
--- a/field.go
+++ b/field.go
@@ -39,8 +39,8 @@ const (
 	StringerType
 	// ReflectType indicates that the field carries an interface{}, which should be serialized using reflection.
 	ReflectType
-	// @TODO ArrayMarshalerType
-	// @TODO ObjectMarshalerType
+	// @TODO ArrayMarshallerType
+	// @TODO ObjectMarshallerType
 )
 
 // Field represents a contextual information
@@ -62,23 +62,23 @@ func (f *Field) String() string {
 		}
 		return "false"
 	case Int8Type:
-		return strconv.Itoa(int(f.Value.(int8)))
+		return strconv.FormatInt(int64(f.Value.(int8)), 10)
 	case Int16Type:
-		return strconv.Itoa(int(f.Value.(int16)))
+		return strconv.FormatInt(int64(f.Value.(int16)), 10)
 	case Int32Type:
-		return strconv.Itoa(int(f.Value.(int32)))
+		return strconv.FormatInt(int64(f.Value.(int32)), 10)
 	case Int64Type:
-		return strconv.Itoa(int(f.Value.(int64)))
+		return strconv.FormatInt(f.Value.(int64), 10)
 	case Uint8Type:
-		return strconv.Itoa(int(f.Value.(uint8)))
+		return strconv.FormatUint(uint64(f.Value.(uint8)), 10)
 	case Uint16Type:
-		return strconv.Itoa(int(f.Value.(uint16)))
+		return strconv.FormatUint(uint64(f.Value.(uint16)), 10)
 	case Uint32Type:
-		return strconv.Itoa(int(f.Value.(uint32)))
+		return strconv.FormatUint(uint64(f.Value.(uint32)), 10)
 	case Uint64Type:
-		return strconv.Itoa(int(f.Value.(uint64)))
+		return strconv.FormatUint(f.Value.(uint64), 10)
 	case UintptrType:
-		return strconv.Itoa(int(f.Value.(uintptr)))
+		return strconv.FormatUint(uint64(f.Value.(uintptr)), 10)
 	case Float32Type:
 		return strconv.FormatFloat(float64(f.Value.(float32)), 'g', 10, 64)
 	case Float64Type:
@@ -236,7 +236,7 @@ func Reflect(name string, value interface{}) Field {
 	return Field{Name: name, Type: ReflectType, Value: value}
 }
 
-// Any will guess and create Field with givan value
+// Any will guess and create Field for given value
 func Any(name string, value interface{}) Field {
 	switch val := value.(type) {
 	case bool:
diff --git a/field_test.go b/field_test.go
index 61da084..48134fe 100644
--- a/field_test.go
+++ b/field_test.go
@@ -20,7 +20,7 @@ func (s MyStringer) String() string {
 
 func TestField(t *testing.T) {
 	now := time.Now()
-	error := errors.New("my_value")
+	err := errors.New("my_value")
 
 	tests := []struct {
 		name          string
@@ -47,7 +47,7 @@ func TestField(t *testing.T) {
 		{field: logger.String("String field", "my_value"), expectedValue: "my_value", expectedType: logger.StringType},
 		{field: logger.Binary("Binary field", []byte("my_value")), expectedValue: []byte("my_value"), expectedType: logger.BinaryType},
 		{field: logger.ByteString("ByteString field", []byte("my_value")), expectedValue: []byte("my_value"), expectedType: logger.ByteStringType},
-		{field: logger.Error("Error field", error), expectedValue: error, expectedType: logger.ErrorType},
+		{field: logger.Error("Error field", err), expectedValue: err, expectedType: logger.ErrorType},
 		{field: logger.Time("Time field", now), expectedValue: now, expectedType: logger.TimeType},
 		{field: logger.Duration("Duration field", 5 * time.Second), expectedValue: 5 * time.Second, expectedType: logger.DurationType},
 		{field: logger.Stringer("Stringer field", MyStringer{}), expectedValue: MyStringer{}, expectedType: logger.StringerType},
@@ -67,32 +67,30 @@ func TestField_Any(t *testing.T) {
 		name               string
 		value              interface{}
 		expectedType       logger.FieldType
-		expectedMallocs    uint64
-		expectedTotalAlloc uint64
 	}{
-		{name: "my bool", value: true, expectedType: logger.BoolType, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my bool", value: false, expectedType: logger.BoolType, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my int", value: 123, expectedType: logger.Int64Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my int8", value: int8(123), expectedType: logger.Int8Type, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my int16", value: int16(123), expectedType: logger.Int16Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my int32", value: int32(123), expectedType: logger.Int32Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my int64", value: int64(123), expectedType: logger.Int64Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my uint8", value: uint8(123), expectedType: logger.Uint8Type, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my uint16", value: uint16(123), expectedType: logger.Uint16Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my uint32", value: uint32(123), expectedType: logger.Uint32Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my uint64", value: uint64(123), expectedType: logger.Uint64Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my uintptr", value: uintptr(123), expectedType: logger.UintptrType, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my float32", value: float32(123), expectedType: logger.Float32Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my float64", value: float64(123), expectedType: logger.Float64Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my complex64", value: complex64(123), expectedType: logger.Complex64Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my complex128", value: complex128(123), expectedType: logger.Complex128Type, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my string", value: "my string", expectedType: logger.StringType, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my binary", value: []byte{1, 2, 3}, expectedType: logger.BinaryType, expectedMallocs: 1, expectedTotalAlloc: 32},
-		{name: "my error", value: errors.New("my error message"), expectedType: logger.ErrorType, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my time", value: time.Now(), expectedType: logger.TimeType, expectedMallocs: 1, expectedTotalAlloc: 32},
-		{name: "my duration", value: time.Second, expectedType: logger.DurationType, expectedMallocs: 1, expectedTotalAlloc: 16},
-		{name: "my stringer", value: MyStringer{}, expectedType: logger.StringerType, expectedMallocs: 0, expectedTotalAlloc: 0},
-		{name: "my reflect", value: struct{}{}, expectedType: logger.ReflectType, expectedMallocs: 0, expectedTotalAlloc: 0},
+		{name: "my bool", value: true, expectedType: logger.BoolType},
+		{name: "my bool", value: false, expectedType: logger.BoolType},
+		{name: "my int", value: 123, expectedType: logger.Int64Type},
+		{name: "my int8", value: int8(123), expectedType: logger.Int8Type},
+		{name: "my int16", value: int16(123), expectedType: logger.Int16Type},
+		{name: "my int32", value: int32(123), expectedType: logger.Int32Type},
+		{name: "my int64", value: int64(123), expectedType: logger.Int64Type},
+		{name: "my uint8", value: uint8(123), expectedType: logger.Uint8Type},
+		{name: "my uint16", value: uint16(123), expectedType: logger.Uint16Type},
+		{name: "my uint32", value: uint32(123), expectedType: logger.Uint32Type},
+		{name: "my uint64", value: uint64(123), expectedType: logger.Uint64Type},
+		{name: "my uintptr", value: uintptr(123), expectedType: logger.UintptrType},
+		{name: "my float32", value: float32(123), expectedType: logger.Float32Type},
+		{name: "my float64", value: float64(123), expectedType: logger.Float64Type},
+		{name: "my complex64", value: complex64(123), expectedType: logger.Complex64Type},
+		{name: "my complex128", value: complex128(123), expectedType: logger.Complex128Type},
+		{name: "my strings", value: "my strings", expectedType: logger.StringType},
+		{name: "my binary", value: []byte{1, 2, 3}, expectedType: logger.BinaryType},
+		{name: "my error", value: errors.New("my error message"), expectedType: logger.ErrorType},
+		{name: "my time", value: time.Now(), expectedType: logger.TimeType},
+		{name: "my duration", value: time.Second, expectedType: logger.DurationType},
+		{name: "my stringer", value: MyStringer{}, expectedType: logger.StringerType},
+		{name: "my reflect", value: struct{}{}, expectedType: logger.ReflectType},
 	}
 
 	for _, tt := range tests {
@@ -105,7 +103,7 @@ func TestField_Any(t *testing.T) {
 
 func TestField_String(t *testing.T) {
 	now := time.Now()
-	error := errors.New("my_error_value")
+	err := errors.New("my_error_value")
 
 	tests := []struct {
 		name           string
@@ -131,7 +129,7 @@ func TestField_String(t *testing.T) {
 		{field: logger.String("String field", "my_value"), expectedString: "my_value"},
 		{field: logger.Binary("Binary field", []byte{1, 2, 3}), expectedString: "\x01\x02\x03"},
 		{field: logger.ByteString("ByteString field", []byte("my_value")), expectedString: "my_value"},
-		{field: logger.Error("Error field", error), expectedString: "my_error_value"},
+		{field: logger.Error("Error field", err), expectedString: "my_error_value"},
 		{field: logger.Time("Time field", now), expectedString: now.String()},
 		{field: logger.Duration("Duration field", 5 * time.Second), expectedString: "5s"},
 		{field: logger.Stringer("Stringer field", MyStringer{}), expectedString: "my_stringer"},
diff --git a/formatter.go b/formatter.go
index b8cd2f9..3698d93 100644
--- a/formatter.go
+++ b/formatter.go
@@ -10,7 +10,7 @@ type FormatterInterface interface {
 type NopFormatter struct{}
 
 // Format will return empty string
-func (n *NopFormatter) Format(entry Entry) string {
+func (n *NopFormatter) Format(_ Entry) string {
 	return ""
 }
 
diff --git a/formatter/default.go b/formatter/default.go
index 8a538eb..a4ba274 100644
--- a/formatter/default.go
+++ b/formatter/default.go
@@ -55,7 +55,7 @@ func (n *DefaultFormatter) Format(entry logger.Entry) string {
 }
 
 // NewDefaultFormatter will create a new DefaultFormatter
-func NewDefaultFormatter(options ...option) *DefaultFormatter {
+func NewDefaultFormatter(options ...Option) *DefaultFormatter {
 	f := &DefaultFormatter{}
 	for _, option := range options {
 		option(f)
@@ -63,17 +63,18 @@ func NewDefaultFormatter(options ...option) *DefaultFormatter {
 	return f
 }
 
-type option func(*DefaultFormatter)
+// Option is the option pattern interface for the DefaultFormatter
+type Option func(*DefaultFormatter)
 
 // WithColor function will enable ANSI colored formatting
-func WithColor(enable bool) option {
+func WithColor(enable bool) Option {
 	return func(formatter *DefaultFormatter) {
 		formatter.colored = enable
 	}
 }
 
 // WithContext function will display context printing
-func WithContext(enable bool) option {
+func WithContext(enable bool) Option {
 	return func(formatter *DefaultFormatter) {
 		formatter.displayContext = enable
 	}
diff --git a/formatter/default_test.go b/formatter/default_test.go
index 8249d3f..afeb608 100644
--- a/formatter/default_test.go
+++ b/formatter/default_test.go
@@ -60,10 +60,10 @@ func TestDefaultFormatter_Format_AllColor(t *testing.T) {
 		{level: logger.InfoLevel, expected: "\x1b[1;32m<info>\x1b[m my message"},
 		{level: logger.DebugLevel, expected: "\x1b[1;36m<debug>\x1b[m my message"},
 	}
-	formatter := formatter.NewDefaultFormatter(formatter.WithColor(true))
+	defaultFormatter := formatter.NewDefaultFormatter(formatter.WithColor(true))
 	for _, tt := range tests {
 		t.Run(tt.level.String(), func(t *testing.T) {
-			assert.Equal(t, tt.expected, formatter.Format(logger.Entry{Level: tt.level, Message: "my message"}))
+			assert.Equal(t, tt.expected, defaultFormatter.Format(logger.Entry{Level: tt.level, Message: "my message"}))
 		})
 	}
 }
diff --git a/handler/chan_test.go b/handler/chan_test.go
index 1c6b305..beeea73 100644
--- a/handler/chan_test.go
+++ b/handler/chan_test.go
@@ -14,7 +14,7 @@ func TestChan_Handle(t *testing.T) {
 	chanHandler := handler.Chan(entryChan)
 
 	entryContext := logger.Context(map[string]logger.Field{
-		"my_key":       {Value: "my_overwrited_value"},
+		"my_key":       {Value: "my_overwritten_value"},
 		"my_entry_key": {Value: "my_entry_value"},
 	})
 	logEntry := logger.Entry{
diff --git a/handler/gelf_test.go b/handler/gelf_test.go
index 9a8f8e0..b485869 100644
--- a/handler/gelf_test.go
+++ b/handler/gelf_test.go
@@ -54,14 +54,14 @@ func TestGelf_withWrongNetwork(t *testing.T) {
 
 type WrongConn struct{}
 
-func (w *WrongConn) Read(b []byte) (n int, err error)   { return 0, nil }
-func (w *WrongConn) Write(b []byte) (n int, err error)  { return 0, nil }
+func (w *WrongConn) Read(_ []byte) (n int, err error)   { return 0, nil }
+func (w *WrongConn) Write(_ []byte) (n int, err error)  { return 0, nil }
 func (w *WrongConn) Close() error                       { return nil }
 func (w *WrongConn) LocalAddr() net.Addr                { return nil }
-func (w *WrongConn) RemoteAddr() net.Addr               { return nil }
-func (w *WrongConn) SetDeadline(t time.Time) error      { return nil }
-func (w *WrongConn) SetReadDeadline(t time.Time) error  { return nil }
-func (w *WrongConn) SetWriteDeadline(t time.Time) error { return nil }
+func (w *WrongConn) RemoteAddr() net.Addr              { return nil }
+func (w *WrongConn) SetDeadline(_ time.Time) error     { return nil }
+func (w *WrongConn) SetReadDeadline(_ time.Time) error { return nil }
+func (w *WrongConn) SetWriteDeadline(_ time.Time) error { return nil }
 
 func TestGelfFromConnection(t *testing.T) {
 
diff --git a/handler/group.go b/handler/group.go
index 5b5b817..0f2ddd7 100644
--- a/handler/group.go
+++ b/handler/group.go
@@ -4,8 +4,8 @@ import (
 	"github.com/gol4ng/logger"
 )
 
-// Group will send Entry to each underlaying handlers
-// usefull when you want to send your log in multiple destination eg stdOut/file/logserver
+// Group will send Entry to each underlying handlers
+// useful when you want to send your log in multiple destination eg stdOut/file/logserver
 func Group(handlers ...logger.HandlerInterface) logger.HandlerInterface {
 	return func(entry logger.Entry) error {
 		var err error
diff --git a/handler/stream_test.go b/handler/stream_test.go
index 127f0ef..adb9305 100644
--- a/handler/stream_test.go
+++ b/handler/stream_test.go
@@ -3,11 +3,11 @@ package handler_test
 import (
 	"bytes"
 	"errors"
-	"github.com/gol4ng/logger/formatter"
 	"os"
 	"testing"
 
 	"github.com/gol4ng/logger"
+	"github.com/gol4ng/logger/formatter"
 	"github.com/gol4ng/logger/handler"
 	"github.com/gol4ng/logger/mocks"
 	"github.com/stretchr/testify/assert"
@@ -40,7 +40,7 @@ type WriterError struct {
 	Error  error
 }
 
-func (w *WriterError) Write(p []byte) (n int, err error) {
+func (w *WriterError) Write(_ []byte) (n int, err error) {
 	return w.Number, w.Error
 }
 
@@ -51,7 +51,7 @@ func (w *WriterError) Write(p []byte) (n int, err error) {
 func ExampleStream() {
 	lineFormatter := formatter.NewDefaultFormatter()
 	lineLogHandler := handler.Stream(os.Stdout, lineFormatter)
-	lineLogHandler(logger.Entry{Message: "Log example"})
+	_ = lineLogHandler(logger.Entry{Message: "Log example"})
 
 	//Output:
 	//<emergency> Log example
diff --git a/logger.go b/logger.go
index 7b4e3ee..79fdb37 100644
--- a/logger.go
+++ b/logger.go
@@ -5,7 +5,7 @@ import (
 	"log"
 )
 
-// ErrorHandler will print error and entry when logging error occured
+// ErrorHandler will print error and entry when logging error occurred
 func ErrorHandler(error error, entry Entry) {
 	log.Println(error, entry)
 }
diff --git a/logger_test.go b/logger_test.go
index 868e77f..6da4ad6 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -272,7 +272,7 @@ func ExampleLogger_callerHandler() {
 	myLogger.Alert("Log example")
 	myLogger.Emergency("Log example")
 
-	output.Constains([]string{
+	output.Contains([]string{
 		"lvl: debug | msg: Log example | ctx:", "<file:/", "<line:",
 		"lvl: info | msg: Log example | ctx:", "<file:/", "<line:",
 		"lvl: notice | msg: Log example | ctx:", "<file:/", "<line:",
@@ -301,7 +301,7 @@ func ExampleLogger_lineFormatter() {
 	myLogger.Alert("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Emergency("Log example", logger.Any("my_key", "my_value"))
 
-	output.Constains([]string{
+	output.Contains([]string{
 		"lvl: debug | msg: Log example | ctx: <my_key:my_value>",
 		"lvl: info | msg: Log example | ctx: <my_key:my_value>",
 		"lvl: notice | msg: Log example | ctx: <my_key:my_value>",
@@ -330,7 +330,7 @@ func ExampleLogger_jsonFormatter() {
 	myLogger.Alert("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Emergency("Log example", logger.Any("my_key", "my_value"))
 
-	output.Constains([]string{
+	output.Contains([]string{
 		`{"Message":"Log example","Level":7,"Context":{"my_key":"my_value"}}`,
 		`{"Message":"Log example","Level":6,"Context":{"my_key":"my_value"}}`,
 		`{"Message":"Log example","Level":5,"Context":{"my_key":"my_value"}}`,
@@ -361,7 +361,7 @@ func ExampleLogger_minLevelFilterHandler() {
 	myLogger.Alert("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Emergency("Log example", logger.Any("my_key", "my_value"))
 
-	output.Constains([]string{
+	output.Contains([]string{
 		`<warning> Log example {"my_key":"my_value"}`,
 		`<error> Log example {"my_key":"my_value"}`,
 		`<critical> Log example {"my_key":"my_value"}`,
@@ -391,7 +391,7 @@ func ExampleLogger_groupHandler() {
 	myLogger.Alert("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Emergency("Log example", logger.Any("my_key", "my_value"))
 
-	output.Constains([]string{
+	output.Contains([]string{
 		`{"Message":"Log example","Level":7,"Context":{"my_key":"my_value"}}`,
 		`{"Message":"Log example","Level":6,"Context":{"my_key":"my_value"}}`,
 		`{"Message":"Log example","Level":5,"Context":{"my_key":"my_value"}}`,
@@ -402,7 +402,7 @@ func ExampleLogger_groupHandler() {
 		`{"Message":"Log example","Level":0,"Context":{"my_key":"my_value"}}`,
 	})
 
-	output2.Constains([]string{
+	output2.Contains([]string{
 		`<debug> Log example {"my_key":"my_value"}`,
 		`<info> Log example {"my_key":"my_value"}`,
 		`<notice> Log example {"my_key":"my_value"}`,
@@ -430,7 +430,7 @@ func ExampleLogger_placeholderMiddleware() {
 	myLogger.Alert("Log %ctx_key% example", logger.Any("ctx_key", struct{ attr string }{attr: "attrValue"}))
 	myLogger.Critical("Log %ctx_key% example another value %ctx_key2%", logger.Any("ctx_key", false), logger.Any("ctx_key2", 1234))
 
-	output.Constains([]string{
+	output.Contains([]string{
 		`debug Log false example`,
 		`info Log 1234 example`,
 		`warning Log 5s example`,
@@ -457,7 +457,7 @@ func ExampleLogger_wrapHandler() {
 	myLogger.Critical("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Alert("Log example", logger.Any("my_key", "my_value"))
 	myLogger.Emergency("Log example", logger.Any("my_key", "my_value"))
-	output.Constains([]string{
+	output.Contains([]string{
 		`<warning> Log example {"my_key":"my_value"}`,
 		`<error> Log example {"my_key":"my_value"}`,
 		`<critical> Log example {"my_key":"my_value"}`,
@@ -535,7 +535,7 @@ type Output struct {
 	bytes.Buffer
 }
 
-func (o *Output) Constains(str []string) {
+func (o *Output) Contains(str []string) {
 	b := o.String()
 	for _, s := range str {
 		if strings.Contains(b, s) != true {
diff --git a/middleware/context_test.go b/middleware/context_test.go
index 76dfb8b..1b1f26b 100644
--- a/middleware/context_test.go
+++ b/middleware/context_test.go
@@ -17,7 +17,7 @@ func TestContext_Handle(t *testing.T) {
 		assert.Equal(t, "my_log_message", entry.Message)
 		assert.Equal(t, logger.DebugLevel, entry.Level)
 		contextStr := entry.Context.String()
-		assert.Contains(t, contextStr, "<my_key:my_overwrited_value>")
+		assert.Contains(t, contextStr, "<my_key:my_overwritten_value>")
 		assert.Contains(t, contextStr, "<my_entry_key:my_entry_value>")
 
 		return nil
@@ -30,7 +30,7 @@ func TestContext_Handle(t *testing.T) {
 	context := middleware.Context(&defaultContext)
 
 	entryContext := logger.Context(map[string]logger.Field{
-		"my_key":       {Value: "my_overwrited_value"},
+		"my_key":       {Value: "my_overwritten_value"},
 		"my_entry_key": {Value: "my_entry_value"},
 	})
 	logEntry := logger.Entry{
@@ -50,12 +50,12 @@ func ExampleContext() {
 	contextHandler := middleware.Context(logger.Ctx("my_value_1", "value 1"))
 
 	myLogger := logger.NewLogger(handler.Group(contextHandler(streamHandler), streamHandler))
-	myLogger.Debug("will be printed", logger.Any("my_value_1", "overwrited value 1"))
+	myLogger.Debug("will be printed", logger.Any("my_value_1", "overwritten value 1"))
 	myLogger.Debug("only context handler values will be printed")
 
 	//Output:
-	//{"Message":"will be printed","Level":7,"Context":{"my_value_1":"overwrited value 1"}}
-	//{"Message":"will be printed","Level":7,"Context":{"my_value_1":"overwrited value 1"}}
+	//{"Message":"will be printed","Level":7,"Context":{"my_value_1":"overwritten value 1"}}
+	//{"Message":"will be printed","Level":7,"Context":{"my_value_1":"overwritten value 1"}}
 	//{"Message":"only context handler values will be printed","Level":7,"Context":{"my_value_1":"value 1"}}
 	//{"Message":"only context handler values will be printed","Level":7,"Context":null}
 }
diff --git a/middleware/error_test.go b/middleware/error_test.go
index 957f618..bf948cd 100644
--- a/middleware/error_test.go
+++ b/middleware/error_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/gol4ng/logger/middleware"
 )
 
-func TestError_PassThrought(t *testing.T) {
+func TestError_PassThrough(t *testing.T) {
 	logEntry := logger.Entry{}
 	e := errors.New("my_fake_error")
 
diff --git a/middleware/filter.go b/middleware/filter.go
index 060cbf4..0dffa60 100644
--- a/middleware/filter.go
+++ b/middleware/filter.go
@@ -4,7 +4,7 @@ import (
 	"github.com/gol4ng/logger"
 )
 
-// Filter will exclude some Entry for the underlaying handler with the given filter function
+// Filter will exclude some Entry for the underlying handler with the given filter function
 // eg: allows you to only treat the logs that have a specific level
 func Filter(filterFn func(logger.Entry) bool) logger.MiddlewareInterface {
 	return func(handler logger.HandlerInterface) logger.HandlerInterface {
diff --git a/middleware/filter_test.go b/middleware/filter_test.go
index 2e6510e..666c6e5 100644
--- a/middleware/filter_test.go
+++ b/middleware/filter_test.go
@@ -18,7 +18,7 @@ func TestFilter_HandleWithoutExclusion(t *testing.T) {
 		assert.Equal(t, "my_log_message", entry.Message)
 		assert.Equal(t, logger.DebugLevel, entry.Level)
 		contextStr := entry.Context.String()
-		assert.Contains(t, contextStr, "<my_key:my_overwrited_value>")
+		assert.Contains(t, contextStr, "<my_key:my_overwritten_value>")
 		assert.Contains(t, contextStr, "<my_entry_key:my_entry_value>")
 
 		return nil
diff --git a/mocks/wrapper.go b/mocks/wrapper.go
deleted file mode 100644
index 88d13c2..0000000
--- a/mocks/wrapper.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package mocks
-
-import (
-	"strings"
-
-	"github.com/gol4ng/logger"
-)
-
-// DecorateMockWrapper will decorate a WrappableLoggerInterface with a real Logger+middlewares in order to have middleware properly working
-//
-// 	myLogger := &mocks.WrappableLoggerInterface{}
-//	newWrapperLogger := &mocks.WrappableLoggerInterface{}
-//
-//	myLogger.On("WrapNew", mock.AnythingOfType("logger.MiddlewareInterface")).Return(mocks.DecorateMockWrapper(newWrapperLogger))
-func DecorateMockWrapper(mockWrapperLoggerInterface *WrappableLoggerInterface) func(middlewares ...logger.MiddlewareInterface) logger.LoggerInterface {
-	return func(middlewares ...logger.MiddlewareInterface) logger.LoggerInterface {
-		h := func(entry logger.Entry) error {
-			mockWrapperLoggerInterface.MethodCalled(strings.Title(entry.Level.String()), entry.Message, entry.Context)
-			return nil
-		}
-		for _, middleware := range middlewares {
-			h = middleware(h)
-		}
-		return logger.NewLogger(h)
-	}
-}
diff --git a/writer/compress.go b/writer/compress.go
index ed44304..833e16d 100644
--- a/writer/compress.go
+++ b/writer/compress.go
@@ -42,7 +42,7 @@ type CompressWriter struct {
 	compressionLevel int
 }
 
-// Write will compress data and pass it to the underlaying io.Writer
+// Write will compress data and pass it to the underlying io.Writer
 func (w *CompressWriter) Write(p []byte) (int, error) {
 	if w.compressionType == CompressNone {
 		return w.Writer.Write(p)
@@ -64,10 +64,10 @@ func (w *CompressWriter) Write(p []byte) (int, error) {
 	}
 
 	if n, err := compressWriter.Write(p); err != nil {
-		compressWriter.Close()
+		_ = compressWriter.Close()
 		return n, err
 	}
-	compressWriter.Close()
+	_ = compressWriter.Close()
 
 	return w.Writer.Write(buf.Bytes())
 }
diff --git a/writer/gelf_chunked.go b/writer/gelf_chunked.go
index 8e1ec04..a42d979 100644
--- a/writer/gelf_chunked.go
+++ b/writer/gelf_chunked.go
@@ -41,12 +41,14 @@ func (w *GelfChunkWriter) Write(p []byte) (int, error) {
 
 	if chunkedNb > 1 {
 		messageID := make([]byte, 8)
-		if n, err := io.ReadFull(rand.Reader, messageID); err != nil || n != 8 {
-			return 0, fmt.Errorf("message id can not be generated : %s", err.Error())
+		if n, err := io.ReadFull(rand.Reader, messageID); err != nil {
+			return 0, fmt.Errorf("message id can not be generated : %w", err)
+		} else if n != 8 {
+			return 0, fmt.Errorf("message id can not be generated : cannot write 8 bytes (only %d)", n)
 		}
 		buffer := bytes.NewBuffer(make([]byte, 0, chunkSize))
 		bytesLeft := lenB
-		writedBytes := 0
+		writtenBytes := 0
 		for i := 0; i < chunkedNb; i++ {
 			off := i * chunkDataSize
 			chunkLen := chunkDataSize
@@ -62,13 +64,13 @@ func (w *GelfChunkWriter) Write(p []byte) (int, error) {
 			buffer.Write(p[off : off+chunkLen])
 
 			n, err := w.writer.Write(buffer.Bytes())
-			writedBytes += n
+			writtenBytes += n
 			if err != nil {
-				return writedBytes, err
+				return writtenBytes, err
 			}
 			bytesLeft -= chunkLen
 		}
-		return writedBytes, nil
+		return writtenBytes, nil
 	}
 	return w.writer.Write(p)
 }
diff --git a/writer/provider/compress_test.go b/writer/provider/compress_test.go
index 2ece65f..b6f5218 100644
--- a/writer/provider/compress_test.go
+++ b/writer/provider/compress_test.go
@@ -13,13 +13,13 @@ import (
 )
 
 func TestCompressProvider_WithError(t *testing.T) {
-	var writer io.Writer
+	var writer1 io.Writer
 	var MyProvider = func(w io.Writer) (io.Writer, error) {
-		assert.Equal(t, writer, w)
+		assert.Equal(t, writer1, w)
 		return w, errors.New("my_fake_provider_error")
 	}
 	w := provider.CompressProvider(MyProvider)
-	file, err := w(writer)
+	file, err := w(writer1)
 	assert.Nil(t, file)
 	assert.EqualError(t, err, "my_fake_provider_error")
 }
diff --git a/writer/rotate_io_writer.go b/writer/rotate_io_writer.go
index b02be8a..9b26933 100644
--- a/writer/rotate_io_writer.go
+++ b/writer/rotate_io_writer.go
@@ -20,7 +20,7 @@ func (w *RotateIoWriter) Write(output []byte) (int, error) {
 	return w.writer.Write(output)
 }
 
-// Rotate will ask the provider to change the underlaing io.writer with a new one
+// Rotate will ask the provider to change the underlying io.writer with a new one
 func (w *RotateIoWriter) Rotate() (err error) {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
diff --git a/writer/time_rotate_test.go b/writer/time_rotate_test.go
index 19b261b..2b611a9 100644
--- a/writer/time_rotate_test.go
+++ b/writer/time_rotate_test.go
@@ -39,7 +39,7 @@ func TestTimeRotateWriter_StartWithError(t *testing.T) {
 	tr.Start()
 	mockRotateWriter.AssertNotCalled(t, "Rotate")
 	tickerChan <- time.Now()
-	time.Sleep(1 * time.Millisecond) //we have to wait a bit to be shure Rotate call has been made
+	time.Sleep(1 * time.Millisecond) //we have to wait a bit to be sure Rotate call has been made
 	mockRotateWriter.AssertCalled(t, "Rotate")
 }