MM-27613: Update dependencies (#15294)

https://mattermost.atlassian.net/browse/MM-27613

vendor/github.com/RoaringBitmap/roaring/.travis.yml

@@ -8,13 +8,9 @@ install:
 notifications:
   email: false
 go:
-- "1.7.x"
-- "1.8.x"
-- "1.9.x"
-- "1.10.x"
-- "1.11.x"
 - "1.12.x"
 - "1.13.x"
+- "1.14.x"
 - tip
 
 # whitelist

vendor/github.com/RoaringBitmap/roaring/README.md

@@ -1,5 +1,9 @@
-roaring [![Build Status](https://travis-ci.org/RoaringBitmap/roaring.png)](https://travis-ci.org/RoaringBitmap/roaring) [![Coverage Status](https://coveralls.io/repos/github/RoaringBitmap/roaring/badge.svg?branch=master)](https://coveralls.io/github/RoaringBitmap/roaring?branch=master) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring) [![Go Report Card](https://goreportcard.com/badge/RoaringBitmap/roaring)](https://goreportcard.com/report/github.com/RoaringBitmap/roaring)
+roaring [![Build Status](https://travis-ci.org/RoaringBitmap/roaring.png)](https://travis-ci.org/RoaringBitmap/roaring) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64) [![Go Report Card](https://goreportcard.com/badge/RoaringBitmap/roaring)](https://goreportcard.com/report/github.com/RoaringBitmap/roaring)
 [![Build Status](https://cloud.drone.io/api/badges/RoaringBitmap/roaring/status.svg)](https://cloud.drone.io/RoaringBitmap/roaring)
+![Go-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-CI/badge.svg)
+![Go-ARM-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-ARM-CI/badge.svg)
+![Go-Windows-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-Windows-CI/badge.svg)
+![Go-macos-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-macos-CI/badge.svg)
 =============
 
 This is a go version of the Roaring bitmap data structure. 
@@ -7,7 +11,7 @@ This is a go version of the Roaring bitmap data structure.
 
 
 Roaring bitmaps are used by several major systems such as [Apache Lucene][lucene] and derivative systems such as [Solr][solr] and
-[Elasticsearch][elasticsearch], [Apache Druid (Incubating)][druid], [LinkedIn Pinot][pinot], [Netflix Atlas][atlas],  [Apache Spark][spark], [OpenSearchServer][opensearchserver], [Cloud Torrent][cloudtorrent], [Whoosh][whoosh],  [Pilosa][pilosa],  [Microsoft Visual Studio Team Services (VSTS)][vsts], and eBay's [Apache Kylin][kylin].
+[Elasticsearch][elasticsearch], [Apache Druid (Incubating)][druid], [LinkedIn Pinot][pinot], [Netflix Atlas][atlas],  [Apache Spark][spark], [OpenSearchServer][opensearchserver], [Cloud Torrent][cloudtorrent], [Whoosh][whoosh],  [Pilosa][pilosa],  [Microsoft Visual Studio Team Services (VSTS)][vsts], and eBay's [Apache Kylin][kylin]. The YouTube SQL Engine, [Google Procella](https://research.google/pubs/pub48388/), uses Roaring bitmaps for indexing.
 
 [lucene]: https://lucene.apache.org/
 [solr]: https://lucene.apache.org/solr/
@@ -172,10 +176,70 @@ That is, given a fixed overhead for the universe size (x), Roaring
 bitmaps never use more than 2 bytes per integer. You can call
 ``BoundSerializedSizeInBytes`` for a more precise estimate.
 
+### 64-bit Roaring
+
+By default, roaring is used to stored unsigned 32-bit integers. However, we also offer
+an extension dedicated to 64-bit integers. It supports roughly the same functions:
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/RoaringBitmap/roaring/roaring64"
+    "bytes"
+)
+
+
+func main() {
+    // example inspired by https://github.com/fzandona/goroar
+    fmt.Println("==roaring64==")
+    rb1 := roaring64.BitmapOf(1, 2, 3, 4, 5, 100, 1000)
+    fmt.Println(rb1.String())
+
+    rb2 := roaring64.BitmapOf(3, 4, 1000)
+    fmt.Println(rb2.String())
+
+    rb3 := roaring64.New()
+    fmt.Println(rb3.String())
+
+    fmt.Println("Cardinality: ", rb1.GetCardinality())
+
+    fmt.Println("Contains 3? ", rb1.Contains(3))
+
+    rb1.And(rb2)
+
+    rb3.Add(1)
+    rb3.Add(5)
+
+    rb3.Or(rb1)
+
+
+
+    // prints 1, 3, 4, 5, 1000
+    i := rb3.Iterator()
+    for i.HasNext() {
+        fmt.Println(i.Next())
+    }
+    fmt.Println()
+
+    // next we include an example of serialization
+    buf := new(bytes.Buffer)
+    rb1.WriteTo(buf) // we omit error handling
+    newrb:= roaring64.New()
+    newrb.ReadFrom(buf)
+    if rb1.Equals(newrb) {
+    	fmt.Println("I wrote the content to a byte stream and read it back.")
+    }
+    // you can iterate over bitmaps using ReverseIterator(), Iterator, ManyIterator()
+}
+```
+
+Only the 32-bit roaring format is standard and cross-operable between Java, C++, C and Go. There is no guarantee that the 64-bit versions are compatible.
 
 ### Documentation
 
-Current documentation is available at http://godoc.org/github.com/RoaringBitmap/roaring
+Current documentation is available at http://godoc.org/github.com/RoaringBitmap/roaring and http://godoc.org/github.com/RoaringBitmap/roaring64
 
 ### Goroutine safety
 

vendor/github.com/RoaringBitmap/roaring/arraycontainer.go

@@ -876,6 +876,41 @@ func (ac *arrayContainer) loadData(bitmapContainer *bitmapContainer) {
 	ac.content = make([]uint16, bitmapContainer.cardinality, bitmapContainer.cardinality)
 	bitmapContainer.fillArray(ac.content)
 }
+
+func (ac *arrayContainer) resetTo(a container) {
+	switch x := a.(type) {
+	case *arrayContainer:
+		ac.realloc(len(x.content))
+		copy(ac.content, x.content)
+
+	case *bitmapContainer:
+		ac.realloc(x.cardinality)
+		x.fillArray(ac.content)
+
+	case *runContainer16:
+		card := int(x.cardinality())
+		ac.realloc(card)
+		cur := 0
+		for _, r := range x.iv {
+			for val := r.start; val <= r.last(); val++ {
+				ac.content[cur] = val
+				cur++
+			}
+		}
+
+	default:
+		panic("unsupported container type")
+	}
+}
+
+func (ac *arrayContainer) realloc(size int) {
+	if cap(ac.content) < size {
+		ac.content = make([]uint16, size)
+	} else {
+		ac.content = ac.content[:size]
+	}
+}
+
 func newArrayContainer() *arrayContainer {
 	p := new(arrayContainer)
 	return p

vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go

@@ -203,6 +203,33 @@ func (bcmi *bitmapContainerManyIterator) nextMany(hs uint32, buf []uint32) int {
 	return n
 }
 
+func (bcmi *bitmapContainerManyIterator) nextMany64(hs uint64, buf []uint64) int {
+	n := 0
+	base := bcmi.base
+	bitset := bcmi.bitset
+
+	for n < len(buf) {
+		if bitset == 0 {
+			base++
+			if base >= len(bcmi.ptr.bitmap) {
+				bcmi.base = base
+				bcmi.bitset = bitset
+				return n
+			}
+			bitset = bcmi.ptr.bitmap[base]
+			continue
+		}
+		t := bitset & -bitset
+		buf[n] = uint64(((base * 64) + int(popcount(t-1)))) | hs
+		n = n + 1
+		bitset ^= t
+	}
+
+	bcmi.base = base
+	bcmi.bitset = bitset
+	return n
+}
+
 func newBitmapContainerManyIterator(a *bitmapContainer) *bitmapContainerManyIterator {
 	return &bitmapContainerManyIterator{a, -1, 0}
 }
@@ -934,6 +961,32 @@ func (bc *bitmapContainer) loadData(arrayContainer *arrayContainer) {
 	}
 }
 
+func (bc *bitmapContainer) resetTo(a container) {
+	switch x := a.(type) {
+	case *arrayContainer:
+		fill(bc.bitmap, 0)
+		bc.loadData(x)
+
+	case *bitmapContainer:
+		bc.cardinality = x.cardinality
+		copy(bc.bitmap, x.bitmap)
+
+	case *runContainer16:
+		bc.cardinality = len(x.iv)
+		lastEnd := 0
+		for _, r := range x.iv {
+			bc.cardinality += int(r.length)
+			resetBitmapRange(bc.bitmap, lastEnd, int(r.start))
+			lastEnd = int(r.start+r.length) + 1
+			setBitmapRange(bc.bitmap, int(r.start), lastEnd)
+		}
+		resetBitmapRange(bc.bitmap, lastEnd, maxCapacity)
+
+	default:
+		panic("unsupported container type")
+	}
+}
+
 func (bc *bitmapContainer) toArrayContainer() *arrayContainer {
 	ac := &arrayContainer{}
 	ac.loadData(bc)

vendor/github.com/RoaringBitmap/roaring/fastaggregation.go

@@ -213,3 +213,120 @@ func HeapXor(bitmaps ...*Bitmap) *Bitmap {
 	}
 	return heap.Pop(&pq).(*item).value
 }
+
+// AndAny provides a result equivalent to x1.And(FastOr(bitmaps)).
+// It's optimized to minimize allocations. It also might be faster than separate calls.
+func (x1 *Bitmap) AndAny(bitmaps ...*Bitmap) {
+	if len(bitmaps) == 0 {
+		return
+	} else if len(bitmaps) == 1 {
+		x1.And(bitmaps[0])
+		return
+	}
+
+	type withPos struct {
+		bitmap *roaringArray
+		pos    int
+		key    uint16
+	}
+	filters := make([]withPos, 0, len(bitmaps))
+
+	for _, b := range bitmaps {
+		if b.highlowcontainer.size() > 0 {
+			filters = append(filters, withPos{
+				bitmap: &b.highlowcontainer,
+				pos:    0,
+				key:    b.highlowcontainer.getKeyAtIndex(0),
+			})
+		}
+	}
+
+	basePos := 0
+	intersections := 0
+	keyContainers := make([]container, 0, len(filters))
+	var (
+		tmpArray   *arrayContainer
+		tmpBitmap  *bitmapContainer
+		minNextKey uint16
+	)
+
+	for basePos < x1.highlowcontainer.size() && len(filters) > 0 {
+		baseKey := x1.highlowcontainer.getKeyAtIndex(basePos)
+
+		// accumulate containers for current key, find next minimal key in filters
+		// and exclude filters that do not have related values anymore
+		i := 0
+		maxPossibleOr := 0
+		minNextKey = MaxUint16
+		for _, f := range filters {
+			if f.key < baseKey {
+				f.pos = f.bitmap.advanceUntil(baseKey, f.pos)
+				if f.pos == f.bitmap.size() {
+					continue
+				}
+				f.key = f.bitmap.getKeyAtIndex(f.pos)
+			}
+
+			if f.key == baseKey {
+				cont := f.bitmap.getContainerAtIndex(f.pos)
+				keyContainers = append(keyContainers, cont)
+				maxPossibleOr += cont.getCardinality()
+
+				f.pos++
+				if f.pos == f.bitmap.size() {
+					continue
+				}
+				f.key = f.bitmap.getKeyAtIndex(f.pos)
+			}
+
+			minNextKey = minOfUint16(minNextKey, f.key)
+			filters[i] = f
+			i++
+		}
+		filters = filters[:i]
+
+		if len(keyContainers) == 0 {
+			basePos = x1.highlowcontainer.advanceUntil(minNextKey, basePos)
+			continue
+		}
+
+		var ored container
+
+		if len(keyContainers) == 1 {
+			ored = keyContainers[0]
+		} else {
+			//TODO: special case for run containers?
+			if maxPossibleOr > arrayDefaultMaxSize {
+				if tmpBitmap == nil {
+					tmpBitmap = newBitmapContainer()
+				}
+				tmpBitmap.resetTo(keyContainers[0])
+				for _, c := range keyContainers[1:] {
+					tmpBitmap.ior(c)
+				}
+				ored = tmpBitmap
+			} else {
+				if tmpArray == nil {
+					tmpArray = newArrayContainerCapacity(maxPossibleOr)
+				}
+				tmpArray.realloc(maxPossibleOr)
+				tmpArray.resetTo(keyContainers[0])
+				for _, c := range keyContainers[1:] {
+					tmpArray.ior(c)
+				}
+				ored = tmpArray
+			}
+		}
+
+		result := x1.highlowcontainer.getWritableContainerAtIndex(basePos).iand(ored)
+		if result.getCardinality() > 0 {
+			x1.highlowcontainer.replaceKeyAndContainerAtIndex(intersections, baseKey, result, false)
+			intersections++
+		}
+
+		keyContainers = keyContainers[:0]
+		basePos = x1.highlowcontainer.advanceUntil(minNextKey, basePos)
+	}
+
+	x1.highlowcontainer.resize(intersections)
+}

vendor/github.com/RoaringBitmap/roaring/manyiterator.go

@@ -2,6 +2,7 @@ package roaring
 
 type manyIterable interface {
 	nextMany(hs uint32, buf []uint32) int
+	nextMany64(hs uint64, buf []uint64) int
 }
 
 func (si *shortIterator) nextMany(hs uint32, buf []uint32) int {
@@ -16,3 +17,16 @@ func (si *shortIterator) nextMany(hs uint32, buf []uint32) int {
 	si.loc = l
 	return n
 }
+
+func (si *shortIterator) nextMany64(hs uint64, buf []uint64) int {
+	n := 0
+	l := si.loc
+	s := si.slice
+	for n < len(buf) && l < len(s) {
+		buf[n] = uint64(s[l]) | hs
+		l++
+		n++
+	}
+	si.loc = l
+	return n
+}

vendor/github.com/RoaringBitmap/roaring/roaring.go

@@ -346,7 +346,9 @@ func newIntReverseIterator(a *Bitmap) *intReverseIterator {
 // ManyIntIterable allows you to iterate over the values in a Bitmap
 type ManyIntIterable interface {
 	// pass in a buffer to fill up with values, returns how many values were returned
-	NextMany([]uint32) int
+	NextMany(buf []uint32) int
+	// pass in a buffer to fill up with 64 bit values, returns how many values were returned
+	NextMany64(hs uint64, buf []uint64) int
 }
 
 type manyIntIterator struct {
@@ -382,6 +384,25 @@ func (ii *manyIntIterator) NextMany(buf []uint32) int {
 	return n
 }
 
+func (ii *manyIntIterator) NextMany64(hs64 uint64, buf []uint64) int {
+	n := 0
+	for n < len(buf) {
+		if ii.iter == nil {
+			break
+		}
+
+		hs := uint64(ii.hs) | hs64
+		moreN := ii.iter.nextMany64(hs, buf[n:])
+		n += moreN
+		if moreN == 0 {
+			ii.pos = ii.pos + 1
+			ii.init()
+		}
+	}
+
+	return n
+}
+
 func newManyIntIterator(a *Bitmap) *manyIntIterator {
 	p := new(manyIntIterator)
 	p.pos = 0
@@ -678,7 +699,10 @@ func (rb *Bitmap) GetCardinality() uint64 {
 	return size
 }
 
-// Rank returns the number of integers that are smaller or equal to x (Rank(infinity) would be GetCardinality())
+// Rank returns the number of integers that are smaller or equal to x (Rank(infinity) would be GetCardinality()).
+// If you pass the smallest value, you get the value 1. If you pass a value that is smaller than the smallest
+// value, you get 0. Note that this function differs in convention from the Select function since it
+// return 1 and not 0 on the smallest value.
 func (rb *Bitmap) Rank(x uint32) uint64 {
 	size := uint64(0)
 	for i := 0; i < rb.highlowcontainer.size(); i++ {
@@ -695,7 +719,9 @@ func (rb *Bitmap) Rank(x uint32) uint64 {
 	return size
 }
 
-// Select returns the xth integer in the bitmap
+// Select returns the xth integer in the bitmap. If you pass 0, you get
+// the smallest element. Note that this function differs in convention from
+// the Rank function which returns 1 on the smallest value.
 func (rb *Bitmap) Select(x uint32) (uint32, error) {
 	if rb.GetCardinality() <= uint64(x) {
 		return 0, fmt.Errorf("can't find %dth integer in a bitmap with only %d items", x, rb.GetCardinality())
@@ -1555,3 +1581,7 @@ func (rb *Bitmap) Stats() Statistics {
 	}
 	return stats
 }
+
+func (rb *Bitmap) FillLeastSignificant32bits(x []uint64, i uint64, mask uint64) {
+	rb.ManyIterator().NextMany64(mask, x[i:])
+}

vendor/github.com/RoaringBitmap/roaring/roaringarray.go

@@ -491,11 +491,11 @@ func (ra *roaringArray) writeTo(w io.Writer) (n int64, err error) {
 		binary.LittleEndian.PutUint16(buf[2:], uint16(len(ra.keys)-1))
 		nw += 2
 		// compute isRun bitmap without temporary allocation
-		var runbitmapslice = buf[nw:nw+isRunSizeInBytes]
+		var runbitmapslice = buf[nw : nw+isRunSizeInBytes]
 		for i, c := range ra.containers {
 			switch c.(type) {
 			case *runContainer16:
-				runbitmapslice[i / 8] |= 1<<(uint(i)%8)
+				runbitmapslice[i/8] |= 1 << (uint(i) % 8)
 			}
 		}
 		nw += isRunSizeInBytes

vendor/github.com/RoaringBitmap/roaring/runcontainer.go

@@ -1321,6 +1321,47 @@ func (ri *runIterator16) nextMany(hs uint32, buf []uint32) int {
 	return n
 }
 
+func (ri *runIterator16) nextMany64(hs uint64, buf []uint64) int {
+	n := 0
+
+	if !ri.hasNext() {
+		return n
+	}
+
+	// start and end are inclusive
+	for n < len(buf) {
+		moreVals := 0
+
+		if ri.rc.iv[ri.curIndex].length >= ri.curPosInIndex {
+			// add as many as you can from this seq
+			moreVals = minOfInt(int(ri.rc.iv[ri.curIndex].length-ri.curPosInIndex)+1, len(buf)-n)
+			base := uint64(ri.rc.iv[ri.curIndex].start+ri.curPosInIndex) | hs
+
+			// allows BCE
+			buf2 := buf[n : n+moreVals]
+			for i := range buf2 {
+				buf2[i] = base + uint64(i)
+			}
+
+			// update values
+			n += moreVals
+		}
+
+		if moreVals+int(ri.curPosInIndex) > int(ri.rc.iv[ri.curIndex].length) {
+			ri.curPosInIndex = 0
+			ri.curIndex++
+
+			if ri.curIndex == int64(len(ri.rc.iv)) {
+				break
+			}
+		} else {
+			ri.curPosInIndex += uint16(moreVals) //moreVals always fits in uint16
+		}
+	}
+
+	return n
+}
+
 // remove removes key from the container.
 func (rc *runContainer16) removeKey(key uint16) (wasPresent bool) {
 

vendor/github.com/RoaringBitmap/roaring/util.go

@@ -1,6 +1,7 @@
 package roaring
 
 import (
+	"math"
 	"math/rand"
 	"sort"
 )
@@ -15,7 +16,7 @@ const (
 	noOffsetThreshold          = 4
 
 	// MaxUint32 is the largest uint32 value.
-	MaxUint32 = 4294967295
+	MaxUint32 = math.MaxUint32
 
 	// MaxRange is One more than the maximum allowed bitmap bit index. For use as an upper
 	// bound for ranges.
@@ -23,7 +24,7 @@ const (
 
 	// MaxUint16 is the largest 16 bit unsigned int.
 	// This is the largest value an interval16 can store.
-	MaxUint16 = 65535
+	MaxUint16 = math.MaxUint16
 
 	// Compute wordSizeInBytes, the size of a word in bytes.
 	_m              = ^uint64(0)

vendor/github.com/armon/go-metrics/.gitignore

@@ -22,3 +22,5 @@ _testmain.go
 *.exe
 
 /metrics.out
+
+.idea

vendor/github.com/getsentry/sentry-go/.golangci.yml

@@ -7,11 +7,11 @@ linters:
     - dogsled
     - dupl
     - errcheck
-    - gochecknoglobals
     - gochecknoinits
     - goconst
     - gocritic
     - gocyclo
+    - godot
     - gofmt
     - goimports
     - golint
@@ -33,14 +33,8 @@ linters:
     - unparam
     - unused
     - varcheck
-run:
-  skip-dirs:
-    - echo
-    - example/echo
+    - whitespace
 issues:
-  exclude:
-    - "not declared by package utf8"
-    - "unicode/utf8/utf8.go"
   exclude-rules:
     - path: _test\.go
       linters:

vendor/github.com/getsentry/sentry-go/.travis.yml

@@ -24,10 +24,11 @@ jobs:
         go test ./... -race
   allow_failures:
     - go: master
+    - env: GO111MODULE=off
   fast_finish: true
 
 before_install:
-  - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/v1.19.1/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.19.1
+  - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/v1.27.0/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.27.0
   # Fetch origin/master. This is required for `git merge-base` when testing a
   # branch, since Travis clones only the target branch.
   - git fetch origin master:remotes/origin/master

vendor/github.com/getsentry/sentry-go/CHANGELOG.md

@@ -1,8 +1,32 @@
 # Changelog
 
-## Unreleased
+## v0.7.0
 
-- "I am running away from my responsibilities. And it feels good." – Michael Scott, Season 4, "Money"
+- feat: Include original error when event cannot be encoded as JSON (#258)
+- feat: Use Hub from request context when available (#217, #259)
+- feat: Extract stack frames from golang.org/x/xerrors (#262)
+- feat: Make Environment Integration preserve existing context data (#261)
+- feat: Recover and RecoverWithContext with arbitrary types (#268)
+- feat: Report bad usage of CaptureMessage and CaptureEvent (#269)
+- feat: Send debug logging to stderr by default (#266)
+- feat: Several improvements to documentation (#223, #245, #250, #265)
+- feat: Example of Recover followed by panic (#241, #247)
+- feat: Add Transactions and Spans (to support OpenTelemetry Sentry Exporter) (#235, #243, #254)
+- fix: Set either Frame.Filename or Frame.AbsPath (#233)
+- fix: Clone requestBody to new Scope (#244)
+- fix: Synchronize access and mutation of Hub.lastEventID (#264)
+- fix: Avoid repeated syscalls in prepareEvent (#256)
+- fix: Do not allocate new RNG for every event (#256)
+- fix: Remove stale replace directive in go.mod (#255)
+- fix(http): Deprecate HandleFunc, remove duplication (#260)
+
+_NOTE:_
+This version comes packed with several fixes and improvements and no breaking
+changes.
+Notably, there is a change in how the SDK reports file names in stack traces
+that should resolve any ambiguity when looking at stack traces and using the
+Suspect Commits feature.
+We recommend all users to upgrade.
 
 ## v0.6.1
 

vendor/github.com/getsentry/sentry-go/CONTRIBUTING.md

@@ -1,3 +1,45 @@
+# Contributing to sentry-go
+
+Hey, thank you if you're reading this, we welcome your contribution!
+
+## Sending a Pull Request
+
+Please help us save time when reviewing your PR by following this simple
+process:
+
+1. Is your PR a simple typo fix? Read no further, **click that green "Create
+   pull request" button**!
+
+2. For more complex PRs that involve behavior changes or new APIs, please
+   consider [opening an **issue**][new-issue] describing the problem you're
+   trying to solve if there's not one already.
+
+   A PR is often one specific solution to a problem and sometimes talking about
+   the problem unfolds new possible solutions. Remember we will be responsible
+   for maintaining the changes later.
+
+3. Fixing a bug and changing a behavior? Please add automated tests to prevent
+   future regression.
+
+4. Practice writing good commit messages. We have [commit
+   guidelines][commit-guide].
+
+5. We have [guidelines for PR submitters][pr-guide]. A short summary:
+
+   - Good PR descriptions are very helpful and most of the time they include
+     **why** something is done and why done in this particular way. Also list
+     other possible solutions that were considered and discarded.
+   - Be your own first reviewer. Make sure your code compiles and passes the
+     existing tests.
+
+[new-issue]: https://github.com/getsentry/sentry-go/issues/new/choose
+[commit-guide]: https://develop.sentry.dev/code-review/#commit-guidelines
+[pr-guide]: https://develop.sentry.dev/code-review/#guidelines-for-submitters
+
+Please also read through our [SDK Development docs](https://develop.sentry.dev/sdk/).
+It contains information about SDK features, expected payloads and best practices for
+contributing to Sentry SDKs.
+
 ## Community
 
 The public-facing channels for support and development of Sentry SDKs can be found on [Discord](https://discord.gg/Ww9hbqr).
@@ -23,6 +65,7 @@ $ go test -race
 ```
 
 ### Coverage
+
 ```console
 $ go test -race -coverprofile=coverage.txt -covermode=atomic && go tool cover -html coverage.txt
 ```
@@ -37,17 +80,17 @@ $ golangci-lint run
 
 1. Update `CHANGELOG.md` with new version in `vX.X.X` format title and list of changes.
 
-    The command below can be used to get a list of changes since the last tag, with the format used in `CHANGELOG.md`:
+   The command below can be used to get a list of changes since the last tag, with the format used in `CHANGELOG.md`:
 
-    ```console
-    $ git log --no-merges --format=%s $(git describe --abbrev=0).. | sed 's/^/- /'
-    ```
+   ```console
+   $ git log --no-merges --format=%s $(git describe --abbrev=0).. | sed 's/^/- /'
+   ```
 
 2. Commit with `misc: vX.X.X changelog` commit message and push to `master`.
 
 3. Let [`craft`](https://github.com/getsentry/craft) do the rest:
 
-    ```console
-    $ craft prepare X.X.X
-    $ craft publish X.X.X
-    ```
+   ```console
+   $ craft prepare X.X.X
+   $ craft publish X.X.X
+   ```

vendor/github.com/getsentry/sentry-go/README.md

@@ -154,7 +154,7 @@ checkout the official documentation:
 
 - [Configuration](https://docs.sentry.io/platforms/go/config)
 - [Error Reporting](https://docs.sentry.io/error-reporting/quickstart?platform=go)
-- [Enriching Error Data](https://docs.sentry.io/enriching-error-data/context?platform=go)
+- [Enriching Error Data](https://docs.sentry.io/enriching-error-data/additional-data/?platform=go)
 - [Transports](https://docs.sentry.io/platforms/go/transports)
 - [Integrations](https://docs.sentry.io/platforms/go/integrations)
   - [net/http](https://docs.sentry.io/platforms/go/http)

vendor/github.com/getsentry/sentry-go/client.go

@@ -12,6 +12,7 @@ import (
 	"os"
 	"reflect"
 	"sort"
+	"sync"
 	"time"
 )
 
@@ -24,6 +25,40 @@ import (
 // stack trace is often the most useful information.
 const maxErrorDepth = 10
 
+// hostname is the host name reported by the kernel. It is precomputed once to
+// avoid syscalls when capturing events.
+//
+// The error is ignored because retrieving the host name is best-effort. If the
+// error is non-nil, there is nothing to do other than retrying. We choose not
+// to retry for now.
+var hostname, _ = os.Hostname()
+
+// lockedRand is a random number generator safe for concurrent use. Its API is
+// intentionally limited and it is not meant as a full replacement for a
+// rand.Rand.
+type lockedRand struct {
+	mu sync.Mutex
+	r  *rand.Rand
+}
+
+// Float64 returns a pseudo-random number in [0.0,1.0).
+func (r *lockedRand) Float64() float64 {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.r.Float64()
+}
+
+// rng is the internal random number generator.
+//
+// We do not use the global functions from math/rand because, while they are
+// safe for concurrent use, any package in a build could change the seed and
+// affect the generated numbers, for instance making them deterministic. On the
+// other hand, the source returned from rand.NewSource is not safe for
+// concurrent use, so we need to couple its use with a sync.Mutex.
+var rng = &lockedRand{
+	r: rand.New(rand.NewSource(time.Now().UnixNano())),
+}
+
 // usageError is used to report to Sentry an SDK usage error.
 //
 // It is not exported because it is never returned by any function or method in
@@ -33,17 +68,27 @@ type usageError struct {
 }
 
 // Logger is an instance of log.Logger that is use to provide debug information about running Sentry Client
-// can be enabled by either using `Logger.SetOutput` directly or with `Debug` client option
-var Logger = log.New(ioutil.Discard, "[Sentry] ", log.LstdFlags) //nolint: gochecknoglobals
+// can be enabled by either using Logger.SetOutput directly or with Debug client option.
+var Logger = log.New(ioutil.Discard, "[Sentry] ", log.LstdFlags)
 
+// EventProcessor is a function that processes an event.
+// Event processors are used to change an event before it is sent to Sentry.
 type EventProcessor func(event *Event, hint *EventHint) *Event
 
+// EventModifier is the interface that wraps the ApplyToEvent method.
+//
+// ApplyToEvent changes an event based on external data and/or
+// an event hint.
 type EventModifier interface {
 	ApplyToEvent(event *Event, hint *EventHint) *Event
 }
 
-var globalEventProcessors []EventProcessor //nolint: gochecknoglobals
+var globalEventProcessors []EventProcessor
 
+// AddGlobalEventProcessor adds processor to the global list of event
+// processors. Global event processors apply to all events.
+//
+// Deprecated: Use Scope.AddEventProcessor or Client.AddEventProcessor instead.
 func AddGlobalEventProcessor(processor EventProcessor) {
 	globalEventProcessors = append(globalEventProcessors, processor)
 }
@@ -54,14 +99,16 @@ type Integration interface {
 	SetupOnce(client *Client)
 }
 
-// ClientOptions that configures a SDK Client
+// ClientOptions that configures a SDK Client.
 type ClientOptions struct {
-	// The DSN to use. If the DSN is not set, the client is effectively disabled.
+	// The DSN to use. If the DSN is not set, the client is effectively
+	// disabled.
 	Dsn string
-	// In debug mode, the debug information is printed to stdout to help you understand what
-	// sentry is doing.
+	// In debug mode, the debug information is printed to stdout to help you
+	// understand what sentry is doing.
 	Debug bool
-	// Configures whether SDK should generate and attach stacktraces to pure capture message calls.
+	// Configures whether SDK should generate and attach stacktraces to pure
+	// capture message calls.
 	AttachStacktrace bool
 	// The sample rate for event submission (0.0 - 1.0, defaults to 1.0).
 	SampleRate float64
@@ -73,13 +120,12 @@ type ClientOptions struct {
 	BeforeSend func(event *Event, hint *EventHint) *Event
 	// Before breadcrumb add callback.
 	BeforeBreadcrumb func(breadcrumb *Breadcrumb, hint *BreadcrumbHint) *Breadcrumb
-	// Integrations to be installed on the current Client, receives default integrations
+	// Integrations to be installed on the current Client, receives default
+	// integrations.
 	Integrations func([]Integration) []Integration
-	// io.Writer implementation that should be used with the `Debug` mode
+	// io.Writer implementation that should be used with the Debug mode.
 	DebugWriter io.Writer
-	// The transport to use.
-	// This is an instance of a struct implementing `Transport` interface.
-	// Defaults to `httpTransport` from `transport.go`
+	// The transport to use. Defaults to HTTPTransport.
 	Transport Transport
 	// The server name to be reported.
 	ServerName string
@@ -91,26 +137,27 @@ type ClientOptions struct {
 	Environment string
 	// Maximum number of breadcrumbs.
 	MaxBreadcrumbs int
-	// An optional pointer to `http.Client` that will be used with a default HTTPTransport.
-	// Using your own client will make HTTPTransport, HTTPProxy, HTTPSProxy and CaCerts options ignored.
+	// An optional pointer to http.Client that will be used with a default
+	// HTTPTransport. Using your own client will make HTTPTransport, HTTPProxy,
+	// HTTPSProxy and CaCerts options ignored.
 	HTTPClient *http.Client
-	// An optional pointer to `http.Transport` that will be used with a default HTTPTransport.
-	// Using your own transport will make HTTPProxy, HTTPSProxy and CaCerts options ignored.
+	// An optional pointer to http.Transport that will be used with a default
+	// HTTPTransport. Using your own transport will make HTTPProxy, HTTPSProxy
+	// and CaCerts options ignored.
 	HTTPTransport http.RoundTripper
 	// An optional HTTP proxy to use.
-	// This will default to the `http_proxy` environment variable.
-	// or `https_proxy` if that one exists.
+	// This will default to the HTTP_PROXY environment variable.
 	HTTPProxy string
 	// An optional HTTPS proxy to use.
-	// This will default to the `HTTPS_PROXY` environment variable
-	// or `http_proxy` if that one exists.
+	// This will default to the HTTPS_PROXY environment variable.
+	// HTTPS_PROXY takes precedence over HTTP_PROXY for https requests.
 	HTTPSProxy string
-	// An optional CaCerts to use.
-	// Defaults to `gocertifi.CACerts()`.
+	// An optional set of SSL certificates to use.
 	CaCerts *x509.CertPool
 }
 
-// Client is the underlying processor that's used by the main API and `Hub` instances.
+// Client is the underlying processor that is used by the main API and Hub
+// instances.
 type Client struct {
 	options         ClientOptions
 	dsn             *Dsn
@@ -119,12 +166,12 @@ type Client struct {
 	Transport       Transport
 }
 
-// NewClient creates and returns an instance of `Client` configured using `ClientOptions`.
+// NewClient creates and returns an instance of Client configured using ClientOptions.
 func NewClient(options ClientOptions) (*Client, error) {
 	if options.Debug {
 		debugWriter := options.DebugWriter
 		if debugWriter == nil {
-			debugWriter = os.Stdout
+			debugWriter = os.Stderr
 		}
 		Logger.SetOutput(debugWriter)
 	}
@@ -204,7 +251,7 @@ func (client *Client) AddEventProcessor(processor EventProcessor) {
 	client.eventProcessors = append(client.eventProcessors, processor)
 }
 
-// Options return `ClientOptions` for the current `Client`.
+// Options return ClientOptions for the current Client.
 func (client Client) Options() ClientOptions {
 	return client.options
 }
@@ -224,36 +271,29 @@ func (client *Client) CaptureException(exception error, hint *EventHint, scope E
 // CaptureEvent captures an event on the currently active client if any.
 //
 // The event must already be assembled. Typically code would instead use
-// the utility methods like `CaptureException`. The return value is the
+// the utility methods like CaptureException. The return value is the
 // event ID. In case Sentry is disabled or event was dropped, the return value will be nil.
 func (client *Client) CaptureEvent(event *Event, hint *EventHint, scope EventModifier) *EventID {
 	return client.processEvent(event, hint, scope)
 }
 
 // Recover captures a panic.
-// Returns `EventID` if successfully, or `nil` if there's no error to recover from.
+// Returns EventID if successfully, or nil if there's no error to recover from.
 func (client *Client) Recover(err interface{}, hint *EventHint, scope EventModifier) *EventID {
 	if err == nil {
 		err = recover()
 	}
 
-	if err != nil {
-		if err, ok := err.(error); ok {
-			event := client.eventFromException(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
-
-		if err, ok := err.(string); ok {
-			event := client.eventFromMessage(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
-	}
-
-	return nil
+	// Normally we would not pass a nil Context, but RecoverWithContext doesn't
+	// use the Context for communicating deadline nor cancelation. All it does
+	// is store the Context in the EventHint and there nil means the Context is
+	// not available.
+	//nolint: staticcheck
+	return client.RecoverWithContext(nil, err, hint, scope)
 }
 
-// Recover captures a panic and passes relevant context object.
-// Returns `EventID` if successfully, or `nil` if there's no error to recover from.
+// RecoverWithContext captures a panic and passes relevant context object.
+// Returns EventID if successfully, or nil if there's no error to recover from.
 func (client *Client) RecoverWithContext(
 	ctx context.Context,
 	err interface{},
@@ -263,24 +303,29 @@ func (client *Client) RecoverWithContext(
 	if err == nil {
 		err = recover()
 	}
+	if err == nil {
+		return nil
+	}
 
-	if err != nil {
-		if hint.Context == nil && ctx != nil {
+	if ctx != nil {
+		if hint == nil {
+			hint = &EventHint{}
+		}
+		if hint.Context == nil {
 			hint.Context = ctx
 		}
-
-		if err, ok := err.(error); ok {
-			event := client.eventFromException(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
-
-		if err, ok := err.(string); ok {
-			event := client.eventFromMessage(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
 	}
 
-	return nil
+	var event *Event
+	switch err := err.(type) {
+	case error:
+		event = client.eventFromException(err, LevelFatal)
+	case string:
+		event = client.eventFromMessage(err, LevelFatal)
+	default:
+		event = client.eventFromMessage(fmt.Sprintf("%#v", err), LevelFatal)
+	}
+	return client.CaptureEvent(event, hint, scope)
 }
 
 // Flush waits until the underlying Transport sends any buffered events to the
@@ -299,6 +344,10 @@ func (client *Client) Flush(timeout time.Duration) bool {
 }
 
 func (client *Client) eventFromMessage(message string, level Level) *Event {
+	if message == "" {
+		err := usageError{fmt.Errorf("%s called with empty message", callerFunctionName())}
+		return client.eventFromException(err, level)
+	}
 	event := NewEvent()
 	event.Level = level
 	event.Message = message
@@ -362,6 +411,11 @@ func reverse(a []Exception) {
 }
 
 func (client *Client) processEvent(event *Event, hint *EventHint, scope EventModifier) *EventID {
+	if event == nil {
+		err := usageError{fmt.Errorf("%s called with nil event", callerFunctionName())}
+		return client.CaptureException(err, hint, scope)
+	}
+
 	options := client.Options()
 
 	// TODO: Reconsider if its worth going away from default implementation
@@ -369,7 +423,7 @@ func (client *Client) processEvent(event *Event, hint *EventHint, scope EventMod
 	// which means that if someone uses ClientOptions{} struct directly
 	// and we would not check for 0 here, we'd skip all events by default
 	if options.SampleRate != 0.0 {
-		randomFloat := rand.New(rand.NewSource(time.Now().UnixNano())).Float64()
+		randomFloat := rng.Float64()
 		if randomFloat > options.SampleRate {
 			Logger.Println("Event dropped due to SampleRate hit.")
 			return nil
@@ -380,7 +434,8 @@ func (client *Client) processEvent(event *Event, hint *EventHint, scope EventMod
 		return nil
 	}
 
-	if options.BeforeSend != nil {
+	// As per spec, transactions do not go through BeforeSend.
+	if event.Type != transactionType && options.BeforeSend != nil {
 		h := &EventHint{}
 		if hint != nil {
 			h = hint
@@ -412,7 +467,7 @@ func (client *Client) prepareEvent(event *Event, hint *EventHint, scope EventMod
 	if event.ServerName == "" {
 		if client.Options().ServerName != "" {
 			event.ServerName = client.Options().ServerName
-		} else if hostname, err := os.Hostname(); err == nil {
+		} else {
 			event.ServerName = hostname
 		}
 	}

vendor/github.com/getsentry/sentry-go/doc.go

@@ -0,0 +1,38 @@
+/*
+Package sentry is the official Sentry SDK for Go.
+
+For more information about Sentry and SDK features please have a look at the
+documentation site https://docs.sentry.io/platforms/go/.
+
+Basic Usage
+
+The first step is to initialize the SDK, providing at a minimum the DSN of your
+Sentry project. This step is accomplished through a call to sentry.Init.
+
+	func main() {
+		err := sentry.Init(...)
+		...
+	}
+
+A more detailed yet simple example is available at
+https://github.com/getsentry/sentry-go/blob/master/example/basic/main.go.
+
+Integrations
+
+The SDK has support for several Go frameworks, available as subpackages.
+
+Getting Support
+
+For paid Sentry.io accounts, head out to https://sentry.io/support.
+
+For all users, support channels include:
+	Forum: https://forum.sentry.io
+	Discord: https://discord.gg/Ww9hbqr (#go channel)
+
+If you found an issue with the SDK, please report through
+https://github.com/getsentry/sentry-go/issues/new/choose.
+
+For responsibly disclosing a security issue, please follow the steps in
+https://sentry.io/security/#vulnerability-disclosure.
+*/
+package sentry

vendor/github.com/getsentry/sentry-go/dsn.go

@@ -27,6 +27,8 @@ func (scheme scheme) defaultPort() int {
 	}
 }
 
+// DsnParseError represents an error that occurs if a Sentry
+// DSN cannot be parsed.
 type DsnParseError struct {
 	Message string
 }
@@ -46,7 +48,7 @@ type Dsn struct {
 	projectID int
 }
 
-// NewDsn creates an instance of `Dsn` by parsing provided url in a `string` format.
+// NewDsn creates an instance of Dsn by parsing provided url in a string format.
 // If Dsn is not set the client is effectively disabled.
 func NewDsn(rawURL string) (*Dsn, error) {
 	// Parse
@@ -123,7 +125,7 @@ func NewDsn(rawURL string) (*Dsn, error) {
 	}, nil
 }
 
-// String formats Dsn struct into a valid string url
+// String formats Dsn struct into a valid string url.
 func (dsn Dsn) String() string {
 	var url string
 	url += fmt.Sprintf("%s://%s", dsn.scheme, dsn.publicKey)
@@ -141,9 +143,19 @@ func (dsn Dsn) String() string {
 	return url
 }
 
-// StoreAPIURL returns assembled url to be used in the transport.
-// It points to configures Sentry instance.
+// StoreAPIURL returns the URL of the store endpoint of the project associated
+// with the DSN.
 func (dsn Dsn) StoreAPIURL() *url.URL {
+	return dsn.getAPIURL("store")
+}
+
+// EnvelopeAPIURL returns the URL of the envelope endpoint of the project
+// associated with the DSN.
+func (dsn Dsn) EnvelopeAPIURL() *url.URL {
+	return dsn.getAPIURL("envelope")
+}
+
+func (dsn Dsn) getAPIURL(s string) *url.URL {
 	var rawURL string
 	rawURL += fmt.Sprintf("%s://%s", dsn.scheme, dsn.host)
 	if dsn.port != dsn.scheme.defaultPort() {
@@ -152,7 +164,7 @@ func (dsn Dsn) StoreAPIURL() *url.URL {
 	if dsn.path != "" {
 		rawURL += dsn.path
 	}
-	rawURL += fmt.Sprintf("/api/%d/store/", dsn.projectID)
+	rawURL += fmt.Sprintf("/api/%d/%s/", dsn.projectID, s)
 	parsedURL, _ := url.Parse(rawURL)
 	return parsedURL
 }
@@ -172,10 +184,12 @@ func (dsn Dsn) RequestHeaders() map[string]string {
 	}
 }
 
+// MarshalJSON converts the Dsn struct to JSON.
 func (dsn Dsn) MarshalJSON() ([]byte, error) {
 	return json.Marshal(dsn.String())
 }
 
+// UnmarshalJSON converts JSON data to the Dsn struct.
 func (dsn *Dsn) UnmarshalJSON(data []byte) error {
 	var str string
 	_ = json.Unmarshal(data, &str)

vendor/github.com/getsentry/sentry-go/go.mod

@@ -31,5 +31,3 @@ require (
 	github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 // indirect
 	github.com/yudai/pp v2.0.1+incompatible // indirect
 )
-
-replace github.com/ugorji/go v1.1.4 => github.com/ugorji/go/codec v0.0.0-20190204201341-e444a5086c43

vendor/github.com/getsentry/sentry-go/go.sum

@@ -170,13 +170,11 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/ugorji/go v1.1.2/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8 h1:3SVOIvH7Ae1KRYyQWRjXWJEA9sS/c/pjvH++55Gr648=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
-github.com/ugorji/go/codec v0.0.0-20190204201341-e444a5086c43 h1:BasDe+IErOQKrMVXab7UayvSlIpiyGwRvuX3EKYY7UA=
-github.com/ugorji/go/codec v0.0.0-20190204201341-e444a5086c43/go.mod h1:iT03XoTwV7xq/+UGwKO3UbC1nNNlopQiY61beSdrtOA=
 github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
 github.com/urfave/negroni v1.0.0 h1:kIimOitoypq34K7TG7DUaJ9kq/N4Ofuwi1sjz0KipXc=

vendor/github.com/getsentry/sentry-go/http/sentryhttp.go

@@ -50,32 +50,28 @@ func New(options Options) *Handler {
 
 // Handle wraps http.Handler and recovers from caught panics.
 func (h *Handler) Handle(handler http.Handler) http.Handler {
+	return h.handle(handler)
+}
+
+// Deprecated: Use the Handle method instead.
+func (h *Handler) HandleFunc(handler http.HandlerFunc) http.HandlerFunc {
+	return h.handle(handler)
+}
+
+func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		hub := sentry.CurrentHub().Clone()
+		ctx := r.Context()
+		hub := sentry.GetHubFromContext(ctx)
+		if hub == nil {
+			hub = sentry.CurrentHub().Clone()
+		}
 		hub.Scope().SetRequest(r)
-		ctx := sentry.SetHubOnContext(
-			r.Context(),
-			hub,
-		)
+		ctx = sentry.SetHubOnContext(ctx, hub)
 		defer h.recoverWithSentry(hub, r)
 		handler.ServeHTTP(rw, r.WithContext(ctx))
 	})
 }
 
-// HandleFunc wraps http.HandleFunc and recovers from caught panics.
-func (h *Handler) HandleFunc(handler http.HandlerFunc) http.HandlerFunc {
-	return func(rw http.ResponseWriter, r *http.Request) {
-		hub := sentry.CurrentHub().Clone()
-		hub.Scope().SetRequest(r)
-		ctx := sentry.SetHubOnContext(
-			r.Context(),
-			hub,
-		)
-		defer h.recoverWithSentry(hub, r)
-		handler(rw, r.WithContext(ctx))
-	}
-}
-
 func (h *Handler) recoverWithSentry(hub *sentry.Hub, r *http.Request) {
 	if err := recover(); err != nil {
 		eventID := hub.RecoverWithContext(

vendor/github.com/getsentry/sentry-go/hub.go

@@ -8,21 +8,25 @@ import (
 
 type contextKey int
 
-// HubContextKey is a context key used to store Hub on any context.Context type
-const HubContextKey = contextKey(1)
+// Keys used to store values in a Context. Use with Context.Value to access
+// values stored by the SDK.
+const (
+	// HubContextKey is the key used to store the current Hub.
+	HubContextKey = contextKey(1)
+	// RequestContextKey is the key used to store the current http.Request.
+	RequestContextKey = contextKey(2)
+)
 
-// RequestContextKey is a context key used to store http.Request on the context passed to RecoverWithContext
-const RequestContextKey = contextKey(2)
-
-// Default maximum number of breadcrumbs added to an event. Can be overwritten `maxBreadcrumbs` option.
+// defaultMaxBreadcrumbs is the default maximum number of breadcrumbs added to
+// an event. Can be overwritten with the maxBreadcrumbs option.
 const defaultMaxBreadcrumbs = 30
 
-// Absolute maximum number of breadcrumbs added to an event.
-// The `maxBreadcrumbs` option cannot be higher than this value.
+// maxBreadcrumbs is the absolute maximum number of breadcrumbs added to an
+// event. The maxBreadcrumbs option cannot be set higher than this value.
 const maxBreadcrumbs = 100
 
-// Initial instance of the Hub that has no `Client` bound and an empty `Scope`
-var currentHub = NewHub(nil, NewScope()) //nolint: gochecknoglobals
+// currentHub is the initial Hub with no Client bound and an empty Scope.
+var currentHub = NewHub(nil, NewScope())
 
 // Hub is the central object that manages scopes and clients.
 //
@@ -31,7 +35,7 @@ var currentHub = NewHub(nil, NewScope()) //nolint: gochecknoglobals
 //
 // In most situations developers do not need to interface the hub. Instead
 // toplevel convenience functions are exposed that will automatically dispatch
-// to global (`CurrentHub`) hub.  In some situations this might not be
+// to global (CurrentHub) hub.  In some situations this might not be
 // possible in which case it might become necessary to manually work with the
 // hub. This is for instance the case when working with async code.
 type Hub struct {
@@ -64,7 +68,7 @@ func (l *layer) SetClient(c *Client) {
 
 type stack []*layer
 
-// NewHub returns an instance of a `Hub` with provided `Client` and `Scope` bound.
+// NewHub returns an instance of a Hub with provided Client and Scope bound.
 func NewHub(client *Client, scope *Scope) *Hub {
 	hub := Hub{
 		stack: &stack{{
@@ -75,13 +79,16 @@ func NewHub(client *Client, scope *Scope) *Hub {
 	return &hub
 }
 
-// CurrentHub returns an instance of previously initialized `Hub` stored in the global namespace.
+// CurrentHub returns an instance of previously initialized Hub stored in the global namespace.
 func CurrentHub() *Hub {
 	return currentHub
 }
 
-// LastEventID returns an ID of last captured event for the current `Hub`.
+// LastEventID returns an ID of last captured event for the current Hub.
 func (hub *Hub) LastEventID() EventID {
+	hub.mu.RLock()
+	defer hub.mu.RUnlock()
+
 	return hub.lastEventID
 }
 
@@ -116,7 +123,7 @@ func (hub *Hub) Clone() *Hub {
 	return NewHub(top.Client(), scope)
 }
 
-// Scope returns top-level `Scope` of the current `Hub` or `nil` if no `Scope` is bound.
+// Scope returns top-level Scope of the current Hub or nil if no Scope is bound.
 func (hub *Hub) Scope() *Scope {
 	top := hub.stackTop()
 	if top == nil {
@@ -125,7 +132,7 @@ func (hub *Hub) Scope() *Scope {
 	return top.scope
 }
 
-// Scope returns top-level `Client` of the current `Hub` or `nil` if no `Client` is bound.
+// Client returns top-level Client of the current Hub or nil if no Client is bound.
 func (hub *Hub) Client() *Client {
 	top := hub.stackTop()
 	if top == nil {
@@ -134,7 +141,7 @@ func (hub *Hub) Client() *Client {
 	return top.Client()
 }
 
-// PushScope pushes a new scope for the current `Hub` and reuses previously bound `Client`.
+// PushScope pushes a new scope for the current Hub and reuses previously bound Client.
 func (hub *Hub) PushScope() *Scope {
 	top := hub.stackTop()
 
@@ -161,7 +168,7 @@ func (hub *Hub) PushScope() *Scope {
 	return scope
 }
 
-// PushScope pops the most recent scope for the current `Hub`.
+// PopScope pops the most recent scope for the current Hub.
 func (hub *Hub) PopScope() {
 	hub.mu.Lock()
 	defer hub.mu.Unlock()
@@ -173,7 +180,7 @@ func (hub *Hub) PopScope() {
 	}
 }
 
-// BindClient binds a new `Client` for the current `Hub`.
+// BindClient binds a new Client for the current Hub.
 func (hub *Hub) BindClient(client *Client) {
 	top := hub.stackTop()
 	if top != nil {
@@ -181,36 +188,46 @@ func (hub *Hub) BindClient(client *Client) {
 	}
 }
 
-// WithScope temporarily pushes a scope for a single call.
+// WithScope runs f in an isolated temporary scope.
 //
-// A shorthand for:
-// PushScope()
-// f(scope)
-// PopScope()
+// It is useful when extra data should be sent with a single capture call, for
+// instance a different level or tags.
+//
+// The scope passed to f starts as a clone of the current scope and can be
+// freely modified without affecting the current scope.
+//
+// It is a shorthand for PushScope followed by PopScope.
 func (hub *Hub) WithScope(f func(scope *Scope)) {
 	scope := hub.PushScope()
 	defer hub.PopScope()
 	f(scope)
 }
 
-// ConfigureScope invokes a function that can modify the current scope.
+// ConfigureScope runs f in the current scope.
 //
-// The function is passed a mutable reference to the `Scope` so that modifications
-// can be performed.
+// It is useful to set data that applies to all events that share the current
+// scope.
+//
+// Modifying the scope affects all references to the current scope.
+//
+// See also WithScope for making isolated temporary changes.
 func (hub *Hub) ConfigureScope(f func(scope *Scope)) {
 	scope := hub.Scope()
 	f(scope)
 }
 
-// CaptureEvent calls the method of a same name on currently bound `Client` instance
-// passing it a top-level `Scope`.
-// Returns `EventID` if successfully, or `nil` if there's no `Scope` or `Client` available.
+// CaptureEvent calls the method of a same name on currently bound Client instance
+// passing it a top-level Scope.
+// Returns EventID if successfully, or nil if there's no Scope or Client available.
 func (hub *Hub) CaptureEvent(event *Event) *EventID {
 	client, scope := hub.Client(), hub.Scope()
 	if client == nil || scope == nil {
 		return nil
 	}
 	eventID := client.CaptureEvent(event, nil, scope)
+
+	hub.mu.Lock()
+	defer hub.mu.Unlock()
 	if eventID != nil {
 		hub.lastEventID = *eventID
 	} else {
@@ -219,15 +236,18 @@ func (hub *Hub) CaptureEvent(event *Event) *EventID {
 	return eventID
 }
 
-// CaptureMessage calls the method of a same name on currently bound `Client` instance
-// passing it a top-level `Scope`.
-// Returns `EventID` if successfully, or `nil` if there's no `Scope` or `Client` available.
+// CaptureMessage calls the method of a same name on currently bound Client instance
+// passing it a top-level Scope.
+// Returns EventID if successfully, or nil if there's no Scope or Client available.
 func (hub *Hub) CaptureMessage(message string) *EventID {
 	client, scope := hub.Client(), hub.Scope()
 	if client == nil || scope == nil {
 		return nil
 	}
 	eventID := client.CaptureMessage(message, nil, scope)
+
+	hub.mu.Lock()
+	defer hub.mu.Unlock()
 	if eventID != nil {
 		hub.lastEventID = *eventID
 	} else {
@@ -236,15 +256,18 @@ func (hub *Hub) CaptureMessage(message string) *EventID {
 	return eventID
 }
 
-// CaptureException calls the method of a same name on currently bound `Client` instance
-// passing it a top-level `Scope`.
-// Returns `EventID` if successfully, or `nil` if there's no `Scope` or `Client` available.
+// CaptureException calls the method of a same name on currently bound Client instance
+// passing it a top-level Scope.
+// Returns EventID if successfully, or nil if there's no Scope or Client available.
 func (hub *Hub) CaptureException(exception error) *EventID {
 	client, scope := hub.Client(), hub.Scope()
 	if client == nil || scope == nil {
 		return nil
 	}
 	eventID := client.CaptureException(exception, &EventHint{OriginalException: exception}, scope)
+
+	hub.mu.Lock()
+	defer hub.mu.Unlock()
 	if eventID != nil {
 		hub.lastEventID = *eventID
 	} else {
@@ -294,9 +317,9 @@ func (hub *Hub) AddBreadcrumb(breadcrumb *Breadcrumb, hint *BreadcrumbHint) {
 	hub.Scope().AddBreadcrumb(breadcrumb, max)
 }
 
-// Recover calls the method of a same name on currently bound `Client` instance
-// passing it a top-level `Scope`.
-// Returns `EventID` if successfully, or `nil` if there's no `Scope` or `Client` available.
+// Recover calls the method of a same name on currently bound Client instance
+// passing it a top-level Scope.
+// Returns EventID if successfully, or nil if there's no Scope or Client available.
 func (hub *Hub) Recover(err interface{}) *EventID {
 	if err == nil {
 		err = recover()
@@ -308,9 +331,9 @@ func (hub *Hub) Recover(err interface{}) *EventID {
 	return client.Recover(err, &EventHint{RecoveredException: err}, scope)
 }
 
-// RecoverWithContext calls the method of a same name on currently bound `Client` instance
-// passing it a top-level `Scope`.
-// Returns `EventID` if successfully, or `nil` if there's no `Scope` or `Client` available.
+// RecoverWithContext calls the method of a same name on currently bound Client instance
+// passing it a top-level Scope.
+// Returns EventID if successfully, or nil if there's no Scope or Client available.
 func (hub *Hub) RecoverWithContext(ctx context.Context, err interface{}) *EventID {
 	if err == nil {
 		err = recover()
@@ -343,14 +366,14 @@ func (hub *Hub) Flush(timeout time.Duration) bool {
 	return client.Flush(timeout)
 }
 
-// HasHubOnContext checks whether `Hub` instance is bound to a given `Context` struct.
+// HasHubOnContext checks whether Hub instance is bound to a given Context struct.
 func HasHubOnContext(ctx context.Context) bool {
 	_, ok := ctx.Value(HubContextKey).(*Hub)
 	return ok
 }
 
-// GetHubFromContext tries to retrieve `Hub` instance from the given `Context` struct
-// or return `nil` if one is not found.
+// GetHubFromContext tries to retrieve Hub instance from the given Context struct
+// or return nil if one is not found.
 func GetHubFromContext(ctx context.Context) *Hub {
 	if hub, ok := ctx.Value(HubContextKey).(*Hub); ok {
 		return hub
@@ -358,7 +381,7 @@ func GetHubFromContext(ctx context.Context) *Hub {
 	return nil
 }
 
-// SetHubOnContext stores given `Hub` instance on the `Context` struct and returns a new `Context`.
+// SetHubOnContext stores given Hub instance on the Context struct and returns a new Context.
 func SetHubOnContext(ctx context.Context, hub *Hub) context.Context {
 	return context.WithValue(ctx, HubContextKey, hub)
 }

vendor/github.com/getsentry/sentry-go/integrations.go

@@ -70,27 +70,49 @@ func (ei *environmentIntegration) SetupOnce(client *Client) {
 }
 
 func (ei *environmentIntegration) processor(event *Event, hint *EventHint) *Event {
+	// Initialize maps as necessary.
 	if event.Contexts == nil {
 		event.Contexts = make(map[string]interface{})
 	}
-
-	event.Contexts["device"] = map[string]interface{}{
-		"arch":    runtime.GOARCH,
-		"num_cpu": runtime.NumCPU(),
+	for _, name := range []string{"device", "os", "runtime"} {
+		if event.Contexts[name] == nil {
+			event.Contexts[name] = make(map[string]interface{})
+		}
 	}
 
-	event.Contexts["os"] = map[string]interface{}{
-		"name": runtime.GOOS,
+	// Set contextual information preserving existing data. For each context, if
+	// the existing value is not of type map[string]interface{}, then no
+	// additional information is added.
+	if deviceContext, ok := event.Contexts["device"].(map[string]interface{}); ok {
+		if _, ok := deviceContext["arch"]; !ok {
+			deviceContext["arch"] = runtime.GOARCH
+		}
+		if _, ok := deviceContext["num_cpu"]; !ok {
+			deviceContext["num_cpu"] = runtime.NumCPU()
+		}
 	}
-
-	event.Contexts["runtime"] = map[string]interface{}{
-		"name":           "go",
-		"version":        runtime.Version(),
-		"go_numroutines": runtime.NumGoroutine(),
-		"go_maxprocs":    runtime.GOMAXPROCS(0),
-		"go_numcgocalls": runtime.NumCgoCall(),
+	if osContext, ok := event.Contexts["os"].(map[string]interface{}); ok {
+		if _, ok := osContext["name"]; !ok {
+			osContext["name"] = runtime.GOOS
+		}
+	}
+	if runtimeContext, ok := event.Contexts["runtime"].(map[string]interface{}); ok {
+		if _, ok := runtimeContext["name"]; !ok {
+			runtimeContext["name"] = "go"
+		}
+		if _, ok := runtimeContext["version"]; !ok {
+			runtimeContext["version"] = runtime.Version()
+		}
+		if _, ok := runtimeContext["go_numroutines"]; !ok {
+			runtimeContext["go_numroutines"] = runtime.NumGoroutine()
+		}
+		if _, ok := runtimeContext["go_maxprocs"]; !ok {
+			runtimeContext["go_maxprocs"] = runtime.GOMAXPROCS(0)
+		}
+		if _, ok := runtimeContext["go_numcgocalls"]; !ok {
+			runtimeContext["go_numcgocalls"] = runtime.NumCgoCall()
+		}
 	}
-
 	return event
 }
 

vendor/github.com/getsentry/sentry-go/interfaces.go

@@ -13,9 +13,13 @@ import (
 // Protocol Docs (kinda)
 // https://github.com/getsentry/rust-sentry-types/blob/master/src/protocol/v7.rs
 
-// Level marks the severity of the event
+// transactionType is the type of a transaction event.
+const transactionType = "transaction"
+
+// Level marks the severity of the event.
 type Level string
 
+// Describes the severity of the event.
 const (
 	LevelDebug   Level = "debug"
 	LevelInfo    Level = "info"
@@ -24,7 +28,7 @@ const (
 	LevelFatal   Level = "fatal"
 )
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/sdk/
+// SdkInfo contains all metadata about about the SDK being used.
 type SdkInfo struct {
 	Name         string       `json:"name,omitempty"`
 	Version      string       `json:"version,omitempty"`
@@ -32,6 +36,7 @@ type SdkInfo struct {
 	Packages     []SdkPackage `json:"packages,omitempty"`
 }
 
+// SdkPackage describes a package that was installed.
 type SdkPackage struct {
 	Name    string `json:"name,omitempty"`
 	Version string `json:"version,omitempty"`
@@ -39,10 +44,13 @@ type SdkPackage struct {
 
 // TODO: This type could be more useful, as map of interface{} is too generic
 // and requires a lot of type assertions in beforeBreadcrumb calls
-// plus it could just be `map[string]interface{}` then
+// plus it could just be map[string]interface{} then.
+
+// BreadcrumbHint contains information that can be associated with a Breadcrumb.
 type BreadcrumbHint map[string]interface{}
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/breadcrumbs/
+// Breadcrumb specifies an application event that occurred before a Sentry event.
+// An event may contain one or more breadcrumbs.
 type Breadcrumb struct {
 	Category  string                 `json:"category,omitempty"`
 	Data      map[string]interface{} `json:"data,omitempty"`
@@ -52,6 +60,7 @@ type Breadcrumb struct {
 	Type      string                 `json:"type,omitempty"`
 }
 
+// MarshalJSON converts the Breadcrumb struct to JSON.
 func (b *Breadcrumb) MarshalJSON() ([]byte, error) {
 	type alias Breadcrumb
 	// encoding/json doesn't support the "omitempty" option for struct types.
@@ -67,14 +76,11 @@ func (b *Breadcrumb) MarshalJSON() ([]byte, error) {
 			alias: (*alias)(b),
 		})
 	}
-	return json.Marshal(&struct {
-		*alias
-	}{
-		alias: (*alias)(b),
-	})
+	return json.Marshal((*alias)(b))
 }
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/user/
+// User describes the user associated with an Event. If this is used, at least
+// an ID or an IP address should be provided.
 type User struct {
 	Email     string `json:"email,omitempty"`
 	ID        string `json:"id,omitempty"`
@@ -82,7 +88,7 @@ type User struct {
 	Username  string `json:"username,omitempty"`
 }
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/request/
+// Request contains information on a HTTP request related to the event.
 type Request struct {
 	URL         string            `json:"url,omitempty"`
 	Method      string            `json:"method,omitempty"`
@@ -131,7 +137,7 @@ func NewRequest(r *http.Request) *Request {
 	}
 }
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/exception/
+// Exception specifies an error that occurred.
 type Exception struct {
 	Type          string      `json:"type,omitempty"`
 	Value         string      `json:"value,omitempty"`
@@ -141,9 +147,11 @@ type Exception struct {
 	RawStacktrace *Stacktrace `json:"raw_stacktrace,omitempty"`
 }
 
+// EventID is a hexadecimal string representing a unique uuid4 for an Event.
+// An EventID must be 32 characters long, lowercase and not have any dashes.
 type EventID string
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/
+// Event is the fundamental data structure that is sent to Sentry.
 type Event struct {
 	Breadcrumbs []*Breadcrumb          `json:"breadcrumbs,omitempty"`
 	Contexts    map[string]interface{} `json:"contexts,omitempty"`
@@ -167,30 +175,57 @@ type Event struct {
 	Modules     map[string]string      `json:"modules,omitempty"`
 	Request     *Request               `json:"request,omitempty"`
 	Exception   []Exception            `json:"exception,omitempty"`
+
+	// Experimental: This is part of a beta feature of the SDK. The fields below
+	// are only relevant for transactions.
+	Type           string    `json:"type,omitempty"`
+	StartTimestamp time.Time `json:"start_timestamp"`
+	Spans          []*Span   `json:"spans,omitempty"`
 }
 
+// MarshalJSON converts the Event struct to JSON.
 func (e *Event) MarshalJSON() ([]byte, error) {
-	type alias Event
-	// encoding/json doesn't support the "omitempty" option for struct types.
-	// See https://golang.org/issues/11939.
-	// This implementation of MarshalJSON shadows the original Timestamp field
-	// forcing it to be omitted when the Timestamp is the zero value of
-	// time.Time.
-	if e.Timestamp.IsZero() {
-		return json.Marshal(&struct {
-			*alias
-			Timestamp json.RawMessage `json:"timestamp,omitempty"`
-		}{
-			alias: (*alias)(e),
-		})
+	// event aliases Event to allow calling json.Marshal without an infinite
+	// loop. It preserves all fields of Event while none of the attached
+	// methods.
+	type event Event
+
+	// Transactions are marshaled in the standard way how json.Marshal works.
+	if e.Type == transactionType {
+		return json.Marshal((*event)(e))
 	}
-	return json.Marshal(&struct {
-		*alias
-	}{
-		alias: (*alias)(e),
-	})
+
+	// errorEvent is like Event with some shadowed fields for customizing the
+	// JSON serialization of regular "error events".
+	type errorEvent struct {
+		*event
+
+		// encoding/json doesn't support the omitempty option for struct types.
+		// See https://golang.org/issues/11939.
+		// We shadow the original Event.Timestamp field with a json.RawMessage.
+		// This allows us to include the timestamp when non-zero and omit it
+		// otherwise.
+		Timestamp json.RawMessage `json:"timestamp,omitempty"`
+
+		// The fields below are not part of the regular "error events" and only
+		// make sense to be sent for transactions. They shadow the respective
+		// fields in Event and are meant to remain nil, triggering the omitempty
+		// behavior.
+		Type           json.RawMessage `json:"type,omitempty"`
+		StartTimestamp json.RawMessage `json:"start_timestamp,omitempty"`
+		Spans          json.RawMessage `json:"spans,omitempty"`
+	}
+
+	x := &errorEvent{event: (*event)(e)}
+	if !e.Timestamp.IsZero() {
+		x.Timestamp = append(x.Timestamp, '"')
+		x.Timestamp = e.Timestamp.UTC().AppendFormat(x.Timestamp, time.RFC3339Nano)
+		x.Timestamp = append(x.Timestamp, '"')
+	}
+	return json.Marshal(x)
 }
 
+// NewEvent creates a new Event.
 func NewEvent() *Event {
 	event := Event{
 		Contexts: make(map[string]interface{}),
@@ -201,6 +236,7 @@ func NewEvent() *Event {
 	return &event
 }
 
+// Thread specifies threads that were running at the time of an event.
 type Thread struct {
 	ID            string      `json:"id,omitempty"`
 	Name          string      `json:"name,omitempty"`
@@ -210,6 +246,7 @@ type Thread struct {
 	Current       bool        `json:"current,omitempty"`
 }
 
+// EventHint contains information that can be associated with an Event.
 type EventHint struct {
 	Data               interface{}
 	EventID            string
@@ -219,3 +256,30 @@ type EventHint struct {
 	Request            *http.Request
 	Response           *http.Response
 }
+
+// TraceContext describes the context of the trace.
+//
+// Experimental: This is part of a beta feature of the SDK.
+type TraceContext struct {
+	TraceID     string `json:"trace_id"`
+	SpanID      string `json:"span_id"`
+	Op          string `json:"op,omitempty"`
+	Description string `json:"description,omitempty"`
+	Status      string `json:"status,omitempty"`
+}
+
+// Span describes a timed unit of work in a trace.
+//
+// Experimental: This is part of a beta feature of the SDK.
+type Span struct {
+	TraceID        string                 `json:"trace_id"`
+	SpanID         string                 `json:"span_id"`
+	ParentSpanID   string                 `json:"parent_span_id,omitempty"`
+	Op             string                 `json:"op,omitempty"`
+	Description    string                 `json:"description,omitempty"`
+	Status         string                 `json:"status,omitempty"`
+	Tags           map[string]string      `json:"tags,omitempty"`
+	StartTimestamp time.Time              `json:"start_timestamp"`
+	EndTimestamp   time.Time              `json:"timestamp"`
+	Data           map[string]interface{} `json:"data,omitempty"`
+}

vendor/github.com/getsentry/sentry-go/scope.go

@@ -11,19 +11,18 @@ import (
 
 // Scope holds contextual data for the current scope.
 //
-// The scope is an object that can cloned efficiently and stores data that
-// is locally relevant to an event.  For instance the scope will hold recorded
+// The scope is an object that can cloned efficiently and stores data that is
+// locally relevant to an event. For instance the scope will hold recorded
 // breadcrumbs and similar information.
 //
-// The scope can be interacted with in two ways:
+// The scope can be interacted with in two ways. First, the scope is routinely
+// updated with information by functions such as AddBreadcrumb which will modify
+// the current scope. Second, the current scope can be configured through the
+// ConfigureScope function or Hub method of the same name.
 //
-// 1. the scope is routinely updated with information by functions such as
-//    `AddBreadcrumb` which will modify the currently top-most scope.
-// 2. the topmost scope can also be configured through the `ConfigureScope`
-//    method.
-//
-// Note that the scope can only be modified but not inspected.
-// Only the client can use the scope to extract information currently.
+// The scope is meant to be modified but not inspected directly. When preparing
+// an event for reporting, the current client adds information from the current
+// scope into the event.
 type Scope struct {
 	mu          sync.RWMutex
 	breadcrumbs []*Breadcrumb
@@ -47,6 +46,7 @@ type Scope struct {
 	eventProcessors []EventProcessor
 }
 
+// NewScope creates a new Scope.
 func NewScope() *Scope {
 	scope := Scope{
 		breadcrumbs: make([]*Breadcrumb, 0),
@@ -309,6 +309,7 @@ func (scope *Scope) Clone() *Scope {
 	clone.level = scope.level
 	clone.transaction = scope.transaction
 	clone.request = scope.request
+	clone.requestBody = scope.requestBody
 
 	return clone
 }

vendor/github.com/getsentry/sentry-go/sentry.go

@@ -5,14 +5,15 @@ import (
 	"time"
 )
 
-// Version is the version of the sentry-go SDK.
-const Version = "0.6.1"
+// Version is the version of the SDK.
+const Version = "0.7.0"
 
 // apiVersion is the minimum version of the Sentry API compatible with the
 // sentry-go SDK.
 const apiVersion = "7"
 
-// Init initializes whole SDK by creating new `Client` and binding it to the current `Hub`
+// Init initializes the SDK with options. The returned error is non-nil if
+// options is invalid, for instance if a malformed DSN is provided.
 func Init(options ClientOptions) error {
 	hub := CurrentHub()
 	client, err := NewClient(options)
@@ -47,7 +48,7 @@ func CaptureException(exception error) *EventID {
 // CaptureEvent captures an event on the currently active client if any.
 //
 // The event must already be assembled. Typically code would instead use
-// the utility methods like `CaptureException`. The return value is the
+// the utility methods like CaptureException. The return value is the
 // event ID. In case Sentry is disabled or event was dropped, the return value will be nil.
 func CaptureEvent(event *Event) *EventID {
 	hub := CurrentHub()
@@ -63,7 +64,7 @@ func Recover() *EventID {
 	return nil
 }
 
-// Recover captures a panic and passes relevant context object.
+// RecoverWithContext captures a panic and passes relevant context object.
 func RecoverWithContext(ctx context.Context) *EventID {
 	if err := recover(); err != nil {
 		var hub *Hub
@@ -79,34 +80,25 @@ func RecoverWithContext(ctx context.Context) *EventID {
 	return nil
 }
 
-// WithScope temporarily pushes a scope for a single call.
-//
-// This function takes one argument, a callback that executes
-// in the context of that scope.
-//
-// This is useful when extra data should be send with a single capture call
-// for instance a different level or tags
+// WithScope is a shorthand for CurrentHub().WithScope.
 func WithScope(f func(scope *Scope)) {
 	hub := CurrentHub()
 	hub.WithScope(f)
 }
 
-// ConfigureScope invokes a function that can modify the current scope.
-//
-// The function is passed a mutable reference to the `Scope` so that modifications
-// can be performed.
+// ConfigureScope is a shorthand for CurrentHub().ConfigureScope.
 func ConfigureScope(f func(scope *Scope)) {
 	hub := CurrentHub()
 	hub.ConfigureScope(f)
 }
 
-// PushScope pushes a new scope.
+// PushScope is a shorthand for CurrentHub().PushPushScope.
 func PushScope() {
 	hub := CurrentHub()
 	hub.PushScope()
 }
 
-// PopScope pushes a new scope.
+// PopScope is a shorthand for CurrentHub().PopScope.
 func PopScope() {
 	hub := CurrentHub()
 	hub.PopScope()

vendor/github.com/getsentry/sentry-go/sourcereader.go

@@ -36,11 +36,12 @@ func (sr *sourceReader) readContextLines(filename string, line, context int) ([]
 	return sr.calculateContextLines(lines, line, context)
 }
 
-// `contextLine` points to a line that caused an issue itself, in relation to returned slice
 func (sr *sourceReader) calculateContextLines(lines [][]byte, line, context int) ([][]byte, int) {
 	// Stacktrace lines are 1-indexed, slices are 0-indexed
 	line--
 
+	// contextLine points to a line that caused an issue itself, in relation to
+	// returned slice.
 	contextLine := context
 
 	if lines == nil || line >= len(lines) || line < 0 {

vendor/github.com/getsentry/sentry-go/stacktrace.go

@@ -23,7 +23,7 @@ type Stacktrace struct {
 	FramesOmitted []uint  `json:"frames_omitted,omitempty"`
 }
 
-// NewStacktrace creates a stacktrace using `runtime.Callers`.
+// NewStacktrace creates a stacktrace using runtime.Callers.
 func NewStacktrace() *Stacktrace {
 	pcs := make([]uintptr, 100)
 	n := runtime.Callers(1, pcs)
@@ -42,17 +42,21 @@ func NewStacktrace() *Stacktrace {
 	return &stacktrace
 }
 
-// ExtractStacktrace creates a new `Stacktrace` based on the given `error` object.
 // TODO: Make it configurable so that anyone can provide their own implementation?
-// Use of reflection allows us to not have a hard dependency on any given package, so we don't have to import it
+// Use of reflection allows us to not have a hard dependency on any given
+// package, so we don't have to import it.
+
+// ExtractStacktrace creates a new Stacktrace based on the given error.
 func ExtractStacktrace(err error) *Stacktrace {
 	method := extractReflectedStacktraceMethod(err)
 
-	if !method.IsValid() {
-		return nil
-	}
+	var pcs []uintptr
 
-	pcs := extractPcs(method)
+	if method.IsValid() {
+		pcs = extractPcs(method)
+	} else {
+		pcs = extractXErrorsPC(err)
+	}
 
 	if len(pcs) == 0 {
 		return nil
@@ -127,7 +131,34 @@ func extractPcs(method reflect.Value) []uintptr {
 	return pcs
 }
 
-// https://docs.sentry.io/development/sdk-dev/event-payloads/stacktrace/
+// extractXErrorsPC extracts program counters from error values compatible with
+// the error types from golang.org/x/xerrors.
+//
+// It returns nil if err is not compatible with errors from that package or if
+// no program counters are stored in err.
+func extractXErrorsPC(err error) []uintptr {
+	// This implementation uses the reflect package to avoid a hard dependency
+	// on third-party packages.
+
+	// We don't know if err matches the expected type. For simplicity, instead
+	// of trying to account for all possible ways things can go wrong, some
+	// assumptions are made and if they are violated the code will panic. We
+	// recover from any panic and ignore it, returning nil.
+	//nolint: errcheck
+	defer func() { recover() }()
+
+	field := reflect.ValueOf(err).Elem().FieldByName("frame") // type Frame struct{ frames [3]uintptr }
+	field = field.FieldByName("frames")
+	field = field.Slice(1, field.Len()) // drop first pc pointing to xerrors.New
+	pc := make([]uintptr, field.Len())
+	for i := 0; i < field.Len(); i++ {
+		pc[i] = uintptr(field.Index(i).Uint())
+	}
+	return pc
+}
+
+// Frame represents a function call and it's metadata. Frames are associated
+// with a Stacktrace.
 type Frame struct {
 	Function    string                 `json:"function,omitempty"`
 	Symbol      string                 `json:"symbol,omitempty"`
@@ -144,30 +175,46 @@ type Frame struct {
 	Vars        map[string]interface{} `json:"vars,omitempty"`
 }
 
-// NewFrame assembles a stacktrace frame out of `runtime.Frame`.
+// NewFrame assembles a stacktrace frame out of runtime.Frame.
 func NewFrame(f runtime.Frame) Frame {
-	abspath := f.File
-	filename := f.File
+	var abspath, relpath string
+	// NOTE: f.File paths historically use forward slash as path separator even
+	// on Windows, though this is not yet documented, see
+	// https://golang.org/issues/3335. In any case, filepath.IsAbs can work with
+	// paths with either slash or backslash on Windows.
+	switch {
+	case f.File == "":
+		relpath = unknown
+		// Leave abspath as the empty string to be omitted when serializing
+		// event as JSON.
+		abspath = ""
+	case filepath.IsAbs(f.File):
+		abspath = f.File
+		// TODO: in the general case, it is not trivial to come up with a
+		// "project relative" path with the data we have in run time.
+		// We shall not use filepath.Base because it creates ambiguous paths and
+		// affects the "Suspect Commits" feature.
+		// For now, leave relpath empty to be omitted when serializing the event
+		// as JSON. Improve this later.
+		relpath = ""
+	default:
+		// f.File is a relative path. This may happen when the binary is built
+		// with the -trimpath flag.
+		relpath = f.File
+		// Omit abspath when serializing the event as JSON.
+		abspath = ""
+	}
+
 	function := f.Function
 	var pkg string
 
-	if filename != "" {
-		filename = filepath.Base(filename)
-	} else {
-		filename = unknown
-	}
-
-	if abspath == "" {
-		abspath = unknown
-	}
-
 	if function != "" {
 		pkg, function = splitQualifiedFunctionName(function)
 	}
 
 	frame := Frame{
 		AbsPath:  abspath,
-		Filename: filename,
+		Filename: relpath,
 		Lineno:   f.Line,
 		Module:   pkg,
 		Function: function,

vendor/github.com/getsentry/sentry-go/transport.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"crypto/tls"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -15,7 +17,7 @@ const defaultBufferSize = 30
 const defaultRetryAfter = time.Second * 60
 const defaultTimeout = time.Second * 30
 
-// Transport is used by the `Client` to deliver events to remote server.
+// Transport is used by the Client to deliver events to remote server.
 type Transport interface {
 	Flush(timeout time.Duration) bool
 	Configure(options ClientOptions)
@@ -70,8 +72,10 @@ func getRequestBodyFromEvent(event *Event) []byte {
 		return body
 	}
 
-	partialMarshallMessage := "Original event couldn't be marshalled. Succeeded by stripping the data " +
-		"that uses interface{} type. Please verify that the data you attach to the scope is serializable."
+	partialMarshallMessage := fmt.Sprintf("Could not encode original event as JSON. "+
+		"Succeeded by removing Breadcrumbs, Contexts and Extra. "+
+		"Please verify the data you attach to the scope. "+
+		"Error: %s", err)
 	// Try to serialize the event, with all the contextual data that allows for interface{} stripped.
 	event.Breadcrumbs = nil
 	event.Contexts = nil
@@ -92,6 +96,40 @@ func getRequestBodyFromEvent(event *Event) []byte {
 	return nil
 }
 
+func getEnvelopeFromBody(body []byte, now time.Time) *bytes.Buffer {
+	var b bytes.Buffer
+	fmt.Fprintf(&b, `{"sent_at":"%s"}`, now.UTC().Format(time.RFC3339Nano))
+	fmt.Fprint(&b, "\n", `{"type":"transaction"}`, "\n")
+	b.Write(body)
+	return &b
+}
+
+func getRequestFromEvent(event *Event, dsn *Dsn) (*http.Request, error) {
+	body := getRequestBodyFromEvent(event)
+	if body == nil {
+		return nil, errors.New("event could not be marshalled")
+	}
+
+	if event.Type == transactionType {
+		env := getEnvelopeFromBody(body, time.Now())
+		request, _ := http.NewRequest(
+			http.MethodPost,
+			dsn.EnvelopeAPIURL().String(),
+			env,
+		)
+
+		return request, nil
+	}
+
+	request, _ := http.NewRequest(
+		http.MethodPost,
+		dsn.StoreAPIURL().String(),
+		bytes.NewBuffer(body),
+	)
+
+	return request, nil
+}
+
 // ================================
 // HTTPTransport
 // ================================
@@ -103,7 +141,7 @@ type batch struct {
 	done    chan struct{} // closed to signal completion of all items
 }
 
-// HTTPTransport is a default implementation of `Transport` interface used by `Client`.
+// HTTPTransport is a default implementation of Transport interface used by Client.
 type HTTPTransport struct {
 	dsn       *Dsn
 	client    *http.Client
@@ -124,7 +162,7 @@ type HTTPTransport struct {
 	disabledUntil time.Time
 }
 
-// NewHTTPTransport returns a new pre-configured instance of HTTPTransport
+// NewHTTPTransport returns a new pre-configured instance of HTTPTransport.
 func NewHTTPTransport() *HTTPTransport {
 	transport := HTTPTransport{
 		BufferSize: defaultBufferSize,
@@ -133,7 +171,7 @@ func NewHTTPTransport() *HTTPTransport {
 	return &transport
 }
 
-// Configure is called by the `Client` itself, providing it it's own `ClientOptions`.
+// Configure is called by the Client itself, providing it it's own ClientOptions.
 func (t *HTTPTransport) Configure(options ClientOptions) {
 	dsn, err := NewDsn(options.Dsn)
 	if err != nil {
@@ -175,7 +213,7 @@ func (t *HTTPTransport) Configure(options ClientOptions) {
 	})
 }
 
-// SendEvent assembles a new packet out of `Event` and sends it to remote server.
+// SendEvent assembles a new packet out of Event and sends it to remote server.
 func (t *HTTPTransport) SendEvent(event *Event) {
 	if t.dsn == nil {
 		return
@@ -187,17 +225,11 @@ func (t *HTTPTransport) SendEvent(event *Event) {
 		return
 	}
 
-	body := getRequestBodyFromEvent(event)
-	if body == nil {
+	request, err := getRequestFromEvent(event, t.dsn)
+	if err != nil {
 		return
 	}
 
-	request, _ := http.NewRequest(
-		http.MethodPost,
-		t.dsn.StoreAPIURL().String(),
-		bytes.NewBuffer(body),
-	)
-
 	for headerKey, headerValue := range t.dsn.RequestHeaders() {
 		request.Header.Set(headerKey, headerValue)
 	}
@@ -332,7 +364,7 @@ func (t *HTTPTransport) worker() {
 // HTTPSyncTransport
 // ================================
 
-// HTTPSyncTransport is an implementation of `Transport` interface which blocks after each captured event.
+// HTTPSyncTransport is an implementation of Transport interface which blocks after each captured event.
 type HTTPSyncTransport struct {
 	dsn           *Dsn
 	client        *http.Client
@@ -343,7 +375,7 @@ type HTTPSyncTransport struct {
 	Timeout time.Duration
 }
 
-// NewHTTPSyncTransport returns a new pre-configured instance of HTTPSyncTransport
+// NewHTTPSyncTransport returns a new pre-configured instance of HTTPSyncTransport.
 func NewHTTPSyncTransport() *HTTPSyncTransport {
 	transport := HTTPSyncTransport{
 		Timeout: defaultTimeout,
@@ -352,7 +384,7 @@ func NewHTTPSyncTransport() *HTTPSyncTransport {
 	return &transport
 }
 
-// Configure is called by the `Client` itself, providing it it's own `ClientOptions`.
+// Configure is called by the Client itself, providing it it's own ClientOptions.
 func (t *HTTPSyncTransport) Configure(options ClientOptions) {
 	dsn, err := NewDsn(options.Dsn)
 	if err != nil {
@@ -380,23 +412,17 @@ func (t *HTTPSyncTransport) Configure(options ClientOptions) {
 	}
 }
 
-// SendEvent assembles a new packet out of `Event` and sends it to remote server.
+// SendEvent assembles a new packet out of Event and sends it to remote server.
 func (t *HTTPSyncTransport) SendEvent(event *Event) {
 	if t.dsn == nil || time.Now().Before(t.disabledUntil) {
 		return
 	}
 
-	body := getRequestBodyFromEvent(event)
-	if body == nil {
+	request, err := getRequestFromEvent(event, t.dsn)
+	if err != nil {
 		return
 	}
 
-	request, _ := http.NewRequest(
-		http.MethodPost,
-		t.dsn.StoreAPIURL().String(),
-		bytes.NewBuffer(body),
-	)
-
 	for headerKey, headerValue := range t.dsn.RequestHeaders() {
 		request.Header.Set(headerKey, headerValue)
 	}
@@ -430,7 +456,7 @@ func (t *HTTPSyncTransport) Flush(_ time.Duration) bool {
 // noopTransport
 // ================================
 
-// noopTransport is an implementation of `Transport` interface which drops all the events.
+// noopTransport is an implementation of Transport interface which drops all the events.
 // Only used internally when an empty DSN is provided, which effectively disables the SDK.
 type noopTransport struct{}
 

vendor/github.com/hako/durafmt/durafmt.go

@@ -17,9 +17,9 @@ var (
 
 // Durafmt holds the parsed duration and the original input duration.
 type Durafmt struct {
-	duration time.Duration
-	input    string // Used as reference.
-	limitN   int    // Non-zero to limit only first N elements to output.
+	duration  time.Duration
+	input     string // Used as reference.
+	limitN    int    // Non-zero to limit only first N elements to output.
 	limitUnit string // Non-empty to limit max unit
 }
 
@@ -35,6 +35,10 @@ func (d *Durafmt) LimitFirstN(n int) *Durafmt {
 	return d
 }
 
+func (d *Durafmt) Duration() time.Duration {
+	return d.duration
+}
+
 // Parse creates a new *Durafmt struct, returns error if input is invalid.
 func Parse(dinput time.Duration) *Durafmt {
 	input := dinput.String()
@@ -95,7 +99,7 @@ func (d *Durafmt) String() string {
 	var years int64
 	var shouldConvert = false
 
-	remainingSecondsToConvert := int64(d.duration/time.Microsecond)
+	remainingSecondsToConvert := int64(d.duration / time.Microsecond)
 
 	// Convert duration.
 	if d.limitUnit == "" {

vendor/github.com/jonboulle/clockwork/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.go]
+indent_style = tab

vendor/github.com/jonboulle/clockwork/.gitignore

@@ -1,3 +1,5 @@
+/.idea/
+
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o
 *.a

vendor/github.com/jonboulle/clockwork/.travis.yml

@@ -1,5 +0,0 @@
-language: go
-go:
-  - 1.3
-
-sudo: false

vendor/github.com/jonboulle/clockwork/README.md

@@ -1,61 +1,80 @@
-clockwork
-=========
+# clockwork
 
-[![Build Status](https://travis-ci.org/jonboulle/clockwork.png?branch=master)](https://travis-ci.org/jonboulle/clockwork)
-[![godoc](https://godoc.org/github.com/jonboulle/clockwork?status.svg)](http://godoc.org/github.com/jonboulle/clockwork) 
+[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/avelino/awesome-go#utilities)
 
-a simple fake clock for golang
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/jonboulle/clockwork/CI?style=flat-square)](https://github.com/jonboulle/clockwork/actions?query=workflow%3ACI)
+[![Go Report Card](https://goreportcard.com/badge/github.com/jonboulle/clockwork?style=flat-square)](https://goreportcard.com/report/github.com/jonboulle/clockwork)
+![Go Version](https://img.shields.io/badge/go%20version-%3E=1.11-61CFDD.svg?style=flat-square)
+[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/mod/github.com/jonboulle/clockwork)
 
-# Usage
+**A simple fake clock for Go.**
+
+
+## Usage
 
 Replace uses of the `time` package with the `clockwork.Clock` interface instead.
 
 For example, instead of using `time.Sleep` directly:
 
-```
-func my_func() {
+```go
+func myFunc() {
 	time.Sleep(3 * time.Second)
-	do_something()
+	doSomething()
 }
 ```
 
-inject a clock and use its `Sleep` method instead:
+Inject a clock and use its `Sleep` method instead:
 
-```
-func my_func(clock clockwork.Clock) {
+```go
+func myFunc(clock clockwork.Clock) {
 	clock.Sleep(3 * time.Second)
-	do_something()
+	doSomething()
 }
 ```
 
-Now you can easily test `my_func` with a `FakeClock`:
+Now you can easily test `myFunc` with a `FakeClock`:
 
-```
+```go
 func TestMyFunc(t *testing.T) {
 	c := clockwork.NewFakeClock()
 
 	// Start our sleepy function
-	my_func(c)
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		myFunc(c)
+		wg.Done()
+	}()
 
-	// Ensure we wait until my_func is sleeping
+	// Ensure we wait until myFunc is sleeping
 	c.BlockUntil(1)
 
-	assert_state()
+	assertState()
 
 	// Advance the FakeClock forward in time
-	c.Advance(3)
+	c.Advance(3 * time.Second)
 
-	assert_state()
+	// Wait until the function completes
+	wg.Wait()
+
+	assertState()
 }
 ```
 
 and in production builds, simply inject the real clock instead:
-```
-my_func(clockwork.NewRealClock())
+
+```go
+myFunc(clockwork.NewRealClock())
 ```
 
 See [example_test.go](example_test.go) for a full example.
 
+
 # Credits
 
-clockwork is inspired by @wickman's [threaded fake clock](https://gist.github.com/wickman/3840816), and the [Golang playground](http://blog.golang.org/playground#Faking time)
+clockwork is inspired by @wickman's [threaded fake clock](https://gist.github.com/wickman/3840816), and the [Golang playground](https://blog.golang.org/playground#TOC_3.1.)
+
+
+## License
+
+Apache License, Version 2.0. Please see [License File](LICENSE) for more information.

vendor/github.com/jonboulle/clockwork/clockwork.go

@@ -11,6 +11,8 @@ type Clock interface {
 	After(d time.Duration) <-chan time.Time
 	Sleep(d time.Duration)
 	Now() time.Time
+	Since(t time.Time) time.Duration
+	NewTicker(d time.Duration) Ticker
 }
 
 // FakeClock provides an interface for a clock which can be
@@ -60,6 +62,14 @@ func (rc *realClock) Now() time.Time {
 	return time.Now()
 }
 
+func (rc *realClock) Since(t time.Time) time.Duration {
+	return rc.Now().Sub(t)
+}
+
+func (rc *realClock) NewTicker(d time.Duration) Ticker {
+	return &realTicker{time.NewTicker(d)}
+}
+
 type fakeClock struct {
 	sleepers []*sleeper
 	blockers []*blocker
@@ -130,6 +140,22 @@ func (fc *fakeClock) Now() time.Time {
 	return t
 }
 
+// Since returns the duration that has passed since the given time on the fakeClock
+func (fc *fakeClock) Since(t time.Time) time.Duration {
+	return fc.Now().Sub(t)
+}
+
+func (fc *fakeClock) NewTicker(d time.Duration) Ticker {
+	ft := &fakeTicker{
+		c:      make(chan time.Time, 1),
+		stop:   make(chan bool, 1),
+		clock:  fc,
+		period: d,
+	}
+	go ft.tick()
+	return ft
+}
+
 // Advance advances fakeClock to a new point in time, ensuring channels from any
 // previous invocations of After are notified appropriately before returning
 func (fc *fakeClock) Advance(d time.Duration) {

vendor/github.com/jonboulle/clockwork/go.mod

@@ -0,0 +1,3 @@
+module github.com/jonboulle/clockwork
+
+go 1.13

vendor/github.com/jonboulle/clockwork/ticker.go

@@ -0,0 +1,66 @@
+package clockwork
+
+import (
+	"time"
+)
+
+// Ticker provides an interface which can be used instead of directly
+// using the ticker within the time module. The real-time ticker t
+// provides ticks through t.C which becomes now t.Chan() to make
+// this channel requirement definable in this interface.
+type Ticker interface {
+	Chan() <-chan time.Time
+	Stop()
+}
+
+type realTicker struct{ *time.Ticker }
+
+func (rt *realTicker) Chan() <-chan time.Time {
+	return rt.C
+}
+
+type fakeTicker struct {
+	c      chan time.Time
+	stop   chan bool
+	clock  FakeClock
+	period time.Duration
+}
+
+func (ft *fakeTicker) Chan() <-chan time.Time {
+	return ft.c
+}
+
+func (ft *fakeTicker) Stop() {
+	ft.stop <- true
+}
+
+// tick sends the tick time to the ticker channel after every period.
+// Tick events are discarded if the underlying ticker channel does
+// not have enough capacity.
+func (ft *fakeTicker) tick() {
+	tick := ft.clock.Now()
+	for {
+		tick = tick.Add(ft.period)
+		remaining := tick.Sub(ft.clock.Now())
+		if remaining <= 0 {
+			// The tick should have already happened. This can happen when
+			// Advance() is called on the fake clock with a duration larger
+			// than this ticker's period.
+			select {
+			case ft.c <- tick:
+			default:
+			}
+			continue
+		}
+
+		select {
+		case <-ft.stop:
+			return
+		case <-ft.clock.After(remaining):
+			select {
+			case ft.c <- tick:
+			default:
+			}
+		}
+	}
+}

vendor/github.com/josharian/intern/README.md

@@ -0,0 +1,5 @@
+Docs: https://godoc.org/github.com/josharian/intern
+
+See also [Go issue 5160](https://golang.org/issue/5160).
+
+License: MIT

vendor/github.com/josharian/intern/go.mod

@@ -0,0 +1,3 @@
+module github.com/josharian/intern
+
+go 1.5

vendor/github.com/josharian/intern/intern.go

@@ -0,0 +1,44 @@
+// Package intern interns strings.
+// Interning is best effort only.
+// Interned strings may be removed automatically
+// at any time without notification.
+// All functions may be called concurrently
+// with themselves and each other.
+package intern
+
+import "sync"
+
+var (
+	pool sync.Pool = sync.Pool{
+		New: func() interface{} {
+			return make(map[string]string)
+		},
+	}
+)
+
+// String returns s, interned.
+func String(s string) string {
+	m := pool.Get().(map[string]string)
+	c, ok := m[s]
+	if ok {
+		pool.Put(m)
+		return c
+	}
+	m[s] = s
+	pool.Put(m)
+	return s
+}
+
+// Bytes returns b converted to a string, interned.
+func Bytes(b []byte) string {
+	m := pool.Get().(map[string]string)
+	c, ok := m[string(b)]
+	if ok {
+		pool.Put(m)
+		return c
+	}
+	s := string(b)
+	m[s] = s
+	pool.Put(m)
+	return s
+}

vendor/github.com/josharian/intern/license.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Josh Bleecher Snyder
+
+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.

vendor/github.com/lib/pq/README.md

@@ -19,10 +19,7 @@
 * Unix socket support
 * Notifications: `LISTEN`/`NOTIFY`
 * pgpass support
-
-## Optional Features
-
-* GSS (Kerberos) auth (to use, see GoDoc)
+* GSS (Kerberos) auth
 
 ## Tests
 

vendor/github.com/lib/pq/conn.go

@@ -1074,9 +1074,9 @@ func isDriverSetting(key string) bool {
 		return true
 	case "binary_parameters":
 		return true
-	case "service":
+	case "krbsrvname":
 		return true
-	case "spn":
+	case "krbspn":
 		return true
 	default:
 		return false
@@ -1168,13 +1168,13 @@ func (cn *conn) auth(r *readBuf, o values) {
 
 		var token []byte
 
-		if spn, ok := o["spn"]; ok {
+		if spn, ok := o["krbspn"]; ok {
 			// Use the supplied SPN if provided..
 			token, err = cli.GetInitTokenFromSpn(spn)
 		} else {
 			// Allow the kerberos service name to be overridden
 			service := "postgres"
-			if val, ok := o["service"]; ok {
+			if val, ok := o["krbsrvname"]; ok {
 				service = val
 			}
 

vendor/github.com/lib/pq/connector.go

@@ -27,7 +27,7 @@ func (c *Connector) Connect(ctx context.Context) (driver.Conn, error) {
 	return c.open(ctx)
 }
 
-// Driver returnst the underlying driver of this Connector.
+// Driver returns the underlying driver of this Connector.
 func (c *Connector) Driver() driver.Driver {
 	return &Driver{}
 }

vendor/github.com/lib/pq/copy.go

@@ -49,6 +49,7 @@ type copyin struct {
 	buffer  []byte
 	rowData chan []byte
 	done    chan bool
+	driver.Result
 
 	closed bool
 
@@ -151,6 +152,8 @@ func (ci *copyin) resploop() {
 		switch t {
 		case 'C':
 			// complete
+			res, _ := ci.cn.parseComplete(r.string())
+			ci.setResult(res)
 		case 'N':
 			if n := ci.cn.noticeHandler; n != nil {
 				n(parseError(&r))
@@ -201,6 +204,22 @@ func (ci *copyin) setError(err error) {
 	ci.Unlock()
 }
 
+func (ci *copyin) setResult(result driver.Result) {
+	ci.Lock()
+	ci.Result = result
+	ci.Unlock()
+}
+
+func (ci *copyin) getResult() driver.Result {
+	ci.Lock()
+	result := ci.Result
+	if result == nil {
+		return driver.RowsAffected(0)
+	}
+	ci.Unlock()
+	return result
+}
+
 func (ci *copyin) NumInput() int {
 	return -1
 }
@@ -231,7 +250,11 @@ func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
 	}
 
 	if len(v) == 0 {
-		return driver.RowsAffected(0), ci.Close()
+		if err := ci.Close(); err != nil {
+			return driver.RowsAffected(0), err
+		}
+
+		return ci.getResult(), nil
 	}
 
 	numValues := len(v)

vendor/github.com/lib/pq/doc.go

@@ -57,8 +57,6 @@ supported:
 	* sslkey - Key file location. The file must contain PEM encoded data.
 	* sslrootcert - The location of the root certificate file. The file
 	  must contain PEM encoded data.
-	* spn - Configures GSS (Kerberos) SPN.
-	* service - GSS (Kerberos) service name to use when constructing the SPN (default is `postgres`).
 
 Valid values for sslmode are:
 
@@ -259,5 +257,12 @@ package:
 This package is in a separate module so that users who don't need Kerberos
 don't have to download unnecessary dependencies.
 
+When imported, additional connection string parameters are supported:
+
+	* krbsrvname - GSS (Kerberos) service name when constructing the
+	  SPN (default is `postgres`). This will be combined with the host
+	  to form the full SPN: `krbsrvname/host`.
+	* krbspn - GSS (Kerberos) SPN. This takes priority over
+	  `krbsrvname` if present.
 */
 package pq

vendor/github.com/mailru/easyjson/Makefile

@@ -20,22 +20,38 @@ generate: build
 		./tests/reference_to_pointer.go \
 		./tests/html.go \
 		./tests/unknown_fields.go \
-
-	bin/easyjson -all ./tests/data.go
-	bin/easyjson -all ./tests/nothing.go
-	bin/easyjson -all ./tests/errors.go
-	bin/easyjson -all ./tests/html.go
+		./tests/type_declaration.go \
+		./tests/type_declaration_skip.go \
+		./tests/members_escaped.go \
+		./tests/members_unescaped.go \
+		./tests/intern.go \
+		./tests/nocopy.go \
+		./tests/escaping.go
+	bin/easyjson -all \
+		./tests/data.go \
+ 		./tests/nothing.go \
+ 		./tests/errors.go \
+ 		./tests/html.go \
+ 		./tests/type_declaration_skip.go
+	bin/easyjson \
+		./tests/nested_easy.go \
+		./tests/named_type.go \
+		./tests/custom_map_key_type.go \
+		./tests/embedded_type.go \
+		./tests/reference_to_pointer.go \
+		./tests/key_marshaler_map.go \
+		./tests/unknown_fields.go \
+		./tests/type_declaration.go \
+		./tests/members_escaped.go \
+		./tests/intern.go \
+		./tests/nocopy.go \
+		./tests/escaping.go \
+		./tests/nested_marshaler.go
 	bin/easyjson -snake_case ./tests/snake.go
 	bin/easyjson -omit_empty ./tests/omitempty.go
-	bin/easyjson -build_tags=use_easyjson ./benchmark/data.go
-	bin/easyjson ./tests/nested_easy.go
-	bin/easyjson ./tests/named_type.go
-	bin/easyjson ./tests/custom_map_key_type.go
-	bin/easyjson ./tests/embedded_type.go
-	bin/easyjson ./tests/reference_to_pointer.go
-	bin/easyjson ./tests/key_marshaler_map.go
+	bin/easyjson -build_tags=use_easyjson -disable_members_unescape ./benchmark/data.go
 	bin/easyjson -disallow_unknown_fields ./tests/disallow_unknown.go
-	bin/easyjson ./tests/unknown_fields.go
+	bin/easyjson -disable_members_unescape ./tests/members_unescaped.go
 
 test: generate
 	go test \

vendor/github.com/mailru/easyjson/README.md

@@ -34,7 +34,11 @@ Usage of easyjson:
   -all
     	generate marshaler/unmarshalers for all structs in a file
   -build_tags string
-    	build tags to add to generated file
+        build tags to add to generated file
+  -gen_build_flags string
+        build flags when running the generator while bootstrapping
+  -byte
+        use simple bytes instead of Base64Bytes for slice of bytes
   -leave_temps
     	do not delete temporary files
   -no_std_marshalers
@@ -55,10 +59,20 @@ Usage of easyjson:
     	only generate stubs for marshaler/unmarshaler funcs
   -disallow_unknown_fields
         return error if some unknown field in json appeared
+  -disable_members_unescape
+        disable unescaping of \uXXXX string sequences in member names
 ```
 
 Using `-all` will generate marshalers/unmarshalers for all Go structs in the
-file. If `-all` is not provided, then only those structs whose preceding
+file excluding those structs whose preceding comment starts with `easyjson:skip`.
+For example: 
+
+```go
+//easyjson:skip
+type A struct {}
+```
+
+If `-all` is not provided, then only those structs whose preceding
 comment starts with `easyjson:json` will have marshalers/unmarshalers
 generated. For example:
 
@@ -76,10 +90,26 @@ Additional option notes:
 
 * `-build_tags` will add the specified build tags to generated Go sources.
 
+* `-gen_build_flags` will execute the easyjson bootstapping code to launch the 
+  actual generator command with provided flags. Multiple arguments should be
+  separated by space e.g. `-gen_build_flags="-mod=mod -x"`.
+
+## Structure json tag options
+
+Besides standart json tag options like 'omitempty' the following are supported:
+
+* 'nocopy' - disables allocation and copying of string values, making them
+  refer to original json buffer memory. This works great for short lived
+  objects which are not hold in memory after decoding and immediate usage.
+  Note if string requires unescaping it will be processed as normally.
+* 'intern' - string "interning" (deduplication) to save memory when the very
+  same string dictionary values are often met all over the structure.
+  See below for more details.
+
 ## Generated Marshaler/Unmarshaler Funcs
 
 For Go struct types, easyjson generates the funcs `MarshalEasyJSON` /
-`UnmarshalEasyJSON` for marshaling/unmarshaling JSON. In turn, these satisify
+`UnmarshalEasyJSON` for marshaling/unmarshaling JSON. In turn, these satisfy
 the `easyjson.Marshaler` and `easyjson.Unmarshaler` interfaces and when used in
 conjunction with `easyjson.Marshal` / `easyjson.Unmarshal` avoid unnecessary
 reflection / type assertions during marshaling/unmarshaling to/from JSON for Go
@@ -102,17 +132,17 @@ utility funcs that are available.
 ## Controlling easyjson Marshaling and Unmarshaling Behavior
 
 Go types can provide their own `MarshalEasyJSON` and `UnmarshalEasyJSON` funcs
-that satisify the `easyjson.Marshaler` / `easyjson.Unmarshaler` interfaces.
+that satisfy the `easyjson.Marshaler` / `easyjson.Unmarshaler` interfaces.
 These will be used by `easyjson.Marshal` and `easyjson.Unmarshal` when defined
 for a Go type.
 
-Go types can also satisify the `easyjson.Optional` interface, which allows the
+Go types can also satisfy the `easyjson.Optional` interface, which allows the
 type to define its own `omitempty` logic.
 
 ## Type Wrappers
 
 easyjson provides additional type wrappers defined in the `easyjson/opt`
-package. These wrap the standard Go primitives and in turn satisify the
+package. These wrap the standard Go primitives and in turn satisfy the
 easyjson interfaces.
 
 The `easyjson/opt` type wrappers are useful when needing to distinguish between
@@ -133,6 +163,27 @@ through a call to `buffer.Init()` prior to any marshaling or unmarshaling.
 Please see the [GoDoc listing](https://godoc.org/github.com/mailru/easyjson/buffer)
 for more information.
 
+## String interning
+
+During unmarshaling, `string` field values can be optionally
+[interned](https://en.wikipedia.org/wiki/String_interning) to reduce memory
+allocations and usage by deduplicating strings in memory, at the expense of slightly
+increased CPU usage.
+
+This will work effectively only for `string` fields being decoded that have frequently
+the same value (e.g. if you have a string field that can only assume a small number
+of possible values).
+
+To enable string interning, add the `intern` keyword tag to your `json` tag on `string`
+fields, e.g.:
+
+```go
+type Foo struct {
+  UUID  string `json:"uuid"`         // will not be interned during unmarshaling
+  State string `json:"state,intern"` // will be interned during unmarshaling
+}
+```
+
 ## Issues, Notes, and Limitations
 
 * easyjson is still early in its development. As such, there are likely to be
@@ -174,7 +225,7 @@ for more information.
   needs to be known prior to sending the data. Currently this is not possible
   with easyjson's architecture.
   
-* easyjson parser and codegen based on reflection, so it wont works on `package main` 
+* easyjson parser and codegen based on reflection, so it won't work on `package main` 
   files, because they cant be imported by parser.
 
 ## Benchmarks
@@ -239,7 +290,7 @@ since the memory is not freed between marshaling operations.
 ### easyjson vs 'ujson' python module
 
 [ujson](https://github.com/esnme/ultrajson) is using C code for parsing, so it
-is interesting to see how plain golang compares to that. It is imporant to note
+is interesting to see how plain golang compares to that. It is important to note
 that the resulting object for python is slower to access, since the library
 parses JSON object into dictionaries.
 

vendor/github.com/mailru/easyjson/buffer/pool.go

@@ -4,6 +4,7 @@ package buffer
 
 import (
 	"io"
+	"net"
 	"sync"
 )
 
@@ -52,14 +53,12 @@ func putBuf(buf []byte) {
 
 // getBuf gets a chunk from reuse pool or creates a new one if reuse failed.
 func getBuf(size int) []byte {
-	if size < config.PooledSize {
-		return make([]byte, 0, size)
-	}
-
-	if c := buffers[size]; c != nil {
-		v := c.Get()
-		if v != nil {
-			return v.([]byte)
+	if size >= config.PooledSize {
+		if c := buffers[size]; c != nil {
+			v := c.Get()
+			if v != nil {
+				return v.([]byte)
+			}
 		}
 	}
 	return make([]byte, 0, size)
@@ -78,9 +77,12 @@ type Buffer struct {
 // EnsureSpace makes sure that the current chunk contains at least s free bytes,
 // possibly creating a new chunk.
 func (b *Buffer) EnsureSpace(s int) {
-	if cap(b.Buf)-len(b.Buf) >= s {
-		return
+	if cap(b.Buf)-len(b.Buf) < s {
+		b.ensureSpaceSlow(s)
 	}
+}
+
+func (b *Buffer) ensureSpaceSlow(s int) {
 	l := len(b.Buf)
 	if l > 0 {
 		if cap(b.toPool) != cap(b.Buf) {
@@ -105,18 +107,22 @@ func (b *Buffer) EnsureSpace(s int) {
 
 // AppendByte appends a single byte to buffer.
 func (b *Buffer) AppendByte(data byte) {
-	if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
-		b.EnsureSpace(1)
-	}
+	b.EnsureSpace(1)
 	b.Buf = append(b.Buf, data)
 }
 
 // AppendBytes appends a byte slice to buffer.
 func (b *Buffer) AppendBytes(data []byte) {
+	if len(data) <= cap(b.Buf)-len(b.Buf) {
+		b.Buf = append(b.Buf, data...) // fast path
+	} else {
+		b.appendBytesSlow(data)
+	}
+}
+
+func (b *Buffer) appendBytesSlow(data []byte) {
 	for len(data) > 0 {
-		if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
-			b.EnsureSpace(1)
-		}
+		b.EnsureSpace(1)
 
 		sz := cap(b.Buf) - len(b.Buf)
 		if sz > len(data) {
@@ -128,12 +134,18 @@ func (b *Buffer) AppendBytes(data []byte) {
 	}
 }
 
-// AppendBytes appends a string to buffer.
+// AppendString appends a string to buffer.
 func (b *Buffer) AppendString(data string) {
+	if len(data) <= cap(b.Buf)-len(b.Buf) {
+		b.Buf = append(b.Buf, data...) // fast path
+	} else {
+		b.appendStringSlow(data)
+	}
+}
+
+func (b *Buffer) appendStringSlow(data string) {
 	for len(data) > 0 {
-		if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
-			b.EnsureSpace(1)
-		}
+		b.EnsureSpace(1)
 
 		sz := cap(b.Buf) - len(b.Buf)
 		if sz > len(data) {
@@ -156,18 +168,14 @@ func (b *Buffer) Size() int {
 
 // DumpTo outputs the contents of a buffer to a writer and resets the buffer.
 func (b *Buffer) DumpTo(w io.Writer) (written int, err error) {
-	var n int
-	for _, buf := range b.bufs {
-		if err == nil {
-			n, err = w.Write(buf)
-			written += n
-		}
-		putBuf(buf)
+	bufs := net.Buffers(b.bufs)
+	if len(b.Buf) > 0 {
+		bufs = append(bufs, b.Buf)
 	}
+	n, err := bufs.WriteTo(w)
 
-	if err == nil {
-		n, err = w.Write(b.Buf)
-		written += n
+	for _, buf := range b.bufs {
+		putBuf(buf)
 	}
 	putBuf(b.toPool)
 
@@ -175,7 +183,7 @@ func (b *Buffer) DumpTo(w io.Writer) (written int, err error) {
 	b.Buf = nil
 	b.toPool = nil
 
-	return
+	return int(n), err
 }
 
 // BuildBytes creates a single byte slice with all the contents of the buffer. Data is
@@ -192,7 +200,7 @@ func (b *Buffer) BuildBytes(reuse ...[]byte) []byte {
 	var ret []byte
 	size := b.Size()
 
-	// If we got a buffer as argument and it is big enought, reuse it.
+	// If we got a buffer as argument and it is big enough, reuse it.
 	if len(reuse) == 1 && cap(reuse[0]) >= size {
 		ret = reuse[0][:0]
 	} else {

vendor/github.com/mailru/easyjson/go.mod

@@ -1,3 +1,5 @@
 module github.com/mailru/easyjson
 
 go 1.12
+
+require github.com/josharian/intern v1.0.0

vendor/github.com/mailru/easyjson/go.sum

@@ -0,0 +1,2 @@
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=

vendor/github.com/mailru/easyjson/helpers.go

@@ -6,6 +6,7 @@ import (
 	"io/ioutil"
 	"net/http"
 	"strconv"
+	"unsafe"
 
 	"github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
@@ -21,6 +22,12 @@ type Unmarshaler interface {
 	UnmarshalEasyJSON(w *jlexer.Lexer)
 }
 
+// MarshalerUnmarshaler is an easyjson-compatible marshaler/unmarshaler interface.
+type MarshalerUnmarshaler interface {
+	Marshaler
+	Unmarshaler
+}
+
 // Optional defines an undefined-test method for a type to integrate with 'omitempty' logic.
 type Optional interface {
 	IsDefined() bool
@@ -36,9 +43,17 @@ type UnknownsMarshaler interface {
 	MarshalUnknowns(w *jwriter.Writer, first bool)
 }
 
+func isNilInterface(i interface{}) bool {
+	return (*[2]uintptr)(unsafe.Pointer(&i))[1] == 0
+}
+
 // Marshal returns data as a single byte slice. Method is suboptimal as the data is likely to be copied
 // from a chain of smaller chunks.
 func Marshal(v Marshaler) ([]byte, error) {
+	if isNilInterface(v) {
+		return nullBytes, nil
+	}
+
 	w := jwriter.Writer{}
 	v.MarshalEasyJSON(&w)
 	return w.BuildBytes()
@@ -46,6 +61,10 @@ func Marshal(v Marshaler) ([]byte, error) {
 
 // MarshalToWriter marshals the data to an io.Writer.
 func MarshalToWriter(v Marshaler, w io.Writer) (written int, err error) {
+	if isNilInterface(v) {
+		return w.Write(nullBytes)
+	}
+
 	jw := jwriter.Writer{}
 	v.MarshalEasyJSON(&jw)
 	return jw.DumpTo(w)
@@ -56,6 +75,13 @@ func MarshalToWriter(v Marshaler, w io.Writer) (written int, err error) {
 // false if an error occurred before any http.ResponseWriter methods were actually
 // invoked (in this case a 500 reply is possible).
 func MarshalToHTTPResponseWriter(v Marshaler, w http.ResponseWriter) (started bool, written int, err error) {
+	if isNilInterface(v) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Content-Length", strconv.Itoa(len(nullBytes)))
+		written, err = w.Write(nullBytes)
+		return true, written, err
+	}
+
 	jw := jwriter.Writer{}
 	v.MarshalEasyJSON(&jw)
 	if jw.Error != nil {

vendor/github.com/mailru/easyjson/jlexer/lexer.go

@@ -5,6 +5,7 @@
 package jlexer
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
@@ -14,6 +15,8 @@ import (
 	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
+
+	"github.com/josharian/intern"
 )
 
 // tokenKind determines type of a token.
@@ -32,9 +35,10 @@ const (
 type token struct {
 	kind tokenKind // Type of a token.
 
-	boolValue  bool   // Value if a boolean literal token.
-	byteValue  []byte // Raw value of a token.
-	delimValue byte
+	boolValue       bool   // Value if a boolean literal token.
+	byteValueCloned bool   // true if byteValue was allocated and does not refer to original json body
+	byteValue       []byte // Raw value of a token.
+	delimValue      byte
 }
 
 // Lexer is a JSON lexer: it iterates over JSON tokens in a byte slice.
@@ -240,23 +244,65 @@ func (r *Lexer) fetchNumber() {
 
 // findStringLen tries to scan into the string literal for ending quote char to determine required size.
 // The size will be exact if no escapes are present and may be inexact if there are escaped chars.
-func findStringLen(data []byte) (isValid, hasEscapes bool, length int) {
-	delta := 0
-
-	for i := 0; i < len(data); i++ {
-		switch data[i] {
-		case '\\':
-			i++
-			delta++
-			if i < len(data) && data[i] == 'u' {
-				delta++
-			}
-		case '"':
-			return true, (delta > 0), (i - delta)
+func findStringLen(data []byte) (isValid bool, length int) {
+	for {
+		idx := bytes.IndexByte(data, '"')
+		if idx == -1 {
+			return false, len(data)
 		}
+		if idx == 0 || (idx > 0 && data[idx-1] != '\\') {
+			return true, length + idx
+		}
+
+		// count \\\\\\\ sequences. even number of slashes means quote is not really escaped
+		cnt := 1
+		for idx-cnt-1 >= 0 && data[idx-cnt-1] == '\\' {
+			cnt++
+		}
+		if cnt%2 == 0 {
+			return true, length + idx
+		}
+
+		length += idx + 1
+		data = data[idx+1:]
+	}
+}
+
+// unescapeStringToken performs unescaping of string token.
+// if no escaping is needed, original string is returned, otherwise - a new one allocated
+func (r *Lexer) unescapeStringToken() (err error) {
+	data := r.token.byteValue
+	var unescapedData []byte
+
+	for {
+		i := bytes.IndexByte(data, '\\')
+		if i == -1 {
+			break
+		}
+
+		escapedRune, escapedBytes, err := decodeEscape(data[i:])
+		if err != nil {
+			r.errParse(err.Error())
+			return err
+		}
+
+		if unescapedData == nil {
+			unescapedData = make([]byte, 0, len(r.token.byteValue))
+		}
+
+		var d [4]byte
+		s := utf8.EncodeRune(d[:], escapedRune)
+		unescapedData = append(unescapedData, data[:i]...)
+		unescapedData = append(unescapedData, d[:s]...)
+
+		data = data[i+escapedBytes:]
 	}
 
-	return false, false, len(data)
+	if unescapedData != nil {
+		r.token.byteValue = append(unescapedData, data...)
+		r.token.byteValueCloned = true
+	}
+	return
 }
 
 // getu4 decodes \uXXXX from the beginning of s, returning the hex value,
@@ -286,36 +332,30 @@ func getu4(s []byte) rune {
 	return val
 }
 
-// processEscape processes a single escape sequence and returns number of bytes processed.
-func (r *Lexer) processEscape(data []byte) (int, error) {
+// decodeEscape processes a single escape sequence and returns number of bytes processed.
+func decodeEscape(data []byte) (decoded rune, bytesProcessed int, err error) {
 	if len(data) < 2 {
-		return 0, fmt.Errorf("syntax error at %v", string(data))
+		return 0, 0, errors.New("incorrect escape symbol \\ at the end of token")
 	}
 
 	c := data[1]
 	switch c {
 	case '"', '/', '\\':
-		r.token.byteValue = append(r.token.byteValue, c)
-		return 2, nil
+		return rune(c), 2, nil
 	case 'b':
-		r.token.byteValue = append(r.token.byteValue, '\b')
-		return 2, nil
+		return '\b', 2, nil
 	case 'f':
-		r.token.byteValue = append(r.token.byteValue, '\f')
-		return 2, nil
+		return '\f', 2, nil
 	case 'n':
-		r.token.byteValue = append(r.token.byteValue, '\n')
-		return 2, nil
+		return '\n', 2, nil
 	case 'r':
-		r.token.byteValue = append(r.token.byteValue, '\r')
-		return 2, nil
+		return '\r', 2, nil
 	case 't':
-		r.token.byteValue = append(r.token.byteValue, '\t')
-		return 2, nil
+		return '\t', 2, nil
 	case 'u':
 		rr := getu4(data)
 		if rr < 0 {
-			return 0, errors.New("syntax error")
+			return 0, 0, errors.New("incorrectly escaped \\uXXXX sequence")
 		}
 
 		read := 6
@@ -328,13 +368,10 @@ func (r *Lexer) processEscape(data []byte) (int, error) {
 				rr = unicode.ReplacementChar
 			}
 		}
-		var d [4]byte
-		s := utf8.EncodeRune(d[:], rr)
-		r.token.byteValue = append(r.token.byteValue, d[:s]...)
-		return read, nil
+		return rr, read, nil
 	}
 
-	return 0, errors.New("syntax error")
+	return 0, 0, errors.New("incorrectly escaped bytes")
 }
 
 // fetchString scans a string literal token.
@@ -342,43 +379,14 @@ func (r *Lexer) fetchString() {
 	r.pos++
 	data := r.Data[r.pos:]
 
-	isValid, hasEscapes, length := findStringLen(data)
+	isValid, length := findStringLen(data)
 	if !isValid {
 		r.pos += length
 		r.errParse("unterminated string literal")
 		return
 	}
-	if !hasEscapes {
-		r.token.byteValue = data[:length]
-		r.pos += length + 1
-		return
-	}
-
-	r.token.byteValue = make([]byte, 0, length)
-	p := 0
-	for i := 0; i < len(data); {
-		switch data[i] {
-		case '"':
-			r.pos += i + 1
-			r.token.byteValue = append(r.token.byteValue, data[p:i]...)
-			i++
-			return
-
-		case '\\':
-			r.token.byteValue = append(r.token.byteValue, data[p:i]...)
-			off, err := r.processEscape(data[i:])
-			if err != nil {
-				r.errParse(err.Error())
-				return
-			}
-			i += off
-			p = i
-
-		default:
-			i++
-		}
-	}
-	r.errParse("unterminated string literal")
+	r.token.byteValue = data[:length]
+	r.pos += length + 1 // skip closing '"' as well
 }
 
 // scanToken scans the next token if no token is currently available in the lexer.
@@ -602,7 +610,7 @@ func (r *Lexer) Consumed() {
 	}
 }
 
-func (r *Lexer) unsafeString() (string, []byte) {
+func (r *Lexer) unsafeString(skipUnescape bool) (string, []byte) {
 	if r.token.kind == tokenUndef && r.Ok() {
 		r.FetchToken()
 	}
@@ -610,6 +618,13 @@ func (r *Lexer) unsafeString() (string, []byte) {
 		r.errInvalidToken("string")
 		return "", nil
 	}
+	if !skipUnescape {
+		if err := r.unescapeStringToken(); err != nil {
+			r.errInvalidToken("string")
+			return "", nil
+		}
+	}
+
 	bytes := r.token.byteValue
 	ret := bytesToStr(r.token.byteValue)
 	r.consume()
@@ -621,13 +636,19 @@ func (r *Lexer) unsafeString() (string, []byte) {
 // Warning: returned string may point to the input buffer, so the string should not outlive
 // the input buffer. Intended pattern of usage is as an argument to a switch statement.
 func (r *Lexer) UnsafeString() string {
-	ret, _ := r.unsafeString()
+	ret, _ := r.unsafeString(false)
 	return ret
 }
 
 // UnsafeBytes returns the byte slice if the token is a string literal.
 func (r *Lexer) UnsafeBytes() []byte {
-	_, ret := r.unsafeString()
+	_, ret := r.unsafeString(false)
+	return ret
+}
+
+// UnsafeFieldName returns current member name string token
+func (r *Lexer) UnsafeFieldName(skipUnescape bool) string {
+	ret, _ := r.unsafeString(skipUnescape)
 	return ret
 }
 
@@ -640,7 +661,34 @@ func (r *Lexer) String() string {
 		r.errInvalidToken("string")
 		return ""
 	}
-	ret := string(r.token.byteValue)
+	if err := r.unescapeStringToken(); err != nil {
+		r.errInvalidToken("string")
+		return ""
+	}
+	var ret string
+	if r.token.byteValueCloned {
+		ret = bytesToStr(r.token.byteValue)
+	} else {
+		ret = string(r.token.byteValue)
+	}
+	r.consume()
+	return ret
+}
+
+// StringIntern reads a string literal, and performs string interning on it.
+func (r *Lexer) StringIntern() string {
+	if r.token.kind == tokenUndef && r.Ok() {
+		r.FetchToken()
+	}
+	if !r.Ok() || r.token.kind != tokenString {
+		r.errInvalidToken("string")
+		return ""
+	}
+	if err := r.unescapeStringToken(); err != nil {
+		r.errInvalidToken("string")
+		return ""
+	}
+	ret := intern.Bytes(r.token.byteValue)
 	r.consume()
 	return ret
 }
@@ -839,7 +887,7 @@ func (r *Lexer) Int() int {
 }
 
 func (r *Lexer) Uint8Str() uint8 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -856,7 +904,7 @@ func (r *Lexer) Uint8Str() uint8 {
 }
 
 func (r *Lexer) Uint16Str() uint16 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -873,7 +921,7 @@ func (r *Lexer) Uint16Str() uint16 {
 }
 
 func (r *Lexer) Uint32Str() uint32 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -890,7 +938,7 @@ func (r *Lexer) Uint32Str() uint32 {
 }
 
 func (r *Lexer) Uint64Str() uint64 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -915,7 +963,7 @@ func (r *Lexer) UintptrStr() uintptr {
 }
 
 func (r *Lexer) Int8Str() int8 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -932,7 +980,7 @@ func (r *Lexer) Int8Str() int8 {
 }
 
 func (r *Lexer) Int16Str() int16 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -949,7 +997,7 @@ func (r *Lexer) Int16Str() int16 {
 }
 
 func (r *Lexer) Int32Str() int32 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -966,7 +1014,7 @@ func (r *Lexer) Int32Str() int32 {
 }
 
 func (r *Lexer) Int64Str() int64 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -1004,7 +1052,7 @@ func (r *Lexer) Float32() float32 {
 }
 
 func (r *Lexer) Float32Str() float32 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}
@@ -1037,7 +1085,7 @@ func (r *Lexer) Float64() float64 {
 }
 
 func (r *Lexer) Float64Str() float64 {
-	s, b := r.unsafeString()
+	s, b := r.unsafeString(false)
 	if !r.Ok() {
 		return 0
 	}

vendor/github.com/mailru/easyjson/jwriter/writer.go

@@ -297,11 +297,9 @@ func (w *Writer) String(s string) {
 
 	p := 0 // last non-escape symbol
 
-	var escapeTable [128]bool
+	escapeTable := &htmlEscapeTable
 	if w.NoEscapeHTML {
-		escapeTable = htmlNoEscapeTable
-	} else {
-		escapeTable = htmlEscapeTable
+		escapeTable = &htmlNoEscapeTable
 	}
 
 	for i := 0; i < len(s); {

vendor/github.com/mailru/easyjson/unknown_fields.go

@@ -1,8 +1,6 @@
 package easyjson
 
 import (
-	json "encoding/json"
-
 	jlexer "github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
 )
@@ -10,14 +8,14 @@ import (
 // UnknownFieldsProxy implemets UnknownsUnmarshaler and UnknownsMarshaler
 // use it as embedded field in your structure to parse and then serialize unknown struct fields
 type UnknownFieldsProxy struct {
-	unknownFields map[string]interface{}
+	unknownFields map[string][]byte
 }
 
 func (s *UnknownFieldsProxy) UnmarshalUnknown(in *jlexer.Lexer, key string) {
 	if s.unknownFields == nil {
-		s.unknownFields = make(map[string]interface{}, 1)
+		s.unknownFields = make(map[string][]byte, 1)
 	}
-	s.unknownFields[key] = in.Interface()
+	s.unknownFields[key] = in.Raw()
 }
 
 func (s UnknownFieldsProxy) MarshalUnknowns(out *jwriter.Writer, first bool) {
@@ -29,6 +27,6 @@ func (s UnknownFieldsProxy) MarshalUnknowns(out *jwriter.Writer, first bool) {
 		}
 		out.String(string(key))
 		out.RawByte(':')
-		out.Raw(json.Marshal(val))
+		out.Raw(val, nil)
 	}
 }

vendor/github.com/miekg/dns/README.md

@@ -28,6 +28,7 @@ A not-so-up-to-date-list-that-may-be-actually-current:
 * https://github.com/coredns/coredns
 * https://cloudflare.com
 * https://github.com/abh/geodns
+* https://github.com/baidu/bfe
 * http://www.statdns.com/
 * http://www.dnsinspect.com/
 * https://github.com/chuangbo/jianbing-dictionary-dns
@@ -70,6 +71,8 @@ A not-so-up-to-date-list-that-may-be-actually-current:
 * https://render.com
 * https://github.com/peterzen/goresolver
 * https://github.com/folbricht/routedns
+* https://domainr.com/
+* https://zonedb.org/
 
 Send pull request if you want to be listed here.
 

vendor/github.com/miekg/dns/client.go

@@ -124,15 +124,38 @@ func (c *Client) Dial(address string) (conn *Conn, err error) {
 // of 512 bytes
 // To specify a local address or a timeout, the caller has to set the `Client.Dialer`
 // attribute appropriately
+
 func (c *Client) Exchange(m *Msg, address string) (r *Msg, rtt time.Duration, err error) {
+	co, err := c.Dial(address)
+
+	if err != nil {
+		return nil, 0, err
+	}
+	defer co.Close()
+	return c.ExchangeWithConn(m, co)
+}
+
+// ExchangeWithConn has the same behavior as Exchange, just with a predetermined connection
+// that will be used instead of creating a new one.
+// Usage pattern with a *dns.Client:
+//	c := new(dns.Client)
+//	// connection management logic goes here
+//
+//	conn := c.Dial(address)
+//	in, rtt, err := c.ExchangeWithConn(message, conn)
+//
+//  This allows users of the library to implement their own connection management,
+//  as opposed to Exchange, which will always use new connections and incur the added overhead
+//  that entails when using "tcp" and especially "tcp-tls" clients.
+func (c *Client) ExchangeWithConn(m *Msg, conn *Conn) (r *Msg, rtt time.Duration, err error) {
 	if !c.SingleInflight {
-		return c.exchange(m, address)
+		return c.exchange(m, conn)
 	}
 
 	q := m.Question[0]
 	key := fmt.Sprintf("%s:%d:%d", q.Name, q.Qtype, q.Qclass)
 	r, rtt, err, shared := c.group.Do(key, func() (*Msg, time.Duration, error) {
-		return c.exchange(m, address)
+		return c.exchange(m, conn)
 	})
 	if r != nil && shared {
 		r = r.Copy()
@@ -141,15 +164,7 @@ func (c *Client) Exchange(m *Msg, address string) (r *Msg, rtt time.Duration, er
 	return r, rtt, err
 }
 
-func (c *Client) exchange(m *Msg, a string) (r *Msg, rtt time.Duration, err error) {
-	var co *Conn
-
-	co, err = c.Dial(a)
-
-	if err != nil {
-		return nil, 0, err
-	}
-	defer co.Close()
+func (c *Client) exchange(m *Msg, co *Conn) (r *Msg, rtt time.Duration, err error) {
 
 	opt := m.IsEdns0()
 	// If EDNS0 is used use that for size.

vendor/github.com/miekg/dns/generate.go

@@ -20,13 +20,13 @@ import (
 // of $ after that are interpreted.
 func (zp *ZoneParser) generate(l lex) (RR, bool) {
 	token := l.token
-	step := 1
+	step := int64(1)
 	if i := strings.IndexByte(token, '/'); i >= 0 {
 		if i+1 == len(token) {
 			return zp.setParseError("bad step in $GENERATE range", l)
 		}
 
-		s, err := strconv.Atoi(token[i+1:])
+		s, err := strconv.ParseInt(token[i+1:], 10, 64)
 		if err != nil || s <= 0 {
 			return zp.setParseError("bad step in $GENERATE range", l)
 		}
@@ -40,12 +40,12 @@ func (zp *ZoneParser) generate(l lex) (RR, bool) {
 		return zp.setParseError("bad start-stop in $GENERATE range", l)
 	}
 
-	start, err := strconv.Atoi(sx[0])
+	start, err := strconv.ParseInt(sx[0], 10, 64)
 	if err != nil {
 		return zp.setParseError("bad start in $GENERATE range", l)
 	}
 
-	end, err := strconv.Atoi(sx[1])
+	end, err := strconv.ParseInt(sx[1], 10, 64)
 	if err != nil {
 		return zp.setParseError("bad stop in $GENERATE range", l)
 	}
@@ -75,10 +75,10 @@ func (zp *ZoneParser) generate(l lex) (RR, bool) {
 	r := &generateReader{
 		s: s,
 
-		cur:   start,
-		start: start,
-		end:   end,
-		step:  step,
+		cur:   int(start),
+		start: int(start),
+		end:   int(end),
+		step:  int(step),
 
 		file: zp.file,
 		lex:  &l,
@@ -188,7 +188,7 @@ func (r *generateReader) ReadByte() (byte, error) {
 			if errMsg != "" {
 				return 0, r.parseError(errMsg, si+3+sep)
 			}
-			if r.start+offset < 0 || r.end+offset > 1<<31-1 {
+			if r.start+offset < 0 || int64(r.end) + int64(offset) > 1<<31-1 {
 				return 0, r.parseError("bad offset in $GENERATE", si+3+sep)
 			}
 
@@ -229,19 +229,19 @@ func modToPrintf(s string) (string, int, string) {
 		return "", 0, "bad base in $GENERATE"
 	}
 
-	offset, err := strconv.Atoi(offStr)
+	offset, err := strconv.ParseInt(offStr, 10, 64)
 	if err != nil {
 		return "", 0, "bad offset in $GENERATE"
 	}
 
-	width, err := strconv.Atoi(widthStr)
+	width, err := strconv.ParseInt(widthStr, 10, 64)
 	if err != nil || width < 0 || width > 255 {
 		return "", 0, "bad width in $GENERATE"
 	}
 
 	if width == 0 {
-		return "%" + base, offset, ""
+		return "%" + base, int(offset), ""
 	}
 
-	return "%0" + widthStr + base, offset, ""
+	return "%0" + widthStr + base, int(offset), ""
 }

vendor/github.com/miekg/dns/msg.go

@@ -398,17 +398,12 @@ Loop:
 				return "", lenmsg, ErrLongDomain
 			}
 			for _, b := range msg[off : off+c] {
-				switch b {
-				case '.', '(', ')', ';', ' ', '@':
-					fallthrough
-				case '"', '\\':
+				if isDomainNameLabelSpecial(b) {
 					s = append(s, '\\', b)
-				default:
-					if b < ' ' || b > '~' { // unprintable, use \DDD
-						s = append(s, escapeByte(b)...)
-					} else {
-						s = append(s, b)
-					}
+				} else if b < ' ' || b > '~' {
+					s = append(s, escapeByte(b)...)
+				} else {
+					s = append(s, b)
 				}
 			}
 			s = append(s, '.')

vendor/github.com/miekg/dns/msg_helpers.go

@@ -423,86 +423,12 @@ Option:
 	if off+int(optlen) > len(msg) {
 		return nil, len(msg), &Error{err: "overflow unpacking opt"}
 	}
-	switch code {
-	case EDNS0NSID:
-		e := new(EDNS0_NSID)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0SUBNET:
-		e := new(EDNS0_SUBNET)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0COOKIE:
-		e := new(EDNS0_COOKIE)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0EXPIRE:
-		e := new(EDNS0_EXPIRE)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0UL:
-		e := new(EDNS0_UL)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0LLQ:
-		e := new(EDNS0_LLQ)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0DAU:
-		e := new(EDNS0_DAU)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0DHU:
-		e := new(EDNS0_DHU)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0N3U:
-		e := new(EDNS0_N3U)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	case EDNS0PADDING:
-		e := new(EDNS0_PADDING)
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
-	default:
-		e := new(EDNS0_LOCAL)
-		e.Code = code
-		if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, e)
-		off += int(optlen)
+	e := makeDataOpt(code)
+	if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
+		return nil, len(msg), err
 	}
+	edns = append(edns, e)
+	off += int(optlen)
 
 	if off < len(msg) {
 		goto Option
@@ -511,6 +437,35 @@ Option:
 	return edns, off, nil
 }
 
+func makeDataOpt(code uint16) EDNS0 {
+	switch code {
+	case EDNS0NSID:
+		return new(EDNS0_NSID)
+	case EDNS0SUBNET:
+		return new(EDNS0_SUBNET)
+	case EDNS0COOKIE:
+		return new(EDNS0_COOKIE)
+	case EDNS0EXPIRE:
+		return new(EDNS0_EXPIRE)
+	case EDNS0UL:
+		return new(EDNS0_UL)
+	case EDNS0LLQ:
+		return new(EDNS0_LLQ)
+	case EDNS0DAU:
+		return new(EDNS0_DAU)
+	case EDNS0DHU:
+		return new(EDNS0_DHU)
+	case EDNS0N3U:
+		return new(EDNS0_N3U)
+	case EDNS0PADDING:
+		return new(EDNS0_PADDING)
+	default:
+		e := new(EDNS0_LOCAL)
+		e.Code = code
+		return e
+	}
+}
+
 func packDataOpt(options []EDNS0, msg []byte, off int) (int, error) {
 	for _, el := range options {
 		b, err := el.pack()
@@ -521,9 +476,7 @@ func packDataOpt(options []EDNS0, msg []byte, off int) (int, error) {
 		binary.BigEndian.PutUint16(msg[off+2:], uint16(len(b))) // Length
 		off += 4
 		if off+len(b) > len(msg) {
-			copy(msg[off:], b)
-			off = len(msg)
-			continue
+			return len(msg), &Error{err: "overflow packing opt"}
 		}
 		// Actual data
 		copy(msg[off:off+len(b)], b)
@@ -783,28 +736,31 @@ func unpackDataAplPrefix(msg []byte, off int) (APLPrefix, int, error) {
 	if int(prefix) > 8*len(ip) {
 		return APLPrefix{}, len(msg), &Error{err: "APL prefix too long"}
 	}
-
 	afdlen := int(nlen & 0x7f)
-	if (int(prefix)+7)/8 != afdlen {
-		return APLPrefix{}, len(msg), &Error{err: "invalid APL address length"}
+	if afdlen > len(ip) {
+		return APLPrefix{}, len(msg), &Error{err: "APL length too long"}
 	}
 	if off+afdlen > len(msg) {
 		return APLPrefix{}, len(msg), &Error{err: "overflow unpacking APL address"}
 	}
 	off += copy(ip, msg[off:off+afdlen])
-	if prefix%8 > 0 {
+	if afdlen > 0 {
 		last := ip[afdlen-1]
-		zero := uint8(0xff) >> (prefix % 8)
-		if last&zero > 0 {
+		if last == 0 {
 			return APLPrefix{}, len(msg), &Error{err: "extra APL address bits"}
 		}
 	}
+	ipnet := net.IPNet{
+		IP:   ip,
+		Mask: net.CIDRMask(int(prefix), 8*len(ip)),
+	}
+	network := ipnet.IP.Mask(ipnet.Mask)
+	if !network.Equal(ipnet.IP) {
+		return APLPrefix{}, len(msg), &Error{err: "invalid APL address length"}
+	}
 
 	return APLPrefix{
 		Negation: (nlen & 0x80) != 0,
-		Network: net.IPNet{
-			IP:   ip,
-			Mask: net.CIDRMask(int(prefix), 8*len(ip)),
-		},
+		Network:  ipnet,
 	}, off, nil
 }

vendor/github.com/miekg/dns/scan.go

@@ -87,16 +87,6 @@ type lex struct {
 	column int    // column in the file
 }
 
-// Token holds the token that are returned when a zone file is parsed.
-type Token struct {
-	// The scanned resource record when error is not nil.
-	RR
-	// When an error occurred, this has the error specifics.
-	Error *ParseError
-	// A potential comment positioned after the RR and on the same line.
-	Comment string
-}
-
 // ttlState describes the state necessary to fill in an omitted RR TTL
 type ttlState struct {
 	ttl           uint32 // ttl is the current default TTL
@@ -130,70 +120,6 @@ func ReadRR(r io.Reader, file string) (RR, error) {
 	return rr, zp.Err()
 }
 
-// ParseZone reads a RFC 1035 style zonefile from r. It returns
-// Tokens on the returned channel, each consisting of either a
-// parsed RR and optional comment or a nil RR and an error. The
-// channel is closed by ParseZone when the end of r is reached.
-//
-// The string file is used in error reporting and to resolve relative
-// $INCLUDE directives. The string origin is used as the initial
-// origin, as if the file would start with an $ORIGIN directive.
-//
-// The directives $INCLUDE, $ORIGIN, $TTL and $GENERATE are all
-// supported. Note that $GENERATE's range support up to a maximum of
-// of 65535 steps.
-//
-// Basic usage pattern when reading from a string (z) containing the
-// zone data:
-//
-//	for x := range dns.ParseZone(strings.NewReader(z), "", "") {
-//		if x.Error != nil {
-//                  // log.Println(x.Error)
-//              } else {
-//                  // Do something with x.RR
-//              }
-//	}
-//
-// Comments specified after an RR (and on the same line!) are
-// returned too:
-//
-//	foo. IN A 10.0.0.1 ; this is a comment
-//
-// The text "; this is comment" is returned in Token.Comment.
-// Comments inside the RR are returned concatenated along with the
-// RR. Comments on a line by themselves are discarded.
-//
-// To prevent memory leaks it is important to always fully drain the
-// returned channel. If an error occurs, it will always be the last
-// Token sent on the channel.
-//
-// Deprecated: New users should prefer the ZoneParser API.
-func ParseZone(r io.Reader, origin, file string) chan *Token {
-	t := make(chan *Token, 10000)
-	go parseZone(r, origin, file, t)
-	return t
-}
-
-func parseZone(r io.Reader, origin, file string, t chan *Token) {
-	defer close(t)
-
-	zp := NewZoneParser(r, origin, file)
-	zp.SetIncludeAllowed(true)
-
-	for rr, ok := zp.Next(); ok; rr, ok = zp.Next() {
-		t <- &Token{RR: rr, Comment: zp.Comment()}
-	}
-
-	if err := zp.Err(); err != nil {
-		pe, ok := err.(*ParseError)
-		if !ok {
-			pe = &ParseError{file: file, err: err.Error()}
-		}
-
-		t <- &Token{Error: pe}
-	}
-}
-
 // ZoneParser is a parser for an RFC 1035 style zonefile.
 //
 // Each parsed RR in the zone is returned sequentially from Next. An

vendor/github.com/miekg/dns/scan_rr.go

@@ -1,6 +1,7 @@
 package dns
 
 import (
+	"bytes"
 	"encoding/base64"
 	"net"
 	"strconv"
@@ -10,15 +11,15 @@ import (
 // A remainder of the rdata with embedded spaces, return the parsed string (sans the spaces)
 // or an error
 func endingToString(c *zlexer, errstr string) (string, *ParseError) {
-	var s string
+	var buffer bytes.Buffer
 	l, _ := c.Next() // zString
 	for l.value != zNewline && l.value != zEOF {
 		if l.err {
-			return s, &ParseError{"", errstr, l}
+			return buffer.String(), &ParseError{"", errstr, l}
 		}
 		switch l.value {
 		case zString:
-			s += l.token
+			buffer.WriteString(l.token)
 		case zBlank: // Ok
 		default:
 			return "", &ParseError{"", errstr, l}
@@ -26,7 +27,7 @@ func endingToString(c *zlexer, errstr string) (string, *ParseError) {
 		l, _ = c.Next()
 	}
 
-	return s, nil
+	return buffer.String(), nil
 }
 
 // A remainder of the rdata with embedded spaces, split on unquoted whitespace

vendor/github.com/miekg/dns/tsig.go

@@ -18,7 +18,9 @@ import (
 const (
 	HmacMD5    = "hmac-md5.sig-alg.reg.int."
 	HmacSHA1   = "hmac-sha1."
+	HmacSHA224 = "hmac-sha224."
 	HmacSHA256 = "hmac-sha256."
+	HmacSHA384 = "hmac-sha384."
 	HmacSHA512 = "hmac-sha512."
 )
 
@@ -111,7 +113,10 @@ func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) ([]byte, s
 	if err != nil {
 		return nil, "", err
 	}
-	buf := tsigBuffer(mbuf, rr, requestMAC, timersOnly)
+	buf, err := tsigBuffer(mbuf, rr, requestMAC, timersOnly)
+	if err != nil {
+		return nil, "", err
+	}
 
 	t := new(TSIG)
 	var h hash.Hash
@@ -120,23 +125,23 @@ func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) ([]byte, s
 		h = hmac.New(md5.New, rawsecret)
 	case HmacSHA1:
 		h = hmac.New(sha1.New, rawsecret)
+	case HmacSHA224:
+		h = hmac.New(sha256.New224, rawsecret)
 	case HmacSHA256:
 		h = hmac.New(sha256.New, rawsecret)
+	case HmacSHA384:
+		h = hmac.New(sha512.New384, rawsecret)
 	case HmacSHA512:
 		h = hmac.New(sha512.New, rawsecret)
 	default:
 		return nil, "", ErrKeyAlg
 	}
 	h.Write(buf)
+	// Copy all TSIG fields except MAC and its size, which are filled using the computed digest.
+	*t = *rr
 	t.MAC = hex.EncodeToString(h.Sum(nil))
 	t.MACSize = uint16(len(t.MAC) / 2) // Size is half!
 
-	t.Hdr = RR_Header{Name: rr.Hdr.Name, Rrtype: TypeTSIG, Class: ClassANY, Ttl: 0}
-	t.Fudge = rr.Fudge
-	t.TimeSigned = rr.TimeSigned
-	t.Algorithm = rr.Algorithm
-	t.OrigId = m.Id
-
 	tbuf := make([]byte, Len(t))
 	off, err := PackRR(t, tbuf, 0, nil, false)
 	if err != nil {
@@ -153,6 +158,11 @@ func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) ([]byte, s
 // If the signature does not validate err contains the
 // error, otherwise it is nil.
 func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
+	return tsigVerify(msg, secret, requestMAC, timersOnly, uint64(time.Now().Unix()))
+}
+
+// actual implementation of TsigVerify, taking the current time ('now') as a parameter for the convenience of tests.
+func tsigVerify(msg []byte, secret, requestMAC string, timersOnly bool, now uint64) error {
 	rawsecret, err := fromBase64([]byte(secret))
 	if err != nil {
 		return err
@@ -168,17 +178,9 @@ func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
 		return err
 	}
 
-	buf := tsigBuffer(stripped, tsig, requestMAC, timersOnly)
-
-	// Fudge factor works both ways. A message can arrive before it was signed because
-	// of clock skew.
-	now := uint64(time.Now().Unix())
-	ti := now - tsig.TimeSigned
-	if now < tsig.TimeSigned {
-		ti = tsig.TimeSigned - now
-	}
-	if uint64(tsig.Fudge) < ti {
-		return ErrTime
+	buf, err := tsigBuffer(stripped, tsig, requestMAC, timersOnly)
+	if err != nil {
+		return err
 	}
 
 	var h hash.Hash
@@ -187,8 +189,12 @@ func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
 		h = hmac.New(md5.New, rawsecret)
 	case HmacSHA1:
 		h = hmac.New(sha1.New, rawsecret)
+	case HmacSHA224:
+		h = hmac.New(sha256.New224, rawsecret)
 	case HmacSHA256:
 		h = hmac.New(sha256.New, rawsecret)
+	case HmacSHA384:
+		h = hmac.New(sha512.New384, rawsecret)
 	case HmacSHA512:
 		h = hmac.New(sha512.New, rawsecret)
 	default:
@@ -198,11 +204,24 @@ func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
 	if !hmac.Equal(h.Sum(nil), msgMAC) {
 		return ErrSig
 	}
+
+	// Fudge factor works both ways. A message can arrive before it was signed because
+	// of clock skew.
+	// We check this after verifying the signature, following draft-ietf-dnsop-rfc2845bis
+	// instead of RFC2845, in order to prevent a security vulnerability as reported in CVE-2017-3142/3143.
+	ti := now - tsig.TimeSigned
+	if now < tsig.TimeSigned {
+		ti = tsig.TimeSigned - now
+	}
+	if uint64(tsig.Fudge) < ti {
+		return ErrTime
+	}
+
 	return nil
 }
 
 // Create a wiredata buffer for the MAC calculation.
-func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []byte {
+func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) ([]byte, error) {
 	var buf []byte
 	if rr.TimeSigned == 0 {
 		rr.TimeSigned = uint64(time.Now().Unix())
@@ -219,7 +238,10 @@ func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []b
 		m.MACSize = uint16(len(requestMAC) / 2)
 		m.MAC = requestMAC
 		buf = make([]byte, len(requestMAC)) // long enough
-		n, _ := packMacWire(m, buf)
+		n, err := packMacWire(m, buf)
+		if err != nil {
+			return nil, err
+		}
 		buf = buf[:n]
 	}
 
@@ -228,7 +250,10 @@ func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []b
 		tsig := new(timerWireFmt)
 		tsig.TimeSigned = rr.TimeSigned
 		tsig.Fudge = rr.Fudge
-		n, _ := packTimerWire(tsig, tsigvar)
+		n, err := packTimerWire(tsig, tsigvar)
+		if err != nil {
+			return nil, err
+		}
 		tsigvar = tsigvar[:n]
 	} else {
 		tsig := new(tsigWireFmt)
@@ -241,7 +266,10 @@ func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []b
 		tsig.Error = rr.Error
 		tsig.OtherLen = rr.OtherLen
 		tsig.OtherData = rr.OtherData
-		n, _ := packTsigWire(tsig, tsigvar)
+		n, err := packTsigWire(tsig, tsigvar)
+		if err != nil {
+			return nil, err
+		}
 		tsigvar = tsigvar[:n]
 	}
 
@@ -251,7 +279,7 @@ func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []b
 	} else {
 		buf = append(msgbuf, tsigvar...)
 	}
-	return buf
+	return buf, nil
 }
 
 // Strip the TSIG from the raw message.

vendor/github.com/miekg/dns/types.go

@@ -209,8 +209,11 @@ var CertTypeToString = map[uint16]string{
 
 //go:generate go run types_generate.go
 
-// Question holds a DNS question. There can be multiple questions in the
-// question section of a message. Usually there is just one.
+// Question holds a DNS question. Usually there is just one. While the
+// original DNS RFCs allow multiple questions in the question section of a
+// message, in practice it never works. Because most DNS servers see multiple
+// questions as an error, it is recommended to only have one question per
+// message.
 type Question struct {
 	Name   string `dns:"cdomain-name"` // "cdomain-name" specifies encoding (and may be compressed)
 	Qtype  uint16
@@ -442,45 +445,38 @@ func sprintName(s string) string {
 	var dst strings.Builder
 
 	for i := 0; i < len(s); {
-		if i+1 < len(s) && s[i] == '\\' && s[i+1] == '.' {
+		if s[i] == '.' {
 			if dst.Len() != 0 {
-				dst.WriteString(s[i : i+2])
+				dst.WriteByte('.')
 			}
-			i += 2
+			i++
 			continue
 		}
 
 		b, n := nextByte(s, i)
 		if n == 0 {
-			i++
-			continue
-		}
-		if b == '.' {
-			if dst.Len() != 0 {
-				dst.WriteByte('.')
+			// Drop "dangling" incomplete escapes.
+			if dst.Len() == 0 {
+				return s[:i]
 			}
-			i += n
-			continue
+			break
 		}
-		switch b {
-		case ' ', '\'', '@', ';', '(', ')', '"', '\\': // additional chars to escape
+		if isDomainNameLabelSpecial(b) {
 			if dst.Len() == 0 {
 				dst.Grow(len(s) * 2)
 				dst.WriteString(s[:i])
 			}
 			dst.WriteByte('\\')
 			dst.WriteByte(b)
-		default:
-			if ' ' <= b && b <= '~' {
-				if dst.Len() != 0 {
-					dst.WriteByte(b)
-				}
-			} else {
-				if dst.Len() == 0 {
-					dst.Grow(len(s) * 2)
-					dst.WriteString(s[:i])
-				}
-				dst.WriteString(escapeByte(b))
+		} else if b < ' ' || b > '~' { // unprintable, use \DDD
+			if dst.Len() == 0 {
+				dst.Grow(len(s) * 2)
+				dst.WriteString(s[:i])
+			}
+			dst.WriteString(escapeByte(b))
+		} else {
+			if dst.Len() != 0 {
+				dst.WriteByte(b)
 			}
 		}
 		i += n
@@ -503,15 +499,10 @@ func sprintTxtOctet(s string) string {
 		}
 
 		b, n := nextByte(s, i)
-		switch {
-		case n == 0:
+		if n == 0 {
 			i++ // dangling back slash
-		case b == '.':
-			dst.WriteByte('.')
-		case b < ' ' || b > '~':
-			dst.WriteString(escapeByte(b))
-		default:
-			dst.WriteByte(b)
+		} else {
+			writeTXTStringByte(&dst, b)
 		}
 		i += n
 	}
@@ -587,6 +578,17 @@ func escapeByte(b byte) string {
 	return escapedByteLarge[int(b)*4 : int(b)*4+4]
 }
 
+// isDomainNameLabelSpecial returns true if
+// a domain name label byte should be prefixed
+// with an escaping backslash.
+func isDomainNameLabelSpecial(b byte) bool {
+	switch b {
+	case '.', ' ', '\'', '@', ';', '(', ')', '"', '\\':
+		return true
+	}
+	return false
+}
+
 func nextByte(s string, offset int) (byte, int) {
 	if offset >= len(s) {
 		return 0, 0
@@ -1118,6 +1120,7 @@ type URI struct {
 	Target   string `dns:"octet"`
 }
 
+// rr.Target to be parsed as a sequence of character encoded octets according to RFC 3986
 func (rr *URI) String() string {
 	return rr.Hdr.String() + strconv.Itoa(int(rr.Priority)) +
 		" " + strconv.Itoa(int(rr.Weight)) + " " + sprintTxtOctet(rr.Target)
@@ -1279,6 +1282,7 @@ type CAA struct {
 	Value string `dns:"octet"`
 }
 
+// rr.Value Is the character-string encoding of the value field as specified in RFC 1035, Section 5.1.
 func (rr *CAA) String() string {
 	return rr.Hdr.String() + strconv.Itoa(int(rr.Flag)) + " " + rr.Tag + " " + sprintTxtOctet(rr.Value)
 }

vendor/github.com/miekg/dns/version.go

@@ -3,7 +3,7 @@ package dns
 import "fmt"
 
 // Version is current version of this library.
-var Version = v{1, 1, 29}
+var Version = v{1, 1, 31}
 
 // v holds the version of this library.
 type v struct {

vendor/github.com/miekg/dns/zduplicate.go

@@ -104,6 +104,48 @@ func (r1 *CAA) isDuplicate(_r2 RR) bool {
 	return true
 }
 
+func (r1 *CDNSKEY) isDuplicate(_r2 RR) bool {
+	r2, ok := _r2.(*CDNSKEY)
+	if !ok {
+		return false
+	}
+	_ = r2
+	if r1.Flags != r2.Flags {
+		return false
+	}
+	if r1.Protocol != r2.Protocol {
+		return false
+	}
+	if r1.Algorithm != r2.Algorithm {
+		return false
+	}
+	if r1.PublicKey != r2.PublicKey {
+		return false
+	}
+	return true
+}
+
+func (r1 *CDS) isDuplicate(_r2 RR) bool {
+	r2, ok := _r2.(*CDS)
+	if !ok {
+		return false
+	}
+	_ = r2
+	if r1.KeyTag != r2.KeyTag {
+		return false
+	}
+	if r1.Algorithm != r2.Algorithm {
+		return false
+	}
+	if r1.DigestType != r2.DigestType {
+		return false
+	}
+	if r1.Digest != r2.Digest {
+		return false
+	}
+	return true
+}
+
 func (r1 *CERT) isDuplicate(_r2 RR) bool {
 	r2, ok := _r2.(*CERT)
 	if !ok {
@@ -172,6 +214,27 @@ func (r1 *DHCID) isDuplicate(_r2 RR) bool {
 	return true
 }
 
+func (r1 *DLV) isDuplicate(_r2 RR) bool {
+	r2, ok := _r2.(*DLV)
+	if !ok {
+		return false
+	}
+	_ = r2
+	if r1.KeyTag != r2.KeyTag {
+		return false
+	}
+	if r1.Algorithm != r2.Algorithm {
+		return false
+	}
+	if r1.DigestType != r2.DigestType {
+		return false
+	}
+	if r1.Digest != r2.Digest {
+		return false
+	}
+	return true
+}
+
 func (r1 *DNAME) isDuplicate(_r2 RR) bool {
 	r2, ok := _r2.(*DNAME)
 	if !ok {
@@ -339,6 +402,27 @@ func (r1 *HIP) isDuplicate(_r2 RR) bool {
 	return true
 }
 
+func (r1 *KEY) isDuplicate(_r2 RR) bool {
+	r2, ok := _r2.(*KEY)
+	if !ok {
+		return false
+	}
+	_ = r2
+	if r1.Flags != r2.Flags {
+		return false
+	}
+	if r1.Protocol != r2.Protocol {
+		return false
+	}
+	if r1.Algorithm != r2.Algorithm {
+		return false
+	}
+	if r1.PublicKey != r2.PublicKey {
+		return false
+	}
+	return true
+}
+
 func (r1 *KX) isDuplicate(_r2 RR) bool {
 	r2, ok := _r2.(*KX)
 	if !ok {
@@ -849,6 +933,42 @@ func (r1 *RT) isDuplicate(_r2 RR) bool {
 	return true
 }
 
+func (r1 *SIG) isDuplicate(_r2 RR) bool {
+	r2, ok := _r2.(*SIG)
+	if !ok {
+		return false
+	}
+	_ = r2
+	if r1.TypeCovered != r2.TypeCovered {
+		return false
+	}
+	if r1.Algorithm != r2.Algorithm {
+		return false
+	}
+	if r1.Labels != r2.Labels {
+		return false
+	}
+	if r1.OrigTtl != r2.OrigTtl {
+		return false
+	}
+	if r1.Expiration != r2.Expiration {
+		return false
+	}
+	if r1.Inception != r2.Inception {
+		return false
+	}
+	if r1.KeyTag != r2.KeyTag {
+		return false
+	}
+	if !isDuplicateName(r1.SignerName, r2.SignerName) {
+		return false
+	}
+	if r1.Signature != r2.Signature {
+		return false
+	}
+	return true
+}
+
 func (r1 *SMIMEA) isDuplicate(_r2 RR) bool {
 	r2, ok := _r2.(*SMIMEA)
 	if !ok {

vendor/github.com/miekg/dns/ztypes.go

@@ -685,8 +685,8 @@ func (rr *ANY) copy() RR {
 }
 func (rr *APL) copy() RR {
 	Prefixes := make([]APLPrefix, len(rr.Prefixes))
-	for i := range rr.Prefixes {
-		Prefixes[i] = rr.Prefixes[i].copy()
+	for i, e := range rr.Prefixes {
+		Prefixes[i] = e.copy()
 	}
 	return &APL{rr.Hdr, Prefixes}
 }
@@ -698,6 +698,12 @@ func (rr *AVC) copy() RR {
 func (rr *CAA) copy() RR {
 	return &CAA{rr.Hdr, rr.Flag, rr.Tag, rr.Value}
 }
+func (rr *CDNSKEY) copy() RR {
+	return &CDNSKEY{*rr.DNSKEY.copy().(*DNSKEY)}
+}
+func (rr *CDS) copy() RR {
+	return &CDS{*rr.DS.copy().(*DS)}
+}
 func (rr *CERT) copy() RR {
 	return &CERT{rr.Hdr, rr.Type, rr.KeyTag, rr.Algorithm, rr.Certificate}
 }
@@ -712,6 +718,9 @@ func (rr *CSYNC) copy() RR {
 func (rr *DHCID) copy() RR {
 	return &DHCID{rr.Hdr, rr.Digest}
 }
+func (rr *DLV) copy() RR {
+	return &DLV{*rr.DS.copy().(*DS)}
+}
 func (rr *DNAME) copy() RR {
 	return &DNAME{rr.Hdr, rr.Target}
 }
@@ -744,6 +753,9 @@ func (rr *HIP) copy() RR {
 	copy(RendezvousServers, rr.RendezvousServers)
 	return &HIP{rr.Hdr, rr.HitLength, rr.PublicKeyAlgorithm, rr.PublicKeyLength, rr.Hit, rr.PublicKey, RendezvousServers}
 }
+func (rr *KEY) copy() RR {
+	return &KEY{*rr.DNSKEY.copy().(*DNSKEY)}
+}
 func (rr *KX) copy() RR {
 	return &KX{rr.Hdr, rr.Preference, rr.Exchanger}
 }
@@ -847,6 +859,9 @@ func (rr *RRSIG) copy() RR {
 func (rr *RT) copy() RR {
 	return &RT{rr.Hdr, rr.Preference, rr.Host}
 }
+func (rr *SIG) copy() RR {
+	return &SIG{*rr.RRSIG.copy().(*RRSIG)}
+}
 func (rr *SMIMEA) copy() RR {
 	return &SMIMEA{rr.Hdr, rr.Usage, rr.Selector, rr.MatchingType, rr.Certificate}
 }

vendor/github.com/minio/minio-go/v7/api.go

@@ -108,7 +108,7 @@ type Options struct {
 // Global constants.
 const (
 	libraryName    = "minio-go"
-	libraryVersion = "v7.0.3"
+	libraryVersion = "v7.0.4"
 )
 
 // User Agent should always following the below style.

vendor/github.com/minio/minio-go/v7/go.mod

@@ -3,6 +3,7 @@ module github.com/minio/minio-go/v7
 go 1.12
 
 require (
+	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/google/uuid v1.1.1
 	github.com/json-iterator/go v1.1.10
 	github.com/klauspost/cpuid v1.3.1 // indirect
@@ -13,6 +14,7 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/rs/xid v1.2.1
+	github.com/sirupsen/logrus v1.6.0 // indirect
 	github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a // indirect
 	github.com/stretchr/testify v1.4.0 // indirect
 	golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899

vendor/github.com/minio/minio-go/v7/go.sum

@@ -1,6 +1,8 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -14,6 +16,7 @@ github.com/klauspost/cpuid v1.2.3 h1:CCtW0xUnWGVINKvE/WWOYKdsPV6mawAtvQuSl8guwQs
 github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/cpuid v1.3.1 h1:5JNjFYYQrZeKRJ0734q51WCEEn2huer72Dc7K+R/b6s=
 github.com/klauspost/cpuid v1.3.1/go.mod h1:bYW4mA6ZgKPob1/Dlai2LviZJO7KGI3uoWLd42rAQw4=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -37,11 +40,14 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rs/xid v1.2.1 h1:mhH9Nq+C1fY2l1XIpgxIiUOfNpRBYH1kKcr+qfKgjRc=
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a h1:pa8hGb/2YqsZKovtsgrwcDH1RZhVbTKCjLp47XpqCDs=
 github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
@@ -57,6 +63,7 @@ golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae h1:Ih9Yo4hSPImZOpfGuA4bR/ORKTAbhZo2AbWNRCnevdo=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go

@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"encoding/xml"
 	"fmt"
+	"strconv"
 	"strings"
 	"unicode/utf8"
 
@@ -34,6 +35,9 @@ type OptionType string
 const (
 	// AddOption specifies addition of rule to config
 	AddOption OptionType = "Add"
+	// SetOption specifies modification of existing rule to config
+	SetOption OptionType = "Set"
+
 	// RemoveOption specifies rule options are for removing a rule
 	RemoveOption OptionType = "Remove"
 	// ImportOption is for getting current config
@@ -45,8 +49,8 @@ type Options struct {
 	Op           OptionType
 	ID           string
 	Prefix       string
-	Disable      bool
-	Priority     int
+	RuleStatus   string
+	Priority     string
 	TagString    string
 	StorageClass string
 	Arn          string
@@ -74,8 +78,7 @@ func (opts Options) Tags() []Tag {
 type Config struct {
 	XMLName xml.Name `xml:"ReplicationConfiguration" json:"-"`
 	Rules   []Rule   `xml:"Rule" json:"Rules"`
-	// ReplicationARN is a MinIO only extension and optional for AWS
-	ReplicationARN string `xml:"ReplicationArn,omitempty" json:"ReplicationArn,omitempty"`
+	Role    string   `xml:"Role" json:"Role"`
 }
 
 // Empty returns true if config is not set
@@ -104,20 +107,32 @@ func (c *Config) AddRule(opts Options) error {
 	if opts.ID == "" {
 		opts.ID = xid.New().String()
 	}
-	status := Enabled
-	if opts.Disable {
+	var status Status
+	// toggle rule status for edit option
+	switch opts.RuleStatus {
+	case "enable":
+		status = Enabled
+	case "disable":
 		status = Disabled
 	}
-	tokens := strings.Split(opts.Arn, ":")
+	arnStr := opts.Arn
+	if opts.Arn == "" {
+		arnStr = c.Role
+	}
+	tokens := strings.Split(arnStr, ":")
 	if len(tokens) != 6 {
 		return fmt.Errorf("invalid format for replication Arn")
 	}
-	if c.ReplicationARN == "" { // for new configurations
-		c.ReplicationARN = opts.Arn
+	if c.Role == "" { // for new configurations
+		c.Role = opts.Arn
+	}
+	priority, err := strconv.Atoi(opts.Priority)
+	if err != nil {
+		return err
 	}
 	newRule := Rule{
 		ID:       opts.ID,
-		Priority: opts.Priority,
+		Priority: priority,
 		Status:   status,
 		Filter:   filter,
 		Destination: Destination{
@@ -138,10 +153,13 @@ func (c *Config) AddRule(opts Options) error {
 		if rule.ID != newRule.ID {
 			continue
 		}
-		if newRule.Status == Disabled && rule.ID == newRule.ID {
+		if opts.Priority == "" && rule.ID == newRule.ID {
 			// inherit priority from existing rule, required field on server
 			newRule.Priority = rule.Priority
 		}
+		if opts.RuleStatus == "" {
+			newRule.Status = rule.Status
+		}
 		c.Rules[i] = newRule
 		ruleFound = true
 		break
@@ -150,7 +168,9 @@ func (c *Config) AddRule(opts Options) error {
 	if err := newRule.Validate(); err != nil {
 		return err
 	}
-
+	if !ruleFound && opts.Op == SetOption {
+		return fmt.Errorf("Rule with ID %s not found in replication configuration", opts.ID)
+	}
 	if !ruleFound {
 		c.Rules = append(c.Rules, newRule)
 	}
@@ -197,7 +217,7 @@ func (r Rule) Validate() error {
 		return err
 	}
 
-	if r.Priority <= 0 && r.Status == Enabled {
+	if r.Priority < 0 && r.Status == Enabled {
 		return fmt.Errorf("Priority must be set for the rule")
 	}
 

vendor/github.com/mitchellh/mapstructure/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.3.3
+
+* Decoding maps from maps creates a settable value for decode hooks [GH-203]
+
 ## 1.3.2
 
 * Decode into interface type with a struct value is supported [GH-187]

vendor/github.com/mitchellh/mapstructure/mapstructure.go

@@ -906,11 +906,22 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
 			mType := reflect.MapOf(vKeyType, vElemType)
 			vMap := reflect.MakeMap(mType)
 
-			err := d.decode(keyName, x.Interface(), vMap)
+			// Creating a pointer to a map so that other methods can completely
+			// overwrite the map if need be (looking at you decodeMapFromMap). The
+			// indirection allows the underlying map to be settable (CanSet() == true)
+			// where as reflect.MakeMap returns an unsettable map.
+			addrVal := reflect.New(vMap.Type())
+			reflect.Indirect(addrVal).Set(vMap)
+
+			err := d.decode(keyName, x.Interface(), reflect.Indirect(addrVal))
 			if err != nil {
 				return err
 			}
 
+			// the underlying map may have been completely overwritten so pull
+			// it indirectly out of the enclosing value.
+			vMap = reflect.Indirect(addrVal)
+
 			if squash {
 				for _, k := range vMap.MapKeys() {
 					valMap.SetMapIndex(k, vMap.MapIndex(k))
@@ -1154,13 +1165,23 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
 		// Not the most efficient way to do this but we can optimize later if
 		// we want to. To convert from struct to struct we go to map first
 		// as an intermediary.
-		m := make(map[string]interface{})
-		mval := reflect.Indirect(reflect.ValueOf(&m))
-		if err := d.decodeMapFromStruct(name, dataVal, mval, mval); err != nil {
+
+		// Make a new map to hold our result
+		mapType := reflect.TypeOf((map[string]interface{})(nil))
+		mval := reflect.MakeMap(mapType)
+
+		// Creating a pointer to a map so that other methods can completely
+		// overwrite the map if need be (looking at you decodeMapFromMap). The
+		// indirection allows the underlying map to be settable (CanSet() == true)
+		// where as reflect.MakeMap returns an unsettable map.
+		addrVal := reflect.New(mval.Type())
+
+		reflect.Indirect(addrVal).Set(mval)
+		if err := d.decodeMapFromStruct(name, dataVal, reflect.Indirect(addrVal), mval); err != nil {
 			return err
 		}
 
-		result := d.decodeStructFromMap(name, mval, val)
+		result := d.decodeStructFromMap(name, reflect.Indirect(addrVal), val)
 		return result
 
 	default:

vendor/github.com/olivere/elastic/CONTRIBUTORS

@@ -40,6 +40,7 @@ Bryan Conklin [@bmconklin](https://github.com/bmconklin)
 Bruce Zhou [@brucez-isell](https://github.com/brucez-isell)
 Carl Dunham [@carldunham](https://github.com/carldunham)
 Carl Johan Gustavsson [@cjgu](https://github.com/cjgu)
+Carson [@carson0321](https://github.com/carson0321)
 Cat [@cat-turner](https://github.com/cat-turner)
 César Jiménez [@cesarjimenez](https://github.com/cesarjimenez)
 cforbes [@cforbes](https://github.com/cforbes)
@@ -56,6 +57,7 @@ Connor Peet [@connor4312](https://github.com/connor4312)
 Conrad Pankoff [@deoxxa](https://github.com/deoxxa)
 Corey Scott [@corsc](https://github.com/corsc)
 Chris Petersen [@ex-nerd](https://github.com/ex-nerd)
+czxichen [@czxichen](https://github.com/czxichen)
 Daniel Barrett [@shendaras](https://github.com/shendaras)
 Daniel Heckrath [@DanielHeckrath](https://github.com/DanielHeckrath)
 Daniel Imfeld [@dimfeld](https://github.com/dimfeld)
@@ -154,6 +156,7 @@ okhowang [@okhowang](https://github.com/okhowang)
 Orne Brocaar [@brocaar](https://github.com/brocaar)
 Paul [@eyeamera](https://github.com/eyeamera)
 Paul Oldenburg [@lr-paul](https://github.com/lr-paul)
+Pedro [@otherview](https://github.com/otherview)
 Pete C [@peteclark-ft](https://github.com/peteclark-ft)
 Peter Nagy [@nagypeterjob](https://github.com/nagypeterjob)
 Paolo [@ppiccolo](https://github.com/ppiccolo)

vendor/github.com/opentracing/opentracing-go/.travis.yml

@@ -2,8 +2,8 @@ language: go
 
 matrix:
   include:
-  - go: "1.11.x"
-  - go: "1.12.x"
+  - go: "1.13.x"
+  - go: "1.14.x"
   - go: "tip"
     env:
     - LINT=true

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

@@ -1,6 +1,23 @@
 Changes by Version
 ==================
 
+
+1.2.0 (2020-07-01)
+-------------------
+
+* Restore the ability to reset the current span in context to nil (#231) -- Yuri Shkuro
+* Use error.object per OpenTracing Semantic Conventions (#179) -- Rahman Syed
+* Convert nil pointer log field value to string "nil" (#230) -- Cyril Tovena
+* Add Go module support (#215) -- Zaba505
+* Make SetTag helper types in ext public (#229) -- Blake Edwards
+* Add log/fields helpers for keys from specification (#226) -- Dmitry Monakhov
+* Improve noop impementation (#223) -- chanxuehong
+* Add an extension to Tracer interface for custom go context creation (#220) -- Krzesimir Nowak
+* Fix typo in comments (#222) -- meteorlxy
+* Improve documentation for log.Object() to emphasize the requirement to pass immutable arguments (#219) -- 疯狂的小企鹅
+* [mock] Return ErrInvalidSpanContext if span context is not MockSpanContext (#216) -- Milad Irannejad
+
+
 1.1.0 (2019-03-23)
 -------------------
 

vendor/github.com/opentracing/opentracing-go/ext.go

@@ -0,0 +1,24 @@
+package opentracing
+
+import (
+	"context"
+)
+
+// TracerContextWithSpanExtension is an extension interface that the
+// implementation of the Tracer interface may want to implement. It
+// allows to have some control over the go context when the
+// ContextWithSpan is invoked.
+//
+// The primary purpose of this extension are adapters from opentracing
+// API to some other tracing API.
+type TracerContextWithSpanExtension interface {
+	// ContextWithSpanHook gets called by the ContextWithSpan
+	// function, when the Tracer implementation also implements
+	// this interface. It allows to put extra information into the
+	// context and make it available to the callers of the
+	// ContextWithSpan.
+	//
+	// This hook is invoked before the ContextWithSpan function
+	// actually puts the span into the context.
+	ContextWithSpanHook(ctx context.Context, span Span) context.Context
+}

vendor/github.com/opentracing/opentracing-go/ext/field.go

@@ -0,0 +1,17 @@
+package ext
+
+import (
+	"github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go/log"
+)
+
+// LogError sets the error=true tag on the Span and logs err as an "error" event.
+func LogError(span opentracing.Span, err error, fields ...log.Field) {
+	Error.Set(span, true)
+	ef := []log.Field{
+		log.Event("error"),
+		log.Error(err),
+	}
+	ef = append(ef, fields...)
+	span.LogFields(ef...)
+}

vendor/github.com/opentracing/opentracing-go/ext/tags.go

@@ -47,40 +47,40 @@ var (
 
 	// Component is a low-cardinality identifier of the module, library,
 	// or package that is generating a span.
-	Component = stringTagName("component")
+	Component = StringTagName("component")
 
 	//////////////////////////////////////////////////////////////////////
 	// Sampling hint
 	//////////////////////////////////////////////////////////////////////
 
 	// SamplingPriority determines the priority of sampling this Span.
-	SamplingPriority = uint16TagName("sampling.priority")
+	SamplingPriority = Uint16TagName("sampling.priority")
 
 	//////////////////////////////////////////////////////////////////////
-	// Peer tags. These tags can be emitted by either client-side of
+	// Peer tags. These tags can be emitted by either client-side or
 	// server-side to describe the other side/service in a peer-to-peer
 	// communications, like an RPC call.
 	//////////////////////////////////////////////////////////////////////
 
 	// PeerService records the service name of the peer.
-	PeerService = stringTagName("peer.service")
+	PeerService = StringTagName("peer.service")
 
 	// PeerAddress records the address name of the peer. This may be a "ip:port",
 	// a bare "hostname", a FQDN or even a database DSN substring
 	// like "mysql://username@127.0.0.1:3306/dbname"
-	PeerAddress = stringTagName("peer.address")
+	PeerAddress = StringTagName("peer.address")
 
 	// PeerHostname records the host name of the peer
-	PeerHostname = stringTagName("peer.hostname")
+	PeerHostname = StringTagName("peer.hostname")
 
 	// PeerHostIPv4 records IP v4 host address of the peer
-	PeerHostIPv4 = ipv4Tag("peer.ipv4")
+	PeerHostIPv4 = IPv4TagName("peer.ipv4")
 
 	// PeerHostIPv6 records IP v6 host address of the peer
-	PeerHostIPv6 = stringTagName("peer.ipv6")
+	PeerHostIPv6 = StringTagName("peer.ipv6")
 
 	// PeerPort records port number of the peer
-	PeerPort = uint16TagName("peer.port")
+	PeerPort = Uint16TagName("peer.port")
 
 	//////////////////////////////////////////////////////////////////////
 	// HTTP Tags
@@ -88,46 +88,46 @@ var (
 
 	// HTTPUrl should be the URL of the request being handled in this segment
 	// of the trace, in standard URI format. The protocol is optional.
-	HTTPUrl = stringTagName("http.url")
+	HTTPUrl = StringTagName("http.url")
 
 	// HTTPMethod is the HTTP method of the request, and is case-insensitive.
-	HTTPMethod = stringTagName("http.method")
+	HTTPMethod = StringTagName("http.method")
 
 	// HTTPStatusCode is the numeric HTTP status code (200, 404, etc) of the
 	// HTTP response.
-	HTTPStatusCode = uint16TagName("http.status_code")
+	HTTPStatusCode = Uint16TagName("http.status_code")
 
 	//////////////////////////////////////////////////////////////////////
 	// DB Tags
 	//////////////////////////////////////////////////////////////////////
 
 	// DBInstance is database instance name.
-	DBInstance = stringTagName("db.instance")
+	DBInstance = StringTagName("db.instance")
 
 	// DBStatement is a database statement for the given database type.
 	// It can be a query or a prepared statement (i.e., before substitution).
-	DBStatement = stringTagName("db.statement")
+	DBStatement = StringTagName("db.statement")
 
 	// DBType is a database type. For any SQL database, "sql".
 	// For others, the lower-case database category, e.g. "redis"
-	DBType = stringTagName("db.type")
+	DBType = StringTagName("db.type")
 
 	// DBUser is a username for accessing database.
-	DBUser = stringTagName("db.user")
+	DBUser = StringTagName("db.user")
 
 	//////////////////////////////////////////////////////////////////////
 	// Message Bus Tag
 	//////////////////////////////////////////////////////////////////////
 
 	// MessageBusDestination is an address at which messages can be exchanged
-	MessageBusDestination = stringTagName("message_bus.destination")
+	MessageBusDestination = StringTagName("message_bus.destination")
 
 	//////////////////////////////////////////////////////////////////////
 	// Error Tag
 	//////////////////////////////////////////////////////////////////////
 
 	// Error indicates that operation represented by the span resulted in an error.
-	Error = boolTagName("error")
+	Error = BoolTagName("error")
 )
 
 // ---
@@ -163,48 +163,53 @@ func RPCServerOption(client opentracing.SpanContext) opentracing.StartSpanOption
 
 // ---
 
-type stringTagName string
+// StringTagName is a common tag name to be set to a string value
+type StringTagName string
 
 // Set adds a string tag to the `span`
-func (tag stringTagName) Set(span opentracing.Span, value string) {
+func (tag StringTagName) Set(span opentracing.Span, value string) {
 	span.SetTag(string(tag), value)
 }
 
 // ---
 
-type uint32TagName string
+// Uint32TagName is a common tag name to be set to a uint32 value
+type Uint32TagName string
 
 // Set adds a uint32 tag to the `span`
-func (tag uint32TagName) Set(span opentracing.Span, value uint32) {
+func (tag Uint32TagName) Set(span opentracing.Span, value uint32) {
 	span.SetTag(string(tag), value)
 }
 
 // ---
 
-type uint16TagName string
+// Uint16TagName is a common tag name to be set to a uint16 value
+type Uint16TagName string
 
 // Set adds a uint16 tag to the `span`
-func (tag uint16TagName) Set(span opentracing.Span, value uint16) {
+func (tag Uint16TagName) Set(span opentracing.Span, value uint16) {
 	span.SetTag(string(tag), value)
 }
 
 // ---
 
-type boolTagName string
+// BoolTagName is a common tag name to be set to a bool value
+type BoolTagName string
 
-// Add adds a bool tag to the `span`
-func (tag boolTagName) Set(span opentracing.Span, value bool) {
+// Set adds a bool tag to the `span`
+func (tag BoolTagName) Set(span opentracing.Span, value bool) {
 	span.SetTag(string(tag), value)
 }
 
-type ipv4Tag string
+// IPv4TagName is a common tag name to be set to an ipv4 value
+type IPv4TagName string
 
 // Set adds IP v4 host address of the peer as an uint32 value to the `span`, keep this for backward and zipkin compatibility
-func (tag ipv4Tag) Set(span opentracing.Span, value uint32) {
+func (tag IPv4TagName) Set(span opentracing.Span, value uint32) {
 	span.SetTag(string(tag), value)
 }
 
 // SetString records IP v4 host address of the peer as a .-separated tuple to the `span`. E.g., "127.0.0.1"
-func (tag ipv4Tag) SetString(span opentracing.Span, value string) {
+func (tag IPv4TagName) SetString(span opentracing.Span, value string) {
 	span.SetTag(string(tag), value)
 }

vendor/github.com/opentracing/opentracing-go/go.mod

@@ -0,0 +1,5 @@
+module github.com/opentracing/opentracing-go
+
+go 1.14
+
+require github.com/stretchr/testify v1.3.0

vendor/github.com/opentracing/opentracing-go/go.sum

@@ -0,0 +1,7 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

vendor/github.com/opentracing/opentracing-go/gocontext.go

@@ -7,8 +7,13 @@ type contextKey struct{}
 var activeSpanKey = contextKey{}
 
 // ContextWithSpan returns a new `context.Context` that holds a reference to
-// `span`'s SpanContext.
+// the span. If span is nil, a new context without an active span is returned.
 func ContextWithSpan(ctx context.Context, span Span) context.Context {
+	if span != nil {
+		if tracerWithHook, ok := span.Tracer().(TracerContextWithSpanExtension); ok {
+			ctx = tracerWithHook.ContextWithSpanHook(ctx, span)
+		}
+	}
 	return context.WithValue(ctx, activeSpanKey, span)
 }
 

vendor/github.com/opentracing/opentracing-go/log/field.go

@@ -122,16 +122,19 @@ func Float64(key string, val float64) Field {
 	}
 }
 
-// Error adds an error with the key "error" to a Span.LogFields() record
+// Error adds an error with the key "error.object" to a Span.LogFields() record
 func Error(err error) Field {
 	return Field{
-		key:          "error",
+		key:          "error.object",
 		fieldType:    errorType,
 		interfaceVal: err,
 	}
 }
 
 // Object adds an object-valued key:value pair to a Span.LogFields() record
+// Please pass in an immutable object, otherwise there may be concurrency issues.
+// Such as passing in the map, log.Object may result in "fatal error: concurrent map iteration and map write".
+// Because span is sent asynchronously, it is possible that this map will also be modified.
 func Object(key string, obj interface{}) Field {
 	return Field{
 		key:          key,
@@ -140,6 +143,16 @@ func Object(key string, obj interface{}) Field {
 	}
 }
 
+// Event creates a string-valued Field for span logs with key="event" and value=val.
+func Event(val string) Field {
+	return String("event", val)
+}
+
+// Message creates a string-valued Field for span logs with key="message" and value=val.
+func Message(val string) Field {
+	return String("message", val)
+}
+
 // LazyLogger allows for user-defined, late-bound logging of arbitrary data
 type LazyLogger func(fv Encoder)
 

vendor/github.com/opentracing/opentracing-go/log/util.go

@@ -1,6 +1,9 @@
 package log
 
-import "fmt"
+import (
+	"fmt"
+	"reflect"
+)
 
 // InterleavedKVToFields converts keyValues a la Span.LogKV() to a Field slice
 // a la Span.LogFields().
@@ -46,6 +49,10 @@ func InterleavedKVToFields(keyValues ...interface{}) ([]Field, error) {
 		case float64:
 			fields[i] = Float64(key, typedVal)
 		default:
+			if typedVal == nil || (reflect.ValueOf(typedVal).Kind() == reflect.Ptr && reflect.ValueOf(typedVal).IsNil()) {
+				fields[i] = String(key, "nil")
+				continue
+			}
 			// When in doubt, coerce to a string
 			fields[i] = String(key, fmt.Sprint(typedVal))
 		}

vendor/github.com/opentracing/opentracing-go/noop.go

@@ -21,9 +21,9 @@ type noopSpan struct{}
 type noopSpanContext struct{}
 
 var (
-	defaultNoopSpanContext = noopSpanContext{}
-	defaultNoopSpan        = noopSpan{}
-	defaultNoopTracer      = NoopTracer{}
+	defaultNoopSpanContext SpanContext = noopSpanContext{}
+	defaultNoopSpan        Span        = noopSpan{}
+	defaultNoopTracer      Tracer      = NoopTracer{}
 )
 
 const (
@@ -35,7 +35,7 @@ func (n noopSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {}
 
 // noopSpan:
 func (n noopSpan) Context() SpanContext                                  { return defaultNoopSpanContext }
-func (n noopSpan) SetBaggageItem(key, val string) Span                   { return defaultNoopSpan }
+func (n noopSpan) SetBaggageItem(key, val string) Span                   { return n }
 func (n noopSpan) BaggageItem(key string) string                         { return emptyString }
 func (n noopSpan) SetTag(key string, value interface{}) Span             { return n }
 func (n noopSpan) LogFields(fields ...log.Field)                         {}

vendor/github.com/pborman/uuid/time.go

@@ -29,7 +29,7 @@ func GetTime() (Time, uint16, error) { return guuid.GetTime() }
 // for
 func ClockSequence() int { return guuid.ClockSequence() }
 
-// SetClockSeq sets the clock sequence to the lower 14 bits of seq.  Setting to
+// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
 // -1 causes a new sequence to be generated.
 func SetClockSequence(seq int) { guuid.SetClockSequence(seq) }
 

vendor/github.com/pborman/uuid/version4.go

@@ -6,7 +6,7 @@ package uuid
 
 import guuid "github.com/google/uuid"
 
-// Random returns a Random (Version 4) UUID or panics.
+// NewRandom returns a Random (Version 4) UUID or panics.
 //
 // The strength of the UUIDs is based on the strength of the crypto/rand
 // package.

vendor/github.com/prometheus/common/expfmt/decode.go

@@ -164,7 +164,7 @@ func (sd *SampleDecoder) Decode(s *model.Vector) error {
 }
 
 // ExtractSamples builds a slice of samples from the provided metric
-// families. If an error occurrs during sample extraction, it continues to
+// families. If an error occurs during sample extraction, it continues to
 // extract from the remaining metric families. The returned error is the last
 // error that has occurred.
 func ExtractSamples(o *DecodeOptions, fams ...*dto.MetricFamily) (model.Vector, error) {

vendor/github.com/prometheus/common/model/fnv.go

@@ -20,7 +20,7 @@ const (
 	prime64  = 1099511628211
 )
 
-// hashNew initializies a new fnv64a hash value.
+// hashNew initializes a new fnv64a hash value.
 func hashNew() uint64 {
 	return offset64
 }

vendor/github.com/prometheus/common/model/time.go

@@ -181,77 +181,77 @@ func (d *Duration) Type() string {
 	return "duration"
 }
 
-var durationRE = regexp.MustCompile("^([0-9]+)(y|w|d|h|m|s|ms)$")
+var durationRE = regexp.MustCompile("^(([0-9]+)y)?(([0-9]+)w)?(([0-9]+)d)?(([0-9]+)h)?(([0-9]+)m)?(([0-9]+)s)?(([0-9]+)ms)?$")
 
 // ParseDuration parses a string into a time.Duration, assuming that a year
 // always has 365d, a week always has 7d, and a day always has 24h.
 func ParseDuration(durationStr string) (Duration, error) {
-	// Allow 0 without a unit.
-	if durationStr == "0" {
+	switch durationStr {
+	case "0":
+		// Allow 0 without a unit.
 		return 0, nil
+	case "":
+		return 0, fmt.Errorf("empty duration string")
 	}
 	matches := durationRE.FindStringSubmatch(durationStr)
-	if len(matches) != 3 {
+	if matches == nil {
 		return 0, fmt.Errorf("not a valid duration string: %q", durationStr)
 	}
-	var (
-		n, _ = strconv.Atoi(matches[1])
-		dur  = time.Duration(n) * time.Millisecond
-	)
-	switch unit := matches[2]; unit {
-	case "y":
-		dur *= 1000 * 60 * 60 * 24 * 365
-	case "w":
-		dur *= 1000 * 60 * 60 * 24 * 7
-	case "d":
-		dur *= 1000 * 60 * 60 * 24
-	case "h":
-		dur *= 1000 * 60 * 60
-	case "m":
-		dur *= 1000 * 60
-	case "s":
-		dur *= 1000
-	case "ms":
-		// Value already correct
-	default:
-		return 0, fmt.Errorf("invalid time unit in duration string: %q", unit)
+	var dur time.Duration
+
+	// Parse the match at pos `pos` in the regex and use `mult` to turn that
+	// into ms, then add that value to the total parsed duration.
+	m := func(pos int, mult time.Duration) {
+		if matches[pos] == "" {
+			return
+		}
+		n, _ := strconv.Atoi(matches[pos])
+		d := time.Duration(n) * time.Millisecond
+		dur += d * mult
 	}
+
+	m(2, 1000*60*60*24*365) // y
+	m(4, 1000*60*60*24*7)   // w
+	m(6, 1000*60*60*24)     // d
+	m(8, 1000*60*60)        // h
+	m(10, 1000*60)          // m
+	m(12, 1000)             // s
+	m(14, 1)                // ms
+
 	return Duration(dur), nil
 }
 
 func (d Duration) String() string {
 	var (
-		ms   = int64(time.Duration(d) / time.Millisecond)
-		unit = "ms"
+		ms = int64(time.Duration(d) / time.Millisecond)
+		r  = ""
 	)
 	if ms == 0 {
 		return "0s"
 	}
-	factors := map[string]int64{
-		"y":  1000 * 60 * 60 * 24 * 365,
-		"w":  1000 * 60 * 60 * 24 * 7,
-		"d":  1000 * 60 * 60 * 24,
-		"h":  1000 * 60 * 60,
-		"m":  1000 * 60,
-		"s":  1000,
-		"ms": 1,
+
+	f := func(unit string, mult int64, exact bool) {
+		if exact && ms%mult != 0 {
+			return
+		}
+		if v := ms / mult; v > 0 {
+			r += fmt.Sprintf("%d%s", v, unit)
+			ms -= v * mult
+		}
 	}
 
-	switch int64(0) {
-	case ms % factors["y"]:
-		unit = "y"
-	case ms % factors["w"]:
-		unit = "w"
-	case ms % factors["d"]:
-		unit = "d"
-	case ms % factors["h"]:
-		unit = "h"
-	case ms % factors["m"]:
-		unit = "m"
-	case ms % factors["s"]:
-		unit = "s"
-	}
-	return fmt.Sprintf("%v%v", ms/factors[unit], unit)
+	// Only format years and weeks if the remainder is zero, as it is often
+	// easier to read 90d than 12w6d.
+	f("y", 1000*60*60*24*365, true)
+	f("w", 1000*60*60*24*7, true)
+
+	f("d", 1000*60*60*24, false)
+	f("h", 1000*60*60, false)
+	f("m", 1000*60, false)
+	f("s", 1000, false)
+	f("ms", 1, false)
+
+	return r
 }
 
 // MarshalYAML implements the yaml.Marshaler interface.

vendor/github.com/spf13/afero/go.mod

@@ -3,7 +3,7 @@ module github.com/spf13/afero
 require (
 	github.com/pkg/sftp v1.10.1
 	golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586
-	golang.org/x/text v0.3.0
+	golang.org/x/text v0.3.3
 )
 
 go 1.13

vendor/github.com/spf13/afero/go.sum

@@ -1,3 +1,4 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
@@ -5,16 +6,24 @@ github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.10.1 h1:VasscCm72135zRysgrJDKsntdmPN+OuU3+nnHYA9wyc=
 github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586 h1:7KByu05hhLed2MO29w7p1XfZvZ13m8mub3shuVftRs0=
 golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/github.com/spf13/afero/memmap.go

@@ -25,6 +25,8 @@ import (
 	"github.com/spf13/afero/mem"
 )
 
+const chmodBits = os.ModePerm | os.ModeSetuid | os.ModeSetgid | os.ModeSticky // Only a subset of bits are allowed to be changed. Documented under os.Chmod()
+
 type MemMapFs struct {
 	mu   sync.RWMutex
 	data map[string]*mem.FileData
@@ -40,7 +42,9 @@ func (m *MemMapFs) getData() map[string]*mem.FileData {
 		m.data = make(map[string]*mem.FileData)
 		// Root should always exist, right?
 		// TODO: what about windows?
-		m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator)
+		root := mem.CreateDir(FilePathSeparator)
+		mem.SetMode(root, os.ModeDir|0755)
+		m.data[FilePathSeparator] = root
 	})
 	return m.data
 }
@@ -52,7 +56,7 @@ func (m *MemMapFs) Create(name string) (File, error) {
 	m.mu.Lock()
 	file := mem.CreateFile(name)
 	m.getData()[name] = file
-	m.registerWithParent(file)
+	m.registerWithParent(file, 0)
 	m.mu.Unlock()
 	return mem.NewFileHandle(file), nil
 }
@@ -83,14 +87,14 @@ func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData {
 	return pfile
 }
 
-func (m *MemMapFs) registerWithParent(f *mem.FileData) {
+func (m *MemMapFs) registerWithParent(f *mem.FileData, perm os.FileMode) {
 	if f == nil {
 		return
 	}
 	parent := m.findParent(f)
 	if parent == nil {
 		pdir := filepath.Dir(filepath.Clean(f.Name()))
-		err := m.lockfreeMkdir(pdir, 0777)
+		err := m.lockfreeMkdir(pdir, perm)
 		if err != nil {
 			//log.Println("Mkdir error:", err)
 			return
@@ -119,13 +123,15 @@ func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error {
 		}
 	} else {
 		item := mem.CreateDir(name)
+		mem.SetMode(item, os.ModeDir|perm)
 		m.getData()[name] = item
-		m.registerWithParent(item)
+		m.registerWithParent(item, perm)
 	}
 	return nil
 }
 
 func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
+	perm &= chmodBits
 	name = normalizePath(name)
 
 	m.mu.RLock()
@@ -137,13 +143,12 @@ func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
 
 	m.mu.Lock()
 	item := mem.CreateDir(name)
+	mem.SetMode(item, os.ModeDir|perm)
 	m.getData()[name] = item
-	m.registerWithParent(item)
+	m.registerWithParent(item, perm)
 	m.mu.Unlock()
 
-	m.Chmod(name, perm|os.ModeDir)
-
-	return nil
+	return m.setFileMode(name, perm|os.ModeDir)
 }
 
 func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error {
@@ -210,6 +215,7 @@ func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) {
 }
 
 func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
+	perm &= chmodBits
 	chmod := false
 	file, err := m.openWrite(name)
 	if err == nil && (flag&os.O_EXCL > 0) {
@@ -240,7 +246,7 @@ func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, erro
 		}
 	}
 	if chmod {
-		m.Chmod(name, perm)
+		return file, m.setFileMode(name, perm)
 	}
 	return file, nil
 }
@@ -302,7 +308,7 @@ func (m *MemMapFs) Rename(oldname, newname string) error {
 		delete(m.getData(), oldname)
 		mem.ChangeFileName(fileData, newname)
 		m.getData()[newname] = fileData
-		m.registerWithParent(fileData)
+		m.registerWithParent(fileData, 0)
 		m.mu.Unlock()
 		m.mu.RLock()
 	} else {
@@ -321,6 +327,21 @@ func (m *MemMapFs) Stat(name string) (os.FileInfo, error) {
 }
 
 func (m *MemMapFs) Chmod(name string, mode os.FileMode) error {
+	mode &= chmodBits
+
+	m.mu.RLock()
+	f, ok := m.getData()[name]
+	m.mu.RUnlock()
+	if !ok {
+		return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound}
+	}
+	prevOtherBits := mem.GetFileInfo(f).Mode() & ^chmodBits
+
+	mode = prevOtherBits | mode
+	return m.setFileMode(name, mode)
+}
+
+func (m *MemMapFs) setFileMode(name string, mode os.FileMode) error {
 	name = normalizePath(name)
 
 	m.mu.RLock()

vendor/github.com/stretchr/objx/accessors.go

@@ -1,6 +1,7 @@
 package objx
 
 import (
+	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
@@ -16,11 +17,18 @@ const (
 	// arrayAccesRegexString is the regex used to extract the array number
 	// from the access path
 	arrayAccesRegexString = `^(.+)\[([0-9]+)\]$`
+
+	// mapAccessRegexString is the regex used to extract the map key
+	// from the access path
+	mapAccessRegexString = `^([^\[]*)\[([^\]]+)\](.*)$`
 )
 
 // arrayAccesRegex is the compiled arrayAccesRegexString
 var arrayAccesRegex = regexp.MustCompile(arrayAccesRegexString)
 
+// mapAccessRegex is the compiled mapAccessRegexString
+var mapAccessRegex = regexp.MustCompile(mapAccessRegexString)
+
 // Get gets the value using the specified selector and
 // returns it inside a new Obj object.
 //
@@ -70,13 +78,45 @@ func getIndex(s string) (int, string) {
 	return -1, s
 }
 
+// getKey returns the key which is held in s by two brackets.
+// It also returns the next selector.
+func getKey(s string) (string, string) {
+	selSegs := strings.SplitN(s, PathSeparator, 2)
+	thisSel := selSegs[0]
+	nextSel := ""
+
+	if len(selSegs) > 1 {
+		nextSel = selSegs[1]
+	}
+
+	mapMatches := mapAccessRegex.FindStringSubmatch(s)
+	if len(mapMatches) > 0 {
+		if _, err := strconv.Atoi(mapMatches[2]); err != nil {
+			thisSel = mapMatches[1]
+			nextSel = "[" + mapMatches[2] + "]" + mapMatches[3]
+
+			if thisSel == "" {
+				thisSel = mapMatches[2]
+				nextSel = mapMatches[3]
+			}
+
+			if nextSel == "" {
+				selSegs = []string{"", ""}
+			} else if nextSel[0] == '.' {
+				nextSel = nextSel[1:]
+			}
+		}
+	}
+
+	return thisSel, nextSel
+}
+
 // access accesses the object using the selector and performs the
 // appropriate action.
 func access(current interface{}, selector string, value interface{}, isSet bool) interface{} {
-	selSegs := strings.SplitN(selector, PathSeparator, 2)
-	thisSel := selSegs[0]
-	index := -1
+	thisSel, nextSel := getKey(selector)
 
+	index := -1
 	if strings.Contains(thisSel, "[") {
 		index, thisSel = getIndex(thisSel)
 	}
@@ -88,7 +128,7 @@ func access(current interface{}, selector string, value interface{}, isSet bool)
 	switch current.(type) {
 	case map[string]interface{}:
 		curMSI := current.(map[string]interface{})
-		if len(selSegs) <= 1 && isSet {
+		if nextSel == "" && isSet {
 			curMSI[thisSel] = value
 			return nil
 		}
@@ -102,9 +142,10 @@ func access(current interface{}, selector string, value interface{}, isSet bool)
 	default:
 		current = nil
 	}
+
 	// do we need to access the item of an array?
 	if index > -1 {
-		if array, ok := current.([]interface{}); ok {
+		if array, ok := interSlice(current); ok {
 			if index < len(array) {
 				current = array[index]
 			} else {
@@ -112,8 +153,27 @@ func access(current interface{}, selector string, value interface{}, isSet bool)
 			}
 		}
 	}
-	if len(selSegs) > 1 {
-		current = access(current, selSegs[1], value, isSet)
+	if nextSel != "" {
+		current = access(current, nextSel, value, isSet)
 	}
 	return current
 }
+
+func interSlice(slice interface{}) ([]interface{}, bool) {
+	if array, ok := slice.([]interface{}); ok {
+		return array, ok
+	}
+
+	s := reflect.ValueOf(slice)
+	if s.Kind() != reflect.Slice {
+		return nil, false
+	}
+
+	ret := make([]interface{}, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		ret[i] = s.Index(i).Interface()
+	}
+
+	return ret, true
+}

vendor/github.com/throttled/throttled/.travis.yml

@@ -1,22 +0,0 @@
-sudo: false
-
-language: go
-
-go:
-    - "1.9"
-    - "1.10"
-    - "1.11"
-    # 1.x builds the latest in that series. Also try to add other versions here
-    # as they come up so that we're pretty sure that we're maintaining
-    # backwards compatibility.
-    - 1.x
-
-notifications:
-  email: false
-
-services:
-  - redis-server
-
-install: make get-deps
-
-script: make

vendor/github.com/throttled/throttled/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 2.2.5 - 2020-08-01
+* [#67](https://github.com/throttled/throttled/pull/67) Bug fix: Fix TTL in `SetIfNotExistsWithTTL`
+* [#74](https://github.com/throttled/throttled/pull/74) Bug fix: Always select DB for Redigo store, even when DB is configured to 0
+
 ## 2.2.4 - 2018-11-19
 * [#52](https://github.com/throttled/throttled/pull/52) Handle the possibility of `RemoteAddr` without port in `VaryBy`
 

vendor/github.com/throttled/throttled/Makefile

@@ -1,30 +1,29 @@
+.PHONY: all
+all: build test vet fmt lint
 
+.PHONY: build
+build:
+	go build ./...
 
-.PHONY: test test-cover bench lint get-deps .go-test .go-test-cover
-
-test: .go-test bench lint
-
-test-cover: .go-test-cover bench lint
-
-bench:
-	go test -race -bench=. -cpu=1,2,4
-
-lint:
-	gofmt -l .
-	go vet ./...
-	which golint # Fail if golint doesn't exist
-	-golint . # Don't fail on golint warnings themselves
-	-golint store # Don't fail on golint warnings themselves
+.PHONY: fmt
+fmt:
+	scripts/check_gofmt.sh
 
+.PHONY: get-deps
 get-deps:
+	go get github.com/go-redis/redis
 	go get github.com/gomodule/redigo/redis
 	go get github.com/hashicorp/golang-lru
 	go get golang.org/x/lint/golint
-	go get github.com/go-redis/redis
 
-.go-test:
+.PHONY: lint
+lint:
+	golint -set_exit_status ./...
+
+.PHONY: test
+test:
 	go test ./...
 
-.go-test-cover:
-	go test -coverprofile=throttled.coverage.out .
-	go test -coverprofile=store.coverage.out ./store
+.PHONY: vet
+vet:
+	go vet ./...

vendor/github.com/throttled/throttled/deprecated.go

@@ -5,41 +5,55 @@ import (
 	"time"
 )
 
-// DEPRECATED. Quota returns the number of requests allowed and the custom time window.
+// Quota returns the number of requests allowed and the custom time window.
+//
+// Deprecated: Use Rate and RateLimiter instead.
 func (q Rate) Quota() (int, time.Duration) {
 	return q.count, q.period * time.Duration(q.count)
 }
 
-// DEPRECATED. Q represents a custom quota.
+// Q represents a custom quota.
+//
+// Deprecated: Use Rate and RateLimiter instead.
 type Q struct {
 	Requests int
 	Window   time.Duration
 }
 
-// DEPRECATED. Quota returns the number of requests allowed and the custom time window.
+// Quota returns the number of requests allowed and the custom time window.
+//
+// Deprecated: Use Rate and RateLimiter instead.
 func (q Q) Quota() (int, time.Duration) {
 	return q.Requests, q.Window
 }
 
-// DEPRECATED. The Quota interface defines the method to implement to describe
+// The Quota interface defines the method to implement to describe
 // a time-window quota, as required by the RateLimit throttler.
+//
+// Deprecated: Use Rate and RateLimiter instead.
 type Quota interface {
 	// Quota returns a number of requests allowed, and a duration.
 	Quota() (int, time.Duration)
 }
 
-// DEPRECATED. Throttler is a backwards-compatible alias for HTTPLimiter.
+// Throttler is a backwards-compatible alias for HTTPLimiter.
+//
+// Deprecated: Use Rate and RateLimiter instead.
 type Throttler struct {
 	HTTPRateLimiter
 }
 
-// DEPRECATED. Throttle is an alias for HTTPLimiter#Limit
+// Throttle is an alias for HTTPLimiter#Limit
+//
+// Deprecated: Use Rate and RateLimiter instead.
 func (t *Throttler) Throttle(h http.Handler) http.Handler {
 	return t.RateLimit(h)
 }
 
-// DEPRECATED. RateLimit creates a Throttler that conforms to the given
+// RateLimit creates a Throttler that conforms to the given
 // rate limits
+//
+// Deprecated: Use Rate and RateLimiter instead.
 func RateLimit(q Quota, vary *VaryBy, store GCRAStore) *Throttler {
 	count, period := q.Quota()
 
@@ -67,7 +81,9 @@ func RateLimit(q Quota, vary *VaryBy, store GCRAStore) *Throttler {
 	}
 }
 
-// DEPRECATED. Store is an alias for GCRAStore
+// Store is an alias for GCRAStore
+//
+// Deprecated: Use Rate and RateLimiter instead.
 type Store interface {
 	GCRAStore
 }

vendor/github.com/throttled/throttled/rate.go

@@ -141,10 +141,10 @@ type GCRARateLimiter struct {
 // only permits one request per second with no tolerance for bursts.
 func NewGCRARateLimiter(st GCRAStore, quota RateQuota) (*GCRARateLimiter, error) {
 	if quota.MaxBurst < 0 {
-		return nil, fmt.Errorf("Invalid RateQuota %#v. MaxBurst must be greater than zero.", quota)
+		return nil, fmt.Errorf("invalid RateQuota %#v; MaxBurst must be greater than zero", quota)
 	}
 	if quota.MaxRate.period <= 0 {
-		return nil, fmt.Errorf("Invalid RateQuota %#v. MaxRate must be greater than zero.", quota)
+		return nil, fmt.Errorf("invalid RateQuota %#v; MaxRate must be greater than zero", quota)
 	}
 
 	return &GCRARateLimiter{