@@ -10,8 +10,7 @@ github.com/moby/locker                              281af2d563954745bea9d1487c96

 github.com/moby/term                                7f0af18e79f2784809e9cef63d0df5aa2c79d76e

 github.com/creack/pty                               3a6a957789163cacdfe0e291617a1c8e80612c11 # v1.1.9

-github.com/konsorten/go-windows-terminal-sequences  edb144dfd453055e1e49a3d8b410a660b5a87613 # v1.0.3

-github.com/sirupsen/logrus                          60c74ad9be0d874af0ab0daef6ab07c5c5911f0d # v1.6.0

+github.com/sirupsen/logrus                          6699a89a232f3db797f2e280639854bbc4b89725 # v1.7.0

 github.com/tchap/go-patricia                        a7f0089c6f496e8e70402f61733606daa326cac5 # v2.3.0

 golang.org/x/net                                    ab34263943818b32f575efc978a3d24e80b04bd7

 golang.org/x/sys                                    aee5d888a86055dc6ab0342f9cdc7b53aaeaec62

deleted file mode 100644

@@ -1,9 +0,0 @@

-(The MIT License)

-

-Copyright (c) 2017 marvin + konsorten GmbH (open-source@konsorten.de)

-

-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

-

-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

-

-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

deleted file mode 100644

@@ -1,42 +0,0 @@

-# Windows Terminal Sequences

-

-This library allow for enabling Windows terminal color support for Go.

-

-See [Console Virtual Terminal Sequences](https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences) for details.

-

-## Usage

-

-```go

-import (

-	"syscall"

-	

-	sequences "github.com/konsorten/go-windows-terminal-sequences"

-)

-

-func main() {

-	sequences.EnableVirtualTerminalProcessing(syscall.Stdout, true)

-}

-

-```

-

-## Authors

-

-The tool is sponsored by the [marvin + konsorten GmbH](http://www.konsorten.de).

-

-We thank all the authors who provided code to this library:

-

-* Felix Kollmann

-* Nicolas Perraut

-* @dirty49374

-

-## License

-

-(The MIT License)

-

-Copyright (c) 2018 marvin + konsorten GmbH (open-source@konsorten.de)

-

-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

-

-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

-

-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

deleted file mode 100644

@@ -1 +0,0 @@

-module github.com/konsorten/go-windows-terminal-sequences

deleted file mode 100644

@@ -1,35 +0,0 @@

-// +build windows

-

-package sequences

-

-import (

-	"syscall"

-)

-

-var (

-	kernel32Dll    *syscall.LazyDLL  = syscall.NewLazyDLL("Kernel32.dll")

-	setConsoleMode *syscall.LazyProc = kernel32Dll.NewProc("SetConsoleMode")

-)

-

-func EnableVirtualTerminalProcessing(stream syscall.Handle, enable bool) error {

-	const ENABLE_VIRTUAL_TERMINAL_PROCESSING uint32 = 0x4

-

-	var mode uint32

-	err := syscall.GetConsoleMode(syscall.Stdout, &mode)

-	if err != nil {

-		return err

-	}

-

-	if enable {

-		mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING

-	} else {

-		mode &^= ENABLE_VIRTUAL_TERMINAL_PROCESSING

-	}

-

-	ret, _, err := setConsoleMode.Call(uintptr(stream), uintptr(mode))

-	if ret == 0 {

-		return err

-	}

-

-	return nil

-}

deleted file mode 100644

@@ -1,11 +0,0 @@

-// +build linux darwin

-

-package sequences

-

-import (

-	"fmt"

-)

-

-func EnableVirtualTerminalProcessing(stream uintptr, enable bool) error {

-	return fmt.Errorf("windows only package")

-}

new file mode 100644

@@ -0,0 +1,52 @@

+package logrus

+

+import (

+	"bytes"

+	"sync"

+)

+

+var (

+	bufferPool BufferPool

+)

+

+type BufferPool interface {

+	Put(*bytes.Buffer)

+	Get() *bytes.Buffer

+}

+

+type defaultPool struct {

+	pool *sync.Pool

+}

+

+func (p *defaultPool) Put(buf *bytes.Buffer) {

+	p.pool.Put(buf)

+}

+

+func (p *defaultPool) Get() *bytes.Buffer {

+	return p.pool.Get().(*bytes.Buffer)

+}

+

+func getBuffer() *bytes.Buffer {

+	return bufferPool.Get()

+}

+

+func putBuffer(buf *bytes.Buffer) {

+	buf.Reset()

+	bufferPool.Put(buf)

+}

+

+// SetBufferPool allows to replace the default logrus buffer pool

+// to better meets the specific needs of an application.

+func SetBufferPool(bp BufferPool) {

+	bufferPool = bp

+}

+

+func init() {

+	SetBufferPool(&defaultPool{

+		pool: &sync.Pool{

+			New: func() interface{} {

+				return new(bytes.Buffer)

+			},

+		},

+	})

+}

@@ -13,7 +13,6 @@ import (

 )

 var (

-	bufferPool *sync.Pool

 	// qualified package name, cached at first use

 	logrusPackage string

@@ -31,12 +30,6 @@ const (

 )

 func init() {

-	bufferPool = &sync.Pool{

-		New: func() interface{} {

-			return new(bytes.Buffer)

-		},

-	}

-

 	// start at the bottom of the stack before the package-name cache is primed

 	minimumCallerDepth = 1

 }

@@ -243,9 +236,12 @@ func (entry Entry) log(level Level, msg string) {

 	entry.fireHooks()

-	buffer = bufferPool.Get().(*bytes.Buffer)

+	buffer = getBuffer()

+	defer func() {

+		entry.Buffer = nil

+		putBuffer(buffer)

+	}()

 	buffer.Reset()

-	defer bufferPool.Put(buffer)

 	entry.Buffer = buffer

 	entry.write()

@@ -134,6 +134,51 @@ func Fatal(args ...interface{}) {

 	std.Fatal(args...)

 }

+// TraceFn logs a message from a func at level Trace on the standard logger.

+func TraceFn(fn LogFunction) {

+	std.TraceFn(fn)

+}

+

+// DebugFn logs a message from a func at level Debug on the standard logger.

+func DebugFn(fn LogFunction) {

+	std.DebugFn(fn)

+}

+

+// PrintFn logs a message from a func at level Info on the standard logger.

+func PrintFn(fn LogFunction) {

+	std.PrintFn(fn)

+}

+

+// InfoFn logs a message from a func at level Info on the standard logger.

+func InfoFn(fn LogFunction) {

+	std.InfoFn(fn)

+}

+

+// WarnFn logs a message from a func at level Warn on the standard logger.

+func WarnFn(fn LogFunction) {

+	std.WarnFn(fn)

+}

+

+// WarningFn logs a message from a func at level Warn on the standard logger.

+func WarningFn(fn LogFunction) {

+	std.WarningFn(fn)

+}

+

+// ErrorFn logs a message from a func at level Error on the standard logger.

+func ErrorFn(fn LogFunction) {

+	std.ErrorFn(fn)

+}

+

+// PanicFn logs a message from a func at level Panic on the standard logger.

+func PanicFn(fn LogFunction) {

+	std.PanicFn(fn)

+}

+

+// FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1.

+func FatalFn(fn LogFunction) {

+	std.FatalFn(fn)

+}

+

 // Tracef logs a message at level Trace on the standard logger.

 func Tracef(format string, args ...interface{}) {

 	std.Tracef(format, args...)

@@ -2,10 +2,9 @@ module github.com/sirupsen/logrus

 require (

 	github.com/davecgh/go-spew v1.1.1 // indirect

-	github.com/konsorten/go-windows-terminal-sequences v1.0.3

 	github.com/pmezard/go-difflib v1.0.0 // indirect

 	github.com/stretchr/testify v1.2.2

-	golang.org/x/sys v0.0.0-20190422165155-953cdadca894

+	golang.org/x/sys v0.0.0-20191026070338-33540a1f6037

 )

 go 1.13

@@ -9,6 +9,11 @@ import (

 	"time"

 )

+// LogFunction For big messages, it can be more efficient to pass a function

+// and only call it if the log level is actually enables rather than

+// generating the log message and then checking if the level is enabled

+type LogFunction func()[]interface{}

+

 type Logger struct {

 	// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a

 	// file, or leave it default which is `os.Stderr`. You can also set this to

@@ -70,7 +75,7 @@ func (mw *MutexWrap) Disable() {

 //

 //    var log = &logrus.Logger{

 //      Out: os.Stderr,

-//      Formatter: new(logrus.JSONFormatter),

+//      Formatter: new(logrus.TextFormatter),

 //      Hooks: make(logrus.LevelHooks),

 //      Level: logrus.DebugLevel,

 //    }

@@ -195,6 +200,14 @@ func (logger *Logger) Log(level Level, args ...interface{}) {

 	}

 }

+func (logger *Logger) LogFn(level Level, fn LogFunction) {

+	if logger.IsLevelEnabled(level) {

+		entry := logger.newEntry()

+		entry.Log(level, fn()...)

+		logger.releaseEntry(entry)

+	}

+}

+

 func (logger *Logger) Trace(args ...interface{}) {

 	logger.Log(TraceLevel, args...)

 }

@@ -234,6 +247,45 @@ func (logger *Logger) Panic(args ...interface{}) {

 	logger.Log(PanicLevel, args...)

 }

+func (logger *Logger) TraceFn(fn LogFunction) {

+	logger.LogFn(TraceLevel, fn)

+}

+

+func (logger *Logger) DebugFn(fn LogFunction) {

+	logger.LogFn(DebugLevel, fn)

+}

+

+func (logger *Logger) InfoFn(fn LogFunction) {

+	logger.LogFn(InfoLevel, fn)

+}

+

+func (logger *Logger) PrintFn(fn LogFunction) {

+	entry := logger.newEntry()

+	entry.Print(fn()...)

+	logger.releaseEntry(entry)

+}

+

+func (logger *Logger) WarnFn(fn LogFunction) {

+	logger.LogFn(WarnLevel, fn)

+}

+

+func (logger *Logger) WarningFn(fn LogFunction) {

+	logger.WarnFn(fn)

+}

+

+func (logger *Logger) ErrorFn(fn LogFunction) {

+	logger.LogFn(ErrorLevel, fn)

+}

+

+func (logger *Logger) FatalFn(fn LogFunction) {

+	logger.LogFn(FatalLevel, fn)

+	logger.Exit(1)

+}

+

+func (logger *Logger) PanicFn(fn LogFunction) {

+	logger.LogFn(PanicLevel, fn)

+}

+

 func (logger *Logger) Logln(level Level, args ...interface{}) {

 	if logger.IsLevelEnabled(level) {

 		entry := logger.newEntry()

@@ -5,30 +5,23 @@ package logrus

 import (

 	"io"

 	"os"

-	"syscall"

-	sequences "github.com/konsorten/go-windows-terminal-sequences"

+	"golang.org/x/sys/windows"

 )

-func initTerminal(w io.Writer) {

-	switch v := w.(type) {

-	case *os.File:

-		sequences.EnableVirtualTerminalProcessing(syscall.Handle(v.Fd()), true)

-	}

-}

-

 func checkIfTerminal(w io.Writer) bool {

-	var ret bool

 	switch v := w.(type) {

 	case *os.File:

+		handle := windows.Handle(v.Fd())

 		var mode uint32

-		err := syscall.GetConsoleMode(syscall.Handle(v.Fd()), &mode)

-		ret = (err == nil)

-	default:

-		ret = false

-	}

-	if ret {

-		initTerminal(w)

+		if err := windows.GetConsoleMode(handle, &mode); err != nil {

+			return false

+		}

+		mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING

+		if err := windows.SetConsoleMode(handle, mode); err != nil {

+			return false

+		}

+		return true

 	}

-	return ret

+	return false

 }