@@ -7,7 +7,7 @@ source 'hack/.vendor-helpers.sh'

 # the following lines are in sorted order, FYI

 clone git github.com/Azure/go-ansiterm 70b2c90b260171e829f1ebd7c17f600c11858dbe

-clone git github.com/Sirupsen/logrus v0.8.2 # logrus is a common dependency among multiple deps

+clone git github.com/Sirupsen/logrus v0.8.7 # logrus is a common dependency among multiple deps

 clone git github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

 clone git github.com/go-check/check 11d3bc7aa68e238947792f30573146a3231fc0f1

 clone git github.com/gorilla/context 14f550f51a

@@ -1,21 +1,47 @@

+# 0.8.7

+

+* logrus/core: fix possible race (#216)

+* logrus/doc: small typo fixes and doc improvements

+

+

+# 0.8.6

+

+* hooks/raven: allow passing an initialized client

+

+# 0.8.5

+

+* logrus/core: revert #208

+

+# 0.8.4

+

+* formatter/text: fix data race (#218)

+

+# 0.8.3

+

+* logrus/core: fix entry log level (#208)

+* logrus/core: improve performance of text formatter by 40%

+* logrus/core: expose `LevelHooks` type

+* logrus/core: add support for DragonflyBSD and NetBSD

+* formatter/text: print structs more verbosely

+

 # 0.8.2

-logrus: fix more Fatal family functions

+* logrus: fix more Fatal family functions

 # 0.8.1

-logrus: fix not exiting on `Fatalf` and `Fatalln`

+* logrus: fix not exiting on `Fatalf` and `Fatalln`

 # 0.8.0

-logrus: defaults to stderr instead of stdout

-hooks/sentry: add special field for `*http.Request`

-formatter/text: ignore Windows for colors

+* logrus: defaults to stderr instead of stdout

+* hooks/sentry: add special field for `*http.Request`

+* formatter/text: ignore Windows for colors

 # 0.7.3

-formatter/\*: allow configuration of timestamp layout

+* formatter/\*: allow configuration of timestamp layout

 # 0.7.2

-formatter/text: Add configuration option for time format (#158)

+* formatter/text: Add configuration option for time format (#158)

@@ -183,7 +183,7 @@ Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in

 import (

   log "github.com/Sirupsen/logrus"

   "github.com/Sirupsen/logrus/hooks/airbrake"

-  "github.com/Sirupsen/logrus/hooks/syslog"

+  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"

   "log/syslog"

 )

@@ -206,12 +206,19 @@ func init() {

 | [Papertrail](https://github.com/Sirupsen/logrus/blob/master/hooks/papertrail/papertrail.go) | Send errors to the Papertrail hosted logging service via UDP. |

 | [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |

 | [BugSnag](https://github.com/Sirupsen/logrus/blob/master/hooks/bugsnag/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |

+| [Sentry](https://github.com/Sirupsen/logrus/blob/master/hooks/sentry/sentry.go) | Send errors to the Sentry error logging and aggregation service. |

 | [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |

 | [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |

 | [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |

 | [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |

 | [Graylog](https://github.com/gemnasium/logrus-hooks/tree/master/graylog) | Hook for logging to [Graylog](http://graylog2.org/) |

 | [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |

+| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |

+| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |

+| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |

+| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |

+| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |

+| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |

 #### Level logging

@@ -267,7 +274,7 @@ init() {

   // do something here to set environment depending on an environment variable

   // or command-line flag

   if Environment == "production" {

-    log.SetFormatter(logrus.JSONFormatter)

+    log.SetFormatter(&log.JSONFormatter{})

   } else {

     // The TextFormatter is default, you don't actually have to do this.

     log.SetFormatter(&log.TextFormatter{})

@@ -310,7 +317,7 @@ type MyJSONFormatter struct {

 log.SetFormatter(new(MyJSONFormatter))

-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {

+func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {

   // Note this doesn't include Time, Level and Message which are available on

   // the Entry. Consult `godoc` on information about those fields or read the

   // source of the official loggers.

@@ -324,7 +331,7 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {

 #### Logger as an `io.Writer`

-Logrus can be transormed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.

+Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.

 ```go

 w := logger.Writer()

new file mode 100644

@@ -0,0 +1,26 @@

+/*

+Package logrus is a structured logger for Go, completely API compatible with the standard library logger.

+

+

+The simplest way to use Logrus is simply the package-level exported logger:

+

+  package main

+

+  import (

+    log "github.com/Sirupsen/logrus"

+  )

+

+  func main() {

+    log.WithFields(log.Fields{

+      "animal": "walrus",

+      "number": 1,

+      "size":   10,

+    }).Info("A walrus appears")

+  }

+

+Output:

+  time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10

+

+For a full guide visit https://github.com/Sirupsen/logrus

+*/

+package logrus

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

 	"time"

 )

+// Defines the key when adding errors using WithError.

+var ErrorKey = "error"

+

 // An entry is the final or intermediate Logrus logging entry. It contains all

 // the fields passed with WithField{,s}. It's finally logged when Debug, Info,

 // Warn, Error, Fatal or Panic is called on it. These objects can be reused and

@@ -53,6 +56,11 @@ func (entry *Entry) String() (string, error) {

 	return reader.String(), err

 }

+// Add an error as single field (using the key defined in ErrorKey) to the Entry.

+func (entry *Entry) WithError(err error) *Entry {

+	return entry.WithField(ErrorKey, err)

+}

+

 // Add a single field to the Entry.

 func (entry *Entry) WithField(key string, value interface{}) *Entry {

 	return entry.WithFields(Fields{key: value})

@@ -70,12 +78,14 @@ func (entry *Entry) WithFields(fields Fields) *Entry {

 	return &Entry{Logger: entry.Logger, Data: data}

 }

-func (entry *Entry) log(level Level, msg string) {

+// This function is not declared with a pointer value because otherwise

+// race conditions will occur when using multiple goroutines

+func (entry Entry) log(level Level, msg string) {

 	entry.Time = time.Now()

 	entry.Level = level

 	entry.Message = msg

-	if err := entry.Logger.Hooks.Fire(level, entry); err != nil {

+	if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {

 		entry.Logger.mu.Lock()

 		fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)

 		entry.Logger.mu.Unlock()

@@ -100,7 +110,7 @@ func (entry *Entry) log(level Level, msg string) {

 	// panic() to use in Entry#Panic(), we avoid the allocation by checking

 	// directly here.

 	if level <= PanicLevel {

-		panic(entry)

+		panic(&entry)

 	}

 }

@@ -48,6 +48,11 @@ func AddHook(hook Hook) {

 	std.Hooks.Add(hook)

 }

+// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.

+func WithError(err error) *Entry {

+	return std.WithField(ErrorKey, err)

+}

+

 // WithField creates an entry from the standard logger and adds a field to

 // it. If you want multiple fields, use `WithFields`.

 //

@@ -11,11 +11,11 @@ type Hook interface {

 }

 // Internal type for storing the hooks on a logger instance.

-type levelHooks map[Level][]Hook

+type LevelHooks map[Level][]Hook

 // Add a hook to an instance of logger. This is called with

 // `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.

-func (hooks levelHooks) Add(hook Hook) {

+func (hooks LevelHooks) Add(hook Hook) {

 	for _, level := range hook.Levels() {

 		hooks[level] = append(hooks[level], hook)

 	}

@@ -23,7 +23,7 @@ func (hooks levelHooks) Add(hook Hook) {

 // Fire all the hooks for the passed level. Used by `entry.log` to fire

 // appropriate hooks for a log entry.

-func (hooks levelHooks) Fire(level Level, entry *Entry) error {

+func (hooks LevelHooks) Fire(level Level, entry *Entry) error {

 	for _, hook := range hooks[level] {

 		if err := hook.Fire(entry); err != nil {

 			return err

@@ -8,13 +8,13 @@ import (

 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.Stdout`. You can also set this to

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

 	// something more adventorous, such as logging to Kafka.

 	Out io.Writer

 	// Hooks for the logger instance. These allow firing events based on logging

 	// levels and log entries. For example, to send errors to an error tracking

 	// service, log to StatsD or dump the core on fatal errors.

-	Hooks levelHooks

+	Hooks LevelHooks

 	// All log entries pass through the formatter before logged to Out. The

 	// included formatters are `TextFormatter` and `JSONFormatter` for which

 	// TextFormatter is the default. In development (when a TTY is attached) it

@@ -37,7 +37,7 @@ type Logger struct {

 //    var log = &Logger{

 //      Out: os.Stderr,

 //      Formatter: new(JSONFormatter),

-//      Hooks: make(levelHooks),

+//      Hooks: make(LevelHooks),

 //      Level: logrus.DebugLevel,

 //    }

 //

@@ -46,14 +46,14 @@ func New() *Logger {

 	return &Logger{

 		Out:       os.Stderr,

 		Formatter: new(TextFormatter),

-		Hooks:     make(levelHooks),

+		Hooks:     make(LevelHooks),

 		Level:     InfoLevel,

 	}

 }

 // Adds a field to the log entry, note that you it doesn't log until you call

 // Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.

-// Ff you want multiple fields, use `WithFields`.

+// If you want multiple fields, use `WithFields`.

 func (logger *Logger) WithField(key string, value interface{}) *Entry {

 	return NewEntry(logger).WithField(key, value)

 }

@@ -74,7 +74,11 @@ const (

 )

 // Won't compile if StdLogger can't be realized by a log.Logger

-var _ StdLogger = &log.Logger{}

+var (

+	_ StdLogger = &log.Logger{}

+	_ StdLogger = &Entry{}

+	_ StdLogger = &Logger{}

+)

 // StdLogger is what your logrus-enabled library should take, that way

 // it'll accept a stdlib logger and a logrus logger. There's no standard

new file mode 100644

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

+// +build darwin freebsd openbsd netbsd dragonfly

+

+package logrus

+

+import "syscall"

+

+const ioctlReadTermios = syscall.TIOCGETA

+

+type Termios syscall.Termios

deleted file mode 100644

@@ -1,12 +0,0 @@

-// Based on ssh/terminal:

-// Copyright 2013 The Go Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style

-// license that can be found in the LICENSE file.

-

-package logrus

-

-import "syscall"

-

-const ioctlReadTermios = syscall.TIOCGETA

-

-type Termios syscall.Termios

deleted file mode 100644

@@ -1,20 +0,0 @@

-/*

-  Go 1.2 doesn't include Termios for FreeBSD. This should be added in 1.3 and this could be merged with terminal_darwin.

-*/

-package logrus

-

-import (

-	"syscall"

-)

-

-const ioctlReadTermios = syscall.TIOCGETA

-

-type Termios struct {

-	Iflag  uint32

-	Oflag  uint32

-	Cflag  uint32

-	Lflag  uint32

-	Cc     [20]uint8

-	Ispeed uint32

-	Ospeed uint32

-}

@@ -3,7 +3,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build linux darwin freebsd openbsd

+// +build linux darwin freebsd openbsd netbsd dragonfly

 package logrus

deleted file mode 100644

@@ -1,7 +0,0 @@

-package logrus

-

-import "syscall"

-

-const ioctlReadTermios = syscall.TIOCGETA

-

-type Termios syscall.Termios

@@ -73,14 +73,15 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 	isColorTerminal := isTerminal && (runtime.GOOS != "windows")

 	isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors

-	if f.TimestampFormat == "" {

-		f.TimestampFormat = DefaultTimestampFormat

+	timestampFormat := f.TimestampFormat

+	if timestampFormat == "" {

+		timestampFormat = DefaultTimestampFormat

 	}

 	if isColored {

-		f.printColored(b, entry, keys)

+		f.printColored(b, entry, keys, timestampFormat)

 	} else {

 		if !f.DisableTimestamp {

-			f.appendKeyValue(b, "time", entry.Time.Format(f.TimestampFormat))

+			f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))

 		}

 		f.appendKeyValue(b, "level", entry.Level.String())

 		f.appendKeyValue(b, "msg", entry.Message)

@@ -93,7 +94,7 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 	return b.Bytes(), nil

 }

-func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string) {

+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {

 	var levelColor int

 	switch entry.Level {

 	case DebugLevel:

@@ -111,11 +112,11 @@ func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []strin

 	if !f.FullTimestamp {

 		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)

 	} else {

-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(f.TimestampFormat), entry.Message)

+		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)

 	}

 	for _, k := range keys {

 		v := entry.Data[k]

-		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%v", levelColor, k, v)

+		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v)

 	}

 }

@@ -131,21 +132,28 @@ func needsQuoting(text string) bool {

 	return true

 }

-func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key, value interface{}) {

-	switch value.(type) {

+func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {

+

+	b.WriteString(key)

+	b.WriteByte('=')

+

+	switch value := value.(type) {

 	case string:

-		if needsQuoting(value.(string)) {

-			fmt.Fprintf(b, "%v=%s ", key, value)

+		if needsQuoting(value) {

+			b.WriteString(value)

 		} else {

-			fmt.Fprintf(b, "%v=%q ", key, value)

+			fmt.Fprintf(b, "%q", value)

 		}

 	case error:

-		if needsQuoting(value.(error).Error()) {

-			fmt.Fprintf(b, "%v=%s ", key, value)

+		errmsg := value.Error()

+		if needsQuoting(errmsg) {

+			b.WriteString(errmsg)

 		} else {

-			fmt.Fprintf(b, "%v=%q ", key, value)

+			fmt.Fprintf(b, "%q", value)

 		}

 	default:

-		fmt.Fprintf(b, "%v=%v ", key, value)

+		fmt.Fprint(b, value)

 	}

+

+	b.WriteByte(' ')

 }