vendor/github.com/cenkalti/backoff/v4/context.go

@@ -57,10 +57,6 @@ func (b *backOffContext) NextBackOff() time.Duration {
 	case <-b.ctx.Done():
 		return Stop
 	default:
+		return b.BackOff.NextBackOff()
 	}
-	next := b.BackOff.NextBackOff()
-	if deadline, ok := b.ctx.Deadline(); ok && deadline.Sub(time.Now()) < next { // nolint: gosimple
-		return Stop
-	}
-	return next
 }

vendor/github.com/cenkalti/backoff/v4/exponential.go

@@ -147,6 +147,9 @@ func (b *ExponentialBackOff) incrementCurrentInterval() {
 // Returns a random value from the following interval:
 // 	[currentInterval - randomizationFactor * currentInterval, currentInterval + randomizationFactor * currentInterval].
 func getRandomValueFromInterval(randomizationFactor, random float64, currentInterval time.Duration) time.Duration {
+	if randomizationFactor == 0 {
+		return currentInterval // make sure no randomness is used when randomizationFactor is 0.
+	}
 	var delta = randomizationFactor * float64(currentInterval)
 	var minInterval = float64(currentInterval) - delta
 	var maxInterval = float64(currentInterval) + delta

vendor/github.com/cenkalti/backoff/v4/go.mod

-module github.com/cenkalti/backoff/v4
-
-go 1.13

vendor/github.com/cenkalti/backoff/v4/retry.go

@@ -62,6 +62,10 @@ func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer
 		}
 
 		if next = b.NextBackOff(); next == Stop {
+			if cerr := ctx.Err(); cerr != nil {
+				return cerr
+			}
+
 			return err
 		}
 

vendor/github.com/cespare/xxhash/v2/.travis.yml

-language: go
-go:
-  - "1.x"
-  - master
-env:
-  - TAGS=""
-  - TAGS="-tags purego"
-script: go test $TAGS -v ./...

vendor/github.com/cespare/xxhash/v2/README.md

 # xxhash
 
-[![GoDoc](https://godoc.org/github.com/cespare/xxhash?status.svg)](https://godoc.org/github.com/cespare/xxhash)
-[![Build Status](https://travis-ci.org/cespare/xxhash.svg?branch=master)](https://travis-ci.org/cespare/xxhash)
+[![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2)
+[![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml)
 
 xxhash is a Go implementation of the 64-bit
 [xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
@@ -64,4 +64,6 @@ $ go test -benchtime 10s -bench '/xxhash,direct,bytes'
 
 - [InfluxDB](https://github.com/influxdata/influxdb)
 - [Prometheus](https://github.com/prometheus/prometheus)
+- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
 - [FreeCache](https://github.com/coocood/freecache)
+- [FastCache](https://github.com/VictoriaMetrics/fastcache)

vendor/github.com/cespare/xxhash/v2/go.mod

-module github.com/cespare/xxhash/v2
-
-go 1.11

vendor/github.com/cespare/xxhash/v2/xxhash.go

@@ -193,7 +193,6 @@ func (d *Digest) UnmarshalBinary(b []byte) error {
 	b, d.v4 = consumeUint64(b)
 	b, d.total = consumeUint64(b)
 	copy(d.mem[:], b)
-	b = b[len(d.mem):]
 	d.n = int(d.total % uint64(len(d.mem)))
 	return nil
 }

vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s

@@ -6,7 +6,7 @@
 
 // Register allocation:
 // AX	h
-// CX	pointer to advance through b
+// SI	pointer to advance through b
 // DX	n
 // BX	loop end
 // R8	v1, k1
@@ -16,39 +16,39 @@
 // R12	tmp
 // R13	prime1v
 // R14	prime2v
-// R15	prime4v
+// DI	prime4v
 
-// round reads from and advances the buffer pointer in CX.
+// round reads from and advances the buffer pointer in SI.
 // It assumes that R13 has prime1v and R14 has prime2v.
 #define round(r) \
-	MOVQ  (CX), R12 \
-	ADDQ  $8, CX    \
+	MOVQ  (SI), R12 \
+	ADDQ  $8, SI    \
 	IMULQ R14, R12  \
 	ADDQ  R12, r    \
 	ROLQ  $31, r    \
 	IMULQ R13, r
 
 // mergeRound applies a merge round on the two registers acc and val.
-// It assumes that R13 has prime1v, R14 has prime2v, and R15 has prime4v.
+// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
 #define mergeRound(acc, val) \
 	IMULQ R14, val \
 	ROLQ  $31, val \
 	IMULQ R13, val \
 	XORQ  val, acc \
 	IMULQ R13, acc \
-	ADDQ  R15, acc
+	ADDQ  DI, acc
 
 // func Sum64(b []byte) uint64
 TEXT ·Sum64(SB), NOSPLIT, $0-32
 	// Load fixed primes.
 	MOVQ ·prime1v(SB), R13
 	MOVQ ·prime2v(SB), R14
-	MOVQ ·prime4v(SB), R15
+	MOVQ ·prime4v(SB), DI
 
 	// Load slice.
-	MOVQ b_base+0(FP), CX
+	MOVQ b_base+0(FP), SI
 	MOVQ b_len+8(FP), DX
-	LEAQ (CX)(DX*1), BX
+	LEAQ (SI)(DX*1), BX
 
 	// The first loop limit will be len(b)-32.
 	SUBQ $32, BX
@@ -65,14 +65,14 @@ TEXT ·Sum64(SB), NOSPLIT, $0-32
 	XORQ R11, R11
 	SUBQ R13, R11
 
-	// Loop until CX > BX.
+	// Loop until SI > BX.
 blockLoop:
 	round(R8)
 	round(R9)
 	round(R10)
 	round(R11)
 
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JLE  blockLoop
 
 	MOVQ R8, AX
@@ -100,16 +100,16 @@ noBlocks:
 afterBlocks:
 	ADDQ DX, AX
 
-	// Right now BX has len(b)-32, and we want to loop until CX > len(b)-8.
+	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
 	ADDQ $24, BX
 
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JG   fourByte
 
 wordLoop:
 	// Calculate k1.
-	MOVQ  (CX), R8
-	ADDQ  $8, CX
+	MOVQ  (SI), R8
+	ADDQ  $8, SI
 	IMULQ R14, R8
 	ROLQ  $31, R8
 	IMULQ R13, R8
@@ -117,18 +117,18 @@ wordLoop:
 	XORQ  R8, AX
 	ROLQ  $27, AX
 	IMULQ R13, AX
-	ADDQ  R15, AX
+	ADDQ  DI, AX
 
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JLE  wordLoop
 
 fourByte:
 	ADDQ $4, BX
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JG   singles
 
-	MOVL  (CX), R8
-	ADDQ  $4, CX
+	MOVL  (SI), R8
+	ADDQ  $4, SI
 	IMULQ R13, R8
 	XORQ  R8, AX
 
@@ -138,19 +138,19 @@ fourByte:
 
 singles:
 	ADDQ $4, BX
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JGE  finalize
 
 singlesLoop:
-	MOVBQZX (CX), R12
-	ADDQ    $1, CX
+	MOVBQZX (SI), R12
+	ADDQ    $1, SI
 	IMULQ   ·prime5v(SB), R12
 	XORQ    R12, AX
 
 	ROLQ  $11, AX
 	IMULQ R13, AX
 
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JL   singlesLoop
 
 finalize:
@@ -179,9 +179,9 @@ TEXT ·writeBlocks(SB), NOSPLIT, $0-40
 	MOVQ ·prime2v(SB), R14
 
 	// Load slice.
-	MOVQ b_base+8(FP), CX
+	MOVQ b_base+8(FP), SI
 	MOVQ b_len+16(FP), DX
-	LEAQ (CX)(DX*1), BX
+	LEAQ (SI)(DX*1), BX
 	SUBQ $32, BX
 
 	// Load vN from d.
@@ -199,7 +199,7 @@ blockLoop:
 	round(R10)
 	round(R11)
 
-	CMPQ CX, BX
+	CMPQ SI, BX
 	JLE  blockLoop
 
 	// Copy vN back to d.
@@ -208,8 +208,8 @@ blockLoop:
 	MOVQ R10, 16(AX)
 	MOVQ R11, 24(AX)
 
-	// The number of bytes written is CX minus the old base pointer.
-	SUBQ b_base+8(FP), CX
-	MOVQ CX, ret+32(FP)
+	// The number of bytes written is SI minus the old base pointer.
+	SUBQ b_base+8(FP), SI
+	MOVQ SI, ret+32(FP)
 
 	RET

vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go

@@ -6,41 +6,52 @@
 package xxhash
 
 import (
-	"reflect"
 	"unsafe"
 )
 
-// Notes:
+// In the future it's possible that compiler optimizations will make these
+// XxxString functions unnecessary by realizing that calls such as
+// Sum64([]byte(s)) don't need to copy s. See https://golang.org/issue/2205.
+// If that happens, even if we keep these functions they can be replaced with
+// the trivial safe code.
+
+// NOTE: The usual way of doing an unsafe string-to-[]byte conversion is:
 //
-// See https://groups.google.com/d/msg/golang-nuts/dcjzJy-bSpw/tcZYBzQqAQAJ
-// for some discussion about these unsafe conversions.
+//   var b []byte
+//   bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+//   bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
+//   bh.Len = len(s)
+//   bh.Cap = len(s)
 //
-// In the future it's possible that compiler optimizations will make these
-// unsafe operations unnecessary: https://golang.org/issue/2205.
+// Unfortunately, as of Go 1.15.3 the inliner's cost model assigns a high enough
+// weight to this sequence of expressions that any function that uses it will
+// not be inlined. Instead, the functions below use a different unsafe
+// conversion designed to minimize the inliner weight and allow both to be
+// inlined. There is also a test (TestInlining) which verifies that these are
+// inlined.
 //
-// Both of these wrapper functions still incur function call overhead since they
-// will not be inlined. We could write Go/asm copies of Sum64 and Digest.Write
-// for strings to squeeze out a bit more speed. Mid-stack inlining should
-// eventually fix this.
+// See https://github.com/golang/go/issues/42739 for discussion.
 
 // Sum64String computes the 64-bit xxHash digest of s.
 // It may be faster than Sum64([]byte(s)) by avoiding a copy.
 func Sum64String(s string) uint64 {
-	var b []byte
-	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
-	bh.Len = len(s)
-	bh.Cap = len(s)
+	b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))
 	return Sum64(b)
 }
 
 // WriteString adds more data to d. It always returns len(s), nil.
 // It may be faster than Write([]byte(s)) by avoiding a copy.
 func (d *Digest) WriteString(s string) (n int, err error) {
-	var b []byte
-	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
-	bh.Len = len(s)
-	bh.Cap = len(s)
-	return d.Write(b)
+	d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})))
+	// d.Write always returns len(s), nil.
+	// Ignoring the return output and returning these fixed values buys a
+	// savings of 6 in the inliner's cost model.
+	return len(s), nil
+}
+
+// sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout
+// of the first two words is the same as the layout of a string.
+type sliceHeader struct {
+	s   string
+	cap int
 }

vendor/github.com/coreos/go-systemd/v22/daemon/watchdog.go

@@ -30,8 +30,8 @@ import (
 // It returns one of the following:
 // (0, nil) - watchdog isn't enabled or we aren't the watched PID.
 // (0, err) - an error happened (e.g. error converting time).
-// (time, nil) - watchdog is enabled and we can send ping.
-//   time is delay before inactive service will be killed.
+// (time, nil) - watchdog is enabled and we can send ping.  time is delay
+// before inactive service will be killed.
 func SdWatchdogEnabled(unsetEnvironment bool) (time.Duration, error) {
 	wusec := os.Getenv("WATCHDOG_USEC")
 	wpid := os.Getenv("WATCHDOG_PID")

vendor/github.com/felixge/httpsnoop/README.md

@@ -65,7 +65,8 @@ being called, or called more than once, as well as concurrent calls to
 Unfortunately this package is not perfect either. It's possible that it is
 still missing some interfaces provided by the go core (let me know if you find
 one), and it won't work for applications adding their own interfaces into the
-mix.
+mix. You can however use `httpsnoop.Unwrap(w)` to access the underlying
+`http.ResponseWriter` and type-assert the result to its other interfaces.
 
 However, hopefully the explanation above has sufficiently scared you of rolling
 your own solution to this problem. httpsnoop may still break your application,

vendor/github.com/felixge/httpsnoop/capture_metrics.go

@@ -3,7 +3,6 @@ package httpsnoop
 import (
 	"io"
 	"net/http"
-	"sync"
 	"time"
 )
 
@@ -36,17 +35,23 @@ func CaptureMetrics(hnd http.Handler, w http.ResponseWriter, r *http.Request) Me
 // sugar on top of this func), but is a more usable interface if your
 // application doesn't use the Go http.Handler interface.
 func CaptureMetricsFn(w http.ResponseWriter, fn func(http.ResponseWriter)) Metrics {
+	m := Metrics{Code: http.StatusOK}
+	m.CaptureMetrics(w, fn)
+	return m
+}
+
+// CaptureMetrics wraps w and calls fn with the wrapped w and updates
+// Metrics m with the resulting metrics. This is similar to CaptureMetricsFn,
+// but allows one to customize starting Metrics object.
+func (m *Metrics) CaptureMetrics(w http.ResponseWriter, fn func(http.ResponseWriter)) {
 	var (
 		start         = time.Now()
-		m             = Metrics{Code: http.StatusOK}
 		headerWritten bool
-		lock          sync.Mutex
 		hooks         = Hooks{
 			WriteHeader: func(next WriteHeaderFunc) WriteHeaderFunc {
 				return func(code int) {
 					next(code)
-					lock.Lock()
-					defer lock.Unlock()
+
 					if !headerWritten {
 						m.Code = code
 						headerWritten = true
@@ -57,8 +62,7 @@ func CaptureMetricsFn(w http.ResponseWriter, fn func(http.ResponseWriter)) Metri
 			Write: func(next WriteFunc) WriteFunc {
 				return func(p []byte) (int, error) {
 					n, err := next(p)
-					lock.Lock()
-					defer lock.Unlock()
+
 					m.Written += int64(n)
 					headerWritten = true
 					return n, err
@@ -68,8 +72,7 @@ func CaptureMetricsFn(w http.ResponseWriter, fn func(http.ResponseWriter)) Metri
 			ReadFrom: func(next ReadFromFunc) ReadFromFunc {
 				return func(src io.Reader) (int64, error) {
 					n, err := next(src)
-					lock.Lock()
-					defer lock.Unlock()
+
 					headerWritten = true
 					m.Written += n
 					return n, err
@@ -79,6 +82,5 @@ func CaptureMetricsFn(w http.ResponseWriter, fn func(http.ResponseWriter)) Metri
 	)
 
 	fn(Wrap(w, hooks))
-	m.Duration = time.Since(start)
-	return m
+	m.Duration += time.Since(start)
 }

vendor/github.com/felixge/httpsnoop/go.mod

-module github.com/felixge/httpsnoop
-
-go 1.13

vendor/github.com/felixge/httpsnoop/wrap_generated_gteq_1.8.go

@@ -74,243 +74,275 @@ func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
 	// combination 1/32
 	case !i0 && !i1 && !i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
-		}{rw}
+		}{rw, rw}
 	// combination 2/32
 	case !i0 && !i1 && !i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Pusher
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 3/32
 	case !i0 && !i1 && !i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			io.ReaderFrom
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 4/32
 	case !i0 && !i1 && !i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 5/32
 	case !i0 && !i1 && i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 6/32
 	case !i0 && !i1 && i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
 			http.Pusher
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 7/32
 	case !i0 && !i1 && i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 8/32
 	case !i0 && !i1 && i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 9/32
 	case !i0 && i1 && !i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 10/32
 	case !i0 && i1 && !i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Pusher
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 11/32
 	case !i0 && i1 && !i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 12/32
 	case !i0 && i1 && !i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 13/32
 	case !i0 && i1 && i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 14/32
 	case !i0 && i1 && i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 15/32
 	case !i0 && i1 && i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 16/32
 	case !i0 && i1 && i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	// combination 17/32
 	case i0 && !i1 && !i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 18/32
 	case i0 && !i1 && !i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Pusher
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 19/32
 	case i0 && !i1 && !i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 20/32
 	case i0 && !i1 && !i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 21/32
 	case i0 && !i1 && i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 22/32
 	case i0 && !i1 && i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 23/32
 	case i0 && !i1 && i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 24/32
 	case i0 && !i1 && i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	// combination 25/32
 	case i0 && i1 && !i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 26/32
 	case i0 && i1 && !i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Pusher
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 27/32
 	case i0 && i1 && !i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 28/32
 	case i0 && i1 && !i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	// combination 29/32
 	case i0 && i1 && i2 && !i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 30/32
 	case i0 && i1 && i2 && !i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
 			http.Pusher
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	// combination 31/32
 	case i0 && i1 && i2 && i3 && !i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	// combination 32/32
 	case i0 && i1 && i2 && i3 && i4:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
 			http.Pusher
-		}{rw, rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw, rw}
 	}
 	panic("unreachable")
 }
@@ -320,6 +352,10 @@ type rw struct {
 	h Hooks
 }
 
+func (w *rw) Unwrap() http.ResponseWriter {
+	return w.w
+}
+
 func (w *rw) Header() http.Header {
 	f := w.w.(http.ResponseWriter).Header
 	if w.h.Header != nil {
@@ -383,3 +419,18 @@ func (w *rw) Push(target string, opts *http.PushOptions) error {
 	}
 	return f(target, opts)
 }
+
+type Unwrapper interface {
+	Unwrap() http.ResponseWriter
+}
+
+// Unwrap returns the underlying http.ResponseWriter from within zero or more
+// layers of httpsnoop wrappers.
+func Unwrap(w http.ResponseWriter) http.ResponseWriter {
+	if rw, ok := w.(Unwrapper); ok {
+		// recurse until rw.Unwrap() returns a non-Unwrapper
+		return Unwrap(rw.Unwrap())
+	} else {
+		return w
+	}
+}

vendor/github.com/felixge/httpsnoop/wrap_generated_lt_1.8.go

@@ -68,115 +68,131 @@ func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
 	// combination 1/16
 	case !i0 && !i1 && !i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
-		}{rw}
+		}{rw, rw}
 	// combination 2/16
 	case !i0 && !i1 && !i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			io.ReaderFrom
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 3/16
 	case !i0 && !i1 && i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 4/16
 	case !i0 && !i1 && i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 5/16
 	case !i0 && i1 && !i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 6/16
 	case !i0 && i1 && !i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 7/16
 	case !i0 && i1 && i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 8/16
 	case !i0 && i1 && i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 9/16
 	case i0 && !i1 && !i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
-		}{rw, rw}
+		}{rw, rw, rw}
 	// combination 10/16
 	case i0 && !i1 && !i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			io.ReaderFrom
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 11/16
 	case i0 && !i1 && i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 12/16
 	case i0 && !i1 && i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 13/16
 	case i0 && i1 && !i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
-		}{rw, rw, rw}
+		}{rw, rw, rw, rw}
 	// combination 14/16
 	case i0 && i1 && !i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			io.ReaderFrom
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 15/16
 	case i0 && i1 && i2 && !i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
-		}{rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw}
 	// combination 16/16
 	case i0 && i1 && i2 && i3:
 		return struct {
+			Unwrapper
 			http.ResponseWriter
 			http.Flusher
 			http.CloseNotifier
 			http.Hijacker
 			io.ReaderFrom
-		}{rw, rw, rw, rw, rw}
+		}{rw, rw, rw, rw, rw, rw}
 	}
 	panic("unreachable")
 }
@@ -186,6 +202,10 @@ type rw struct {
 	h Hooks
 }
 
+func (w *rw) Unwrap() http.ResponseWriter {
+	return w.w
+}
+
 func (w *rw) Header() http.Header {
 	f := w.w.(http.ResponseWriter).Header
 	if w.h.Header != nil {
@@ -241,3 +261,18 @@ func (w *rw) ReadFrom(src io.Reader) (int64, error) {
 	}
 	return f(src)
 }
+
+type Unwrapper interface {
+	Unwrap() http.ResponseWriter
+}
+
+// Unwrap returns the underlying http.ResponseWriter from within zero or more
+// layers of httpsnoop wrappers.
+func Unwrap(w http.ResponseWriter) http.ResponseWriter {
+	if rw, ok := w.(Unwrapper); ok {
+		// recurse until rw.Unwrap() returns a non-Unwrapper
+		return Unwrap(rw.Unwrap())
+	} else {
+		return w
+	}
+}

vendor/github.com/openzipkin/zipkin-go/.golangci.yml → vendor/github.com/go-logr/logr/.golangci.yaml

 run:
-  deadline: 5m
+  timeout: 1m
+  tests: true
 
 linters:
   disable-all: true
   enable:
-    - dupl
-    - goconst
-    - gocyclo
+    - asciicheck
+    - deadcode
+    - errcheck
+    - forcetypeassert
+    - gocritic
     - gofmt
-    - golint
+    - goimports
+    - gosimple
     - govet
     - ineffassign
-    - interfacer
-    - lll
     - misspell
-    - nakedret
+    - revive
+    - staticcheck
     - structcheck
-    - unparam
+    - typecheck
+    - unused
     - varcheck
 
-linters-settings:
-  dupl:
-    threshold: 400 
-  lll:   
-    line-length: 170
-  gocyclo:
-    min-complexity: 15
-  golint:
-    min-confidence: 0.85
\ No newline at end of file
+issues:
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 10

vendor/github.com/go-logr/logr/CHANGELOG.md

+# CHANGELOG
+
+## v1.0.0-rc1
+
+This is the first logged release.  Major changes (including breaking changes)
+have occurred since earlier tags.

vendor/github.com/go-logr/logr/CONTRIBUTING.md

+# Contributing
+
+Logr is open to pull-requests, provided they fit within the intended scope of
+the project.  Specifically, this library aims to be VERY small and minimalist,
+with no external dependencies.
+
+## Compatibility
+
+This project intends to follow [semantic versioning](http://semver.org) and
+is very strict about compatibility.  Any proposed changes MUST follow those
+rules.
+
+## Performance
+
+As a logging library, logr must be as light-weight as possible.  Any proposed
+code change must include results of running the [benchmark](./benchmark)
+before and after the change.