From 9259438ae58e86473c167362897935599b5069d6 Mon Sep 17 00:00:00 2001 From: Bruce Leidl Date: Wed, 29 Jun 2016 18:35:29 +0000 Subject: [PATCH] update dependency go-logging --- Godeps/Godeps.json | 3 +- vendor/github.com/op/go-logging/CHANGELOG.md | 19 +++++ vendor/github.com/op/go-logging/README.md | 8 +- vendor/github.com/op/go-logging/format.go | 61 +++++++++++++-- vendor/github.com/op/go-logging/log_nix.go | 67 ++++++++++------ vendor/github.com/op/go-logging/logger.go | 80 +++++++++++--------- 6 files changed, 171 insertions(+), 67 deletions(-) create mode 100644 vendor/github.com/op/go-logging/CHANGELOG.md diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 8f3ebcf..463c6b9 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -43,7 +43,8 @@ }, { "ImportPath": "github.com/op/go-logging", - "Rev": "dfaf3dff9b631bc4236201d90d41ee0de9202889" + "Comment": "v1-7-g970db52", + "Rev": "970db520ece77730c7e4724c61121037378659d9" }, { "ImportPath": "github.com/subgraph/go-procsnitch", diff --git a/vendor/github.com/op/go-logging/CHANGELOG.md b/vendor/github.com/op/go-logging/CHANGELOG.md new file mode 100644 index 0000000..4b7d233 --- /dev/null +++ b/vendor/github.com/op/go-logging/CHANGELOG.md @@ -0,0 +1,19 @@ +# Changelog + +## 2.0.0-rc1 (2016-02-11) + +Time flies and it has been three years since this package was first released. +There have been a couple of API changes I have wanted to do for some time but +I've tried to maintain backwards compatibility. Some inconsistencies in the +API have started to show, proper vendor support in Go out of the box and +the fact that `go vet` will give warnings -- I have decided to bump the major +version. + +* Make eg. `Info` and `Infof` do different things. You want to change all calls + to `Info` with a string format go to `Infof` etc. In many cases, `go vet` will + guide you. +* `Id` in `Record` is now called `ID` + +## 1.0.0 (2013-02-21) + +Initial release diff --git a/vendor/github.com/op/go-logging/README.md b/vendor/github.com/op/go-logging/README.md index 65177d1..0a7326b 100644 --- a/vendor/github.com/op/go-logging/README.md +++ b/vendor/github.com/op/go-logging/README.md @@ -7,6 +7,10 @@ is customizable and supports different logging backends like syslog, file and memory. Multiple backends can be utilized with different log levels per backend and logger. +**_NOTE:_** backwards compatibility promise have been dropped for master. Please +vendor this package or use `gopkg.in/op/go-logging.v1` for previous version. See +[changelog](CHANGELOG.md) for details. + ## Example Let's have a look at an [example](examples/example.go) which demonstrates most @@ -74,7 +78,7 @@ func main() { After this command *go-logging* is ready to use. Its source will be in: - $GOROOT/src/pkg/github.com/op/go-logging + $GOPATH/src/pkg/github.com/op/go-logging You can use `go get -u` to update the package. @@ -86,4 +90,4 @@ For docs, see http://godoc.org/github.com/op/go-logging or run: ## Additional resources -* [wslog](https://godoc.org/github.com/cryptix/go/logging/wslog) -- exposes log messages through a WebSocket. +* [wslog](https://godoc.org/github.com/cryptix/exp/wslog) -- exposes log messages through a WebSocket. diff --git a/vendor/github.com/op/go-logging/format.go b/vendor/github.com/op/go-logging/format.go index 0fb5a4f..7160674 100644 --- a/vendor/github.com/op/go-logging/format.go +++ b/vendor/github.com/op/go-logging/format.go @@ -14,6 +14,7 @@ import ( "path/filepath" "regexp" "runtime" + "strconv" "strings" "sync" "time" @@ -39,6 +40,7 @@ const ( fmtVerbShortpkg fmtVerbLongfunc fmtVerbShortfunc + fmtVerbCallpath fmtVerbLevelColor // Keep last, there are no match for these below. @@ -60,6 +62,7 @@ var fmtVerbs = []string{ "shortpkg", "longfunc", "shortfunc", + "callpath", "color", } @@ -79,6 +82,7 @@ var defaultVerbsLayout = []string{ "s", "s", "s", + "0", "", } @@ -159,6 +163,7 @@ type stringFormatter struct { // %{message} Message (string) // %{longfile} Full file name and line number: /a/b/c/d.go:23 // %{shortfile} Final file name element and line number: d.go:23 +// %{callpath} Callpath like main.a.b.c...c "..." meaning recursive call ~. meaning truncated path // %{color} ANSI color based on log level // // For normal types, the output can be customized by using the 'verbs' defined @@ -175,6 +180,9 @@ type stringFormatter struct { // "%{color:bold}%{time:15:04:05} %{level:-8s}%{color:reset} %{message}" will // just colorize the time and level, leaving the message uncolored. // +// For the 'callpath' verb, the output can be adjusted to limit the printing +// the stack depth. i.e. '%{callpath:3}' will print '~.a.b.c' +// // Colors on Windows is unfortunately not supported right now and is currently // a no-op. // @@ -187,6 +195,7 @@ type stringFormatter struct { // %{shortpkg} Base package path, eg. go-logging // %{longfunc} Full function name, eg. littleEndian.PutUint32 // %{shortfunc} Base function name, eg. PutUint32 +// %{callpath} Call function path, eg. main.a.b.c func NewStringFormatter(format string) (Formatter, error) { var fmter = &stringFormatter{} @@ -211,12 +220,12 @@ func NewStringFormatter(format string) (Formatter, error) { } // Handle layout customizations or use the default. If this is not for the - // time or color formatting, we need to prefix with %. + // time, color formatting or callpath, we need to prefix with %. layout := defaultVerbsLayout[verb] if m[4] != -1 { layout = format[m[4]:m[5]] } - if verb != fmtVerbTime && verb != fmtVerbLevelColor { + if verb != fmtVerbTime && verb != fmtVerbLevelColor && verb != fmtVerbCallpath { layout = "%" + layout } @@ -233,12 +242,13 @@ func NewStringFormatter(format string) (Formatter, error) { if err != nil { panic(err) } + testFmt := "hello %s" r := &Record{ - Id: 12345, + ID: 12345, Time: t, Module: "logger", - fmt: "hello %s", - args: []interface{}{"go"}, + Args: []interface{}{"go"}, + fmt: &testFmt, } if err := fmter.Format(0, r, &bytes.Buffer{}); err != nil { return nil, err @@ -269,6 +279,12 @@ func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) err output.Write([]byte(r.Time.Format(part.layout))) } else if part.verb == fmtVerbLevelColor { doFmtVerbLevelColor(part.layout, r.Level, output) + } else if part.verb == fmtVerbCallpath { + depth, err := strconv.Atoi(part.layout) + if err != nil { + depth = 0 + } + output.Write([]byte(formatCallpath(calldepth+1, depth))) } else { var v interface{} switch part.verb { @@ -276,7 +292,7 @@ func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) err v = r.Level break case fmtVerbID: - v = r.Id + v = r.ID break case fmtVerbPid: v = pid @@ -343,6 +359,39 @@ func formatFuncName(v fmtVerb, f string) string { panic("unexpected func formatter") } +func formatCallpath(calldepth int, depth int) string { + v := "" + callers := make([]uintptr, 64) + n := runtime.Callers(calldepth+2, callers) + oldPc := callers[n-1] + + start := n - 3 + if depth > 0 && start >= depth { + start = depth - 1 + v += "~." + } + recursiveCall := false + for i := start; i >= 0; i-- { + pc := callers[i] + if oldPc == pc { + recursiveCall = true + continue + } + oldPc = pc + if recursiveCall { + recursiveCall = false + v += ".." + } + if i < start { + v += "." + } + if f := runtime.FuncForPC(pc); f != nil { + v += formatFuncName(fmtVerbShortfunc, f.Name()) + } + } + return v +} + // backendFormatter combines a backend with a specific formatter making it // possible to have different log formats for different backends. type backendFormatter struct { diff --git a/vendor/github.com/op/go-logging/log_nix.go b/vendor/github.com/op/go-logging/log_nix.go index f06a871..4ff2ab1 100644 --- a/vendor/github.com/op/go-logging/log_nix.go +++ b/vendor/github.com/op/go-logging/log_nix.go @@ -16,37 +16,38 @@ import ( type color int const ( - colorBlack = iota + 30 - colorRed - colorGreen - colorYellow - colorBlue - colorMagenta - colorCyan - colorWhite + ColorBlack = iota + 30 + ColorRed + ColorGreen + ColorYellow + ColorBlue + ColorMagenta + ColorCyan + ColorWhite ) var ( colors = []string{ - CRITICAL: colorSeq(colorMagenta), - ERROR: colorSeq(colorRed), - WARNING: colorSeq(colorYellow), - NOTICE: colorSeq(colorGreen), - DEBUG: colorSeq(colorCyan), + CRITICAL: ColorSeq(ColorMagenta), + ERROR: ColorSeq(ColorRed), + WARNING: ColorSeq(ColorYellow), + NOTICE: ColorSeq(ColorGreen), + DEBUG: ColorSeq(ColorCyan), } boldcolors = []string{ - CRITICAL: colorSeqBold(colorMagenta), - ERROR: colorSeqBold(colorRed), - WARNING: colorSeqBold(colorYellow), - NOTICE: colorSeqBold(colorGreen), - DEBUG: colorSeqBold(colorCyan), + CRITICAL: ColorSeqBold(ColorMagenta), + ERROR: ColorSeqBold(ColorRed), + WARNING: ColorSeqBold(ColorYellow), + NOTICE: ColorSeqBold(ColorGreen), + DEBUG: ColorSeqBold(ColorCyan), } ) // LogBackend utilizes the standard log module. type LogBackend struct { - Logger *log.Logger - Color bool + Logger *log.Logger + Color bool + ColorConfig []string } // NewLogBackend creates a new LogBackend. @@ -57,8 +58,13 @@ func NewLogBackend(out io.Writer, prefix string, flag int) *LogBackend { // Log implements the Backend interface. func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error { if b.Color { + col := colors[level] + if len(b.ColorConfig) > int(level) && b.ColorConfig[level] != "" { + col = b.ColorConfig[level] + } + buf := &bytes.Buffer{} - buf.Write([]byte(colors[level])) + buf.Write([]byte(col)) buf.Write([]byte(rec.Formatted(calldepth + 1))) buf.Write([]byte("\033[0m")) // For some reason, the Go logger arbitrarily decided "2" was the correct @@ -69,11 +75,26 @@ func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error { return b.Logger.Output(calldepth+2, rec.Formatted(calldepth+1)) } -func colorSeq(color color) string { +// ConvertColors takes a list of ints representing colors for log levels and +// converts them into strings for ANSI color formatting +func ConvertColors(colors []int, bold bool) []string { + converted := []string{} + for _, i := range colors { + if bold { + converted = append(converted, ColorSeqBold(color(i))) + } else { + converted = append(converted, ColorSeq(color(i))) + } + } + + return converted +} + +func ColorSeq(color color) string { return fmt.Sprintf("\033[%dm", int(color)) } -func colorSeqBold(color color) string { +func ColorSeqBold(color color) string { return fmt.Sprintf("\033[%d;1m", int(color)) } diff --git a/vendor/github.com/op/go-logging/logger.go b/vendor/github.com/op/go-logging/logger.go index b430124..535ed9b 100644 --- a/vendor/github.com/op/go-logging/logger.go +++ b/vendor/github.com/op/go-logging/logger.go @@ -41,16 +41,16 @@ var ( // was created, an increasing id, filename and line and finally the actual // formatted log line. type Record struct { - Id uint64 + ID uint64 Time time.Time Module string Level Level + Args []interface{} // message is kept as a pointer to have shallow copies update this once // needed. message *string - args []interface{} - fmt string + fmt *string formatter Formatter formatted string } @@ -69,12 +69,20 @@ func (r *Record) Formatted(calldepth int) string { func (r *Record) Message() string { if r.message == nil { // Redact the arguments that implements the Redactor interface - for i, arg := range r.args { + for i, arg := range r.Args { if redactor, ok := arg.(Redactor); ok == true { - r.args[i] = redactor.Redacted() + r.Args[i] = redactor.Redacted() } } - msg := fmt.Sprintf(r.fmt, r.args...) + var buf bytes.Buffer + if r.fmt != nil { + fmt.Fprintf(&buf, *r.fmt, r.Args...) + } else { + // use Fprintln to make sure we always get space between arguments + fmt.Fprintln(&buf, r.Args...) + buf.Truncate(buf.Len() - 1) // strip newline + } + msg := buf.String() r.message = &msg } return *r.message @@ -132,19 +140,19 @@ func (l *Logger) IsEnabledFor(level Level) bool { return defaultBackend.IsEnabledFor(level, l.Module) } -func (l *Logger) log(lvl Level, format string, args ...interface{}) { +func (l *Logger) log(lvl Level, format *string, args ...interface{}) { if !l.IsEnabledFor(lvl) { return } // Create the logging record and pass it in to the backend record := &Record{ - Id: atomic.AddUint64(&sequenceNo, 1), + ID: atomic.AddUint64(&sequenceNo, 1), Time: timeNow(), Module: l.Module, Level: lvl, fmt: format, - args: args, + Args: args, } // TODO use channels to fan out the records to all backends? @@ -164,84 +172,86 @@ func (l *Logger) log(lvl Level, format string, args ...interface{}) { // Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1). func (l *Logger) Fatal(args ...interface{}) { - s := fmt.Sprint(args...) - l.log(CRITICAL, "%s", s) + l.log(CRITICAL, nil, args...) os.Exit(1) } // Fatalf is equivalent to l.Critical followed by a call to os.Exit(1). func (l *Logger) Fatalf(format string, args ...interface{}) { - l.log(CRITICAL, format, args...) + l.log(CRITICAL, &format, args...) os.Exit(1) } // Panic is equivalent to l.Critical(fmt.Sprint()) followed by a call to panic(). func (l *Logger) Panic(args ...interface{}) { - s := fmt.Sprint(args...) - l.log(CRITICAL, "%s", s) - panic(s) + l.log(CRITICAL, nil, args...) + panic(fmt.Sprint(args...)) } // Panicf is equivalent to l.Critical followed by a call to panic(). func (l *Logger) Panicf(format string, args ...interface{}) { - s := fmt.Sprintf(format, args...) - l.log(CRITICAL, "%s", s) - panic(s) + l.log(CRITICAL, &format, args...) + panic(fmt.Sprintf(format, args...)) } // Critical logs a message using CRITICAL as log level. -func (l *Logger) Critical(format string, args ...interface{}) { - l.log(CRITICAL, format, args...) +func (l *Logger) Critical(args ...interface{}) { + l.log(CRITICAL, nil, args...) +} + +// Criticalf logs a message using CRITICAL as log level. +func (l *Logger) Criticalf(format string, args ...interface{}) { + l.log(CRITICAL, &format, args...) } // Error logs a message using ERROR as log level. -func (l *Logger) Error(format string, args ...interface{}) { - l.log(ERROR, format, args...) +func (l *Logger) Error(args ...interface{}) { + l.log(ERROR, nil, args...) } // Errorf logs a message using ERROR as log level. func (l *Logger) Errorf(format string, args ...interface{}) { - l.log(ERROR, format, args...) + l.log(ERROR, &format, args...) } // Warning logs a message using WARNING as log level. -func (l *Logger) Warning(format string, args ...interface{}) { - l.log(WARNING, format, args...) +func (l *Logger) Warning(args ...interface{}) { + l.log(WARNING, nil, args...) } // Warningf logs a message using WARNING as log level. func (l *Logger) Warningf(format string, args ...interface{}) { - l.log(WARNING, format, args...) + l.log(WARNING, &format, args...) } // Notice logs a message using NOTICE as log level. -func (l *Logger) Notice(format string, args ...interface{}) { - l.log(NOTICE, format, args...) +func (l *Logger) Notice(args ...interface{}) { + l.log(NOTICE, nil, args...) } // Noticef logs a message using NOTICE as log level. func (l *Logger) Noticef(format string, args ...interface{}) { - l.log(NOTICE, format, args...) + l.log(NOTICE, &format, args...) } // Info logs a message using INFO as log level. -func (l *Logger) Info(format string, args ...interface{}) { - l.log(INFO, format, args...) +func (l *Logger) Info(args ...interface{}) { + l.log(INFO, nil, args...) } // Infof logs a message using INFO as log level. func (l *Logger) Infof(format string, args ...interface{}) { - l.log(INFO, format, args...) + l.log(INFO, &format, args...) } // Debug logs a message using DEBUG as log level. -func (l *Logger) Debug(format string, args ...interface{}) { - l.log(DEBUG, format, args...) +func (l *Logger) Debug(args ...interface{}) { + l.log(DEBUG, nil, args...) } // Debugf logs a message using DEBUG as log level. func (l *Logger) Debugf(format string, args ...interface{}) { - l.log(DEBUG, format, args...) + l.log(DEBUG, &format, args...) } func init() {