From 275fcb17d7b19e0f5dce15a42ab2cef00877bac7 Mon Sep 17 00:00:00 2001
From: Sebastien cante <seb@mx51.io>
Date: Mon, 14 Sep 2020 17:40:44 +1000
Subject: [PATCH 01/63] initial draft for uds support

---
 datadog/client.go      | 96 ++++++++++++++++++++++++++++--------------
 datadog/client_test.go | 62 +++++++++++++++++++++++++--
 datadog/server_test.go | 70 +++++++++++++++++++++++++++++-
 3 files changed, 191 insertions(+), 37 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index 3ac7afc..8bf0753 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -4,8 +4,9 @@ import (
 	"bytes"
 	"io"
 	"log"
-	"net"
+	"net/url"
 	"os"
+	"strings"
 	"syscall"
 	"time"
 
@@ -14,7 +15,7 @@ import (
 
 const (
 	// DefaultAddress is the default address to which the datadog client tries
-	// to connect to.
+	// to connect to. By default is connects to UDP
 	DefaultAddress = "localhost:8125"
 
 	// DefaultBufferSize is the default size for batches of metrics sent to
@@ -37,6 +38,8 @@ var (
 // The ClientConfig type is used to configure datadog clients.
 type ClientConfig struct {
 	// Address of the datadog database to send metrics to.
+	// UDP: host:port
+	// UDS: unixgram://dir/file.ext
 	Address string
 
 	// Maximum size of batch of events sent to datadog.
@@ -89,15 +92,24 @@ func NewClientWith(config ClientConfig) *Client {
 		},
 	}
 
-	conn, bufferSize, err := dial(config.Address, config.BufferSize)
+	w, err := newWriter(config.Address)
 	if err != nil {
-		log.Printf("stats/datadog: %s", err)
+		log.Printf("stats/datadog: unable to create writer %s", err)
+		c.err = err
+		w = &noopWriter{}
 	}
 
-	c.conn, c.err, c.bufferSize = conn, err, bufferSize
-	c.buffer.BufferSize = bufferSize
+	newBufSize, err := w.CalcBufferSize(config.BufferSize)
+	if err != nil {
+		log.Printf("stats/datadog: unable to calc buffer size from connn. Defaulting to a buffer of size %d - %v\n", DefaultBufferSize, err)
+		newBufSize = DefaultBufferSize
+	}
+	c.bufferSize = newBufSize
+	c.buffer.BufferSize = newBufSize
+
+	c.serializer.w = w
 	c.buffer.Serializer = &c.serializer
-	log.Printf("stats/datadog: sending metrics with a buffer of size %d B", bufferSize)
+	log.Printf("stats/datadog: sending metrics with a buffer of size %d B", c.serializer.bufferSize)
 	return c
 }
 
@@ -124,7 +136,7 @@ func (c *Client) Close() error {
 }
 
 type serializer struct {
-	conn       net.Conn
+	w          io.WriteCloser
 	bufferSize int
 	filters    map[string]struct{}
 }
@@ -137,12 +149,9 @@ func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Mea
 }
 
 func (s *serializer) Write(b []byte) (int, error) {
-	if s.conn == nil {
-		return 0, io.ErrClosedPipe
-	}
 
 	if len(b) <= s.bufferSize {
-		return s.conn.Write(b)
+		return s.w.Write(b)
 	}
 
 	// When the serialized metrics are larger than the configured socket buffer
@@ -167,8 +176,7 @@ func (s *serializer) Write(b []byte) (int, error) {
 			}
 			splitIndex += i + 1
 		}
-
-		c, err := s.conn.Write(b[:splitIndex])
+		c, err := s.w.Write(b[:splitIndex])
 		if err != nil {
 			return n + c, err
 		}
@@ -181,33 +189,18 @@ func (s *serializer) Write(b []byte) (int, error) {
 }
 
 func (s *serializer) close() {
-	if s.conn != nil {
-		s.conn.Close()
-	}
+	s.w.Close()
 }
 
-func dial(address string, sizehint int) (conn net.Conn, bufsize int, err error) {
-	var f *os.File
-
-	if conn, err = net.Dial("udp", address); err != nil {
-		return
-	}
-
-	if f, err = conn.(*net.UDPConn).File(); err != nil {
-		conn.Close()
-		return
-	}
-	defer f.Close()
+func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	fd := int(f.Fd())
-
 	// The kernel refuses to send UDP datagrams that are larger than the size of
 	// the size of the socket send buffer. To maximize the number of metrics
 	// sent in one batch we attempt to attempt to adjust the kernel buffer size
 	// to accept larger datagrams, or fallback to the default socket buffer size
 	// if it failed.
 	if bufsize, err = syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF); err != nil {
-		conn.Close()
-		return
+		return 0, err
 	}
 
 	// The kernel applies a 2x factor on the socket buffer size, only half of it
@@ -244,3 +237,42 @@ func dial(address string, sizehint int) (conn net.Conn, bufsize int, err error)
 	syscall.SetNonblock(fd, true)
 	return
 }
+
+type ddWriter interface {
+	io.WriteCloser
+	CalcBufferSize(desiredBufSize int) (int, error)
+}
+
+func newWriter(addr string) (ddWriter, error) {
+	if strings.HasPrefix(addr, "unixgram://") ||
+		strings.HasPrefix(addr, "udp://") {
+		u, err := url.Parse(addr)
+		if err != nil {
+			return nil, err
+		}
+		switch u.Scheme {
+		case "unixgram":
+			return newUDSWriter(u.Path)
+		case "udp":
+			return newUDPWriter(u.Path)
+		}
+	}
+	// default assume addr host:port to use UDP
+	return newUDPWriter(addr)
+}
+
+// noopWriter is a writer that does not do anything
+type noopWriter struct{}
+
+// Write writes nothing
+func (w *noopWriter) Write(data []byte) (int, error) {
+	return 0, nil
+}
+
+func (w *noopWriter) Close() error {
+	return nil
+}
+
+func (w *noopWriter) CalcBufferSize(sizehint int) (int, error) {
+	return sizehint, nil
+}
diff --git a/datadog/client_test.go b/datadog/client_test.go
index 3238140..29363c0 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
-func TestClient(t *testing.T) {
+func TestClient_UDP(t *testing.T) {
 	client := NewClient(DefaultAddress)
 
 	for i := 0; i != 1000; i++ {
@@ -35,7 +35,29 @@ func TestClient(t *testing.T) {
 	}
 }
 
-func TestClientWriteLargeMetrics(t *testing.T) {
+func TestClient_UDS(t *testing.T) {
+	client := NewClient("unixgram://do-not-exist")
+
+	for i := 0; i != 1000; i++ {
+		client.HandleMeasures(time.Time{}, stats.Measure{
+			Name: "request",
+			Fields: []stats.Field{
+				{Name: "count", Value: stats.ValueOf(5)},
+				{Name: "rtt", Value: stats.ValueOf(100 * time.Millisecond)},
+			},
+			Tags: []stats.Tag{
+				stats.T("answer", "42"),
+				stats.T("hello", "world"),
+			},
+		})
+	}
+
+	if err := client.Close(); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestClientWriteLargeMetrics_UDP(t *testing.T) {
 	const data = `main.http.error.count:0|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity
 main.http.message.count:1|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
 main.http.message.header.size:2|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
@@ -51,7 +73,7 @@ main.http.rtt.seconds:0.001215296|h|#http_req_content_charset:,http_req_content_
 	count := int32(0)
 	expect := int32(strings.Count(data, "\n"))
 
-	addr, closer := startTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
+	addr, closer := startUDPTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
 		atomic.AddInt32(&count, 1)
 	}))
 	defer closer.Close()
@@ -69,6 +91,40 @@ main.http.rtt.seconds:0.001215296|h|#http_req_content_charset:,http_req_content_
 	}
 }
 
+func TestClientWriteLargeMetrics_UDS(t *testing.T) {
+	const data = `main.http.error.count:0|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity
+main.http.message.count:1|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
+main.http.message.header.size:2|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
+main.http.message.header.bytes:240|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
+main.http.message.body.bytes:0|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
+main.http.message.count:1|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,http_res_content_charset:,http_res_content_endoing:,http_res_content_type:application/json,http_res_protocol:HTTP/1.1,http_res_server:,http_res_transfer_encoding:identity,http_res_upgrade:,http_status:200,http_status_bucket:2xx,operation:write,type:response
+main.http.message.header.size:1|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,http_res_content_charset:,http_res_content_endoing:,http_res_content_type:application/json,http_res_protocol:HTTP/1.1,http_res_server:,http_res_transfer_encoding:identity,http_res_upgrade:,http_status:200,http_status_bucket:2xx,operation:write,type:response
+main.http.message.header.bytes:70|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,http_res_content_charset:,http_res_content_endoing:,http_res_content_type:application/json,http_res_protocol:HTTP/1.1,http_res_server:,http_res_transfer_encoding:identity,http_res_upgrade:,http_status:200,http_status_bucket:2xx,operation:write,type:response
+main.http.message.body.bytes:839|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,http_res_content_charset:,http_res_content_endoing:,http_res_content_type:application/json,http_res_protocol:HTTP/1.1,http_res_server:,http_res_transfer_encoding:identity,http_res_upgrade:,http_status:200,http_status_bucket:2xx,operation:write,type:response
+main.http.rtt.seconds:0.001215296|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,http_res_content_charset:,http_res_content_endoing:,http_res_content_type:application/json,http_res_protocol:HTTP/1.1,http_res_server:,http_res_transfer_encoding:identity,http_res_upgrade:,http_status:200,http_status_bucket:2xx,operation:write,type:response
+`
+
+	count := int32(0)
+	expect := int32(strings.Count(data, "\n"))
+
+	addr, closer := startUDSTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
+		atomic.AddInt32(&count, 1)
+	}))
+	defer closer.Close()
+
+	client := NewClient("unixgram://" + addr)
+
+	if _, err := client.Write([]byte(data)); err != nil {
+		t.Error(err)
+	}
+
+	time.Sleep(100 * time.Millisecond)
+
+	if n := atomic.LoadInt32(&count); n != expect {
+		t.Error("bad metric count:", n)
+	}
+}
+
 func BenchmarkClient(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 
diff --git a/datadog/server_test.go b/datadog/server_test.go
index 0030a6b..11d58df 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -2,7 +2,10 @@ package datadog
 
 import (
 	"io"
+	"io/ioutil"
 	"net"
+	"os"
+	"path/filepath"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -17,7 +20,7 @@ func TestServer(t *testing.T) {
 	b := uint32(0)
 	c := uint32(0)
 
-	addr, closer := startTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
+	addr, closer := startUDPTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
 		switch m.Name {
 		case "datadog.test.A":
 			atomic.AddUint32(&a, uint32(m.Value))
@@ -68,7 +71,7 @@ func TestServer(t *testing.T) {
 	}
 }
 
-func startTestServer(t *testing.T, handler Handler) (addr string, closer io.Closer) {
+func startUDPTestServer(t *testing.T, handler Handler) (addr string, closer io.Closer) {
 	conn, err := net.ListenPacket("udp", "127.0.0.1:0")
 
 	if err != nil {
@@ -80,3 +83,66 @@ func startTestServer(t *testing.T, handler Handler) (addr string, closer io.Clos
 
 	return conn.LocalAddr().String(), conn
 }
+
+// startUDSTestServerWithSocketFile starts a UDS server with a given socket file
+func startUDSTestServerWithSocketFile(t *testing.T, socketPath string, handler Handler) (closer io.Closer) {
+	udsAddr, err := net.ResolveUnixAddr("unixgram", socketPath)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	conn, err := net.ListenUnixgram("unixgram", udsAddr)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	go Serve(conn, handler)
+
+	return &testUnixgramServer{
+		UnixConn:     conn,
+		pathToDelete: socketPath,
+	}
+}
+
+// startUDSTestServer starts a Unix domain socket server with a random tmp file for the socket file
+func startUDSTestServer(t *testing.T, handler Handler) (socketPath string, closer io.Closer) {
+	dir, err := ioutil.TempDir("", "socket")
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	socketPath = filepath.Join(dir, "dsd.socket")
+
+	udsAddr, err := net.ResolveUnixAddr("unixgram", socketPath)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	conn, err := net.ListenUnixgram("unixgram", udsAddr)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	ts := testUnixgramServer{
+		UnixConn:     conn,
+		pathToDelete: dir, // so we delete any tmp dir we created
+	}
+
+	go Serve(conn, handler)
+	return socketPath, &ts
+}
+
+type testUnixgramServer struct {
+	*net.UnixConn
+	pathToDelete string
+}
+
+func (ts *testUnixgramServer) Close() error {
+	os.RemoveAll(ts.pathToDelete) // clean up
+	return ts.UnixConn.Close()
+}

From 54c9f6ed35c9e57d10dde149de55188a2eb924c3 Mon Sep 17 00:00:00 2001
From: Sebastien cante <seb@mx51.io>
Date: Mon, 14 Sep 2020 17:40:51 +1000
Subject: [PATCH 02/63] initial draft for uds support

---
 datadog/udp.go      |  42 +++++++++++++++++
 datadog/uds.go      | 108 ++++++++++++++++++++++++++++++++++++++++++++
 datadog/uds_test.go |  55 ++++++++++++++++++++++
 3 files changed, 205 insertions(+)
 create mode 100644 datadog/udp.go
 create mode 100644 datadog/uds.go
 create mode 100644 datadog/uds_test.go

diff --git a/datadog/udp.go b/datadog/udp.go
new file mode 100644
index 0000000..33d88aa
--- /dev/null
+++ b/datadog/udp.go
@@ -0,0 +1,42 @@
+package datadog
+
+import "net"
+
+// udsWriter is an internal class wrapping around management of UDS connection
+type udpWriter struct {
+	conn net.Conn
+}
+
+// newUDSWriter returns a pointer to a new udpWriter given a socket file path as addr.
+func newUDPWriter(addr string) (*udpWriter, error) {
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := net.DialUDP("udp", nil, udpAddr)
+	if err != nil {
+		return nil, err
+	}
+	return &udpWriter{conn: conn}, nil
+
+}
+
+// Write data to the UDS connection with write timeout and minimal error handling:
+// create the connection if nil, and destroy it if the statsd server has disconnected
+func (w *udpWriter) Write(data []byte) (int, error) {
+	return w.conn.Write(data)
+}
+
+func (w *udpWriter) Close() error {
+	return w.conn.Close()
+}
+
+func (w *udpWriter) CalcBufferSize(sizehint int) (int, error) {
+	f, err := w.conn.(*net.UDPConn).File()
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	return bufSizeFromFD(f, sizehint)
+}
diff --git a/datadog/uds.go b/datadog/uds.go
new file mode 100644
index 0000000..29b71b1
--- /dev/null
+++ b/datadog/uds.go
@@ -0,0 +1,108 @@
+package datadog
+
+import (
+	"net"
+	"sync"
+	"time"
+)
+
+// UDSTimeout holds the default timeout for UDS socket writes, as they can get
+// blocking when the receiving buffer is full.
+// same value as in official datadog client: https://github.com/DataDog/datadog-go/blob/master/statsd/uds.go#L13
+const defaultUDSTimeout = 1 * time.Millisecond
+
+// udsWriter is an internal class wrapping around management of UDS connection
+// credits to Datadog team: https://github.com/DataDog/datadog-go/blob/master/statsd/uds.go
+type udsWriter struct {
+	// Address to send metrics to, needed to allow reconnection on error
+	addr net.Addr
+
+	// Established connection object, or nil if not connected yet
+	conn   net.Conn
+	connMu sync.RWMutex // so that we can replace the failing conn on error
+
+	// write timeout
+	writeTimeout time.Duration
+}
+
+// newUDSWriter returns a pointer to a new udsWriter given a socket file path as addr.
+func newUDSWriter(addr string) (*udsWriter, error) {
+	udsAddr, err := net.ResolveUnixAddr("unixgram", addr)
+	if err != nil {
+		return nil, err
+	}
+	// Defer connection to first Write
+	writer := &udsWriter{addr: udsAddr, conn: nil, writeTimeout: defaultUDSTimeout}
+	return writer, nil
+}
+
+// Write data to the UDS connection with write timeout and minimal error handling:
+// create the connection if nil, and destroy it if the statsd server has disconnected
+func (w *udsWriter) Write(data []byte) (int, error) {
+	conn, err := w.ensureConnection()
+	if err != nil {
+		return 0, err
+	}
+
+	conn.SetWriteDeadline(time.Now().Add(w.writeTimeout))
+	n, e := conn.Write(data)
+	if err, isNetworkErr := e.(net.Error); err != nil && (!isNetworkErr || !err.Temporary()) {
+		// Statsd server disconnected, retry connecting at next packet
+		w.unsetConnection()
+		return 0, e
+	}
+	return n, e
+}
+
+func (w *udsWriter) Close() error {
+	if w.conn != nil {
+		return w.conn.Close()
+	}
+	return nil
+}
+
+func (w *udsWriter) CalcBufferSize(sizehint int) (int, error) {
+	conn, err := w.ensureConnection()
+	if err != nil {
+		return 0, err
+	}
+	f, err := conn.(*net.UnixConn).File()
+	if err != nil {
+		w.unsetConnection()
+		return 0, err
+	}
+	defer f.Close()
+
+	return bufSizeFromFD(f, sizehint)
+}
+
+func (w *udsWriter) ensureConnection() (net.Conn, error) {
+	// Check if we've already got a socket we can use
+	w.connMu.RLock()
+	currentConn := w.conn
+	w.connMu.RUnlock()
+
+	if currentConn != nil {
+		return currentConn, nil
+	}
+
+	// Looks like we might need to connect - try again with write locking.
+	w.connMu.Lock()
+	defer w.connMu.Unlock()
+	if w.conn != nil {
+		return w.conn, nil
+	}
+
+	newConn, err := net.Dial(w.addr.Network(), w.addr.String())
+	if err != nil {
+		return nil, err
+	}
+	w.conn = newConn
+	return newConn, nil
+}
+
+func (w *udsWriter) unsetConnection() {
+	w.connMu.Lock()
+	defer w.connMu.Unlock()
+	w.conn = nil
+}
diff --git a/datadog/uds_test.go b/datadog/uds_test.go
new file mode 100644
index 0000000..1030edb
--- /dev/null
+++ b/datadog/uds_test.go
@@ -0,0 +1,55 @@
+package datadog
+
+import (
+	"io/ioutil"
+	"net"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+)
+
+func TestUDSReconnectWhenConnRefused(t *testing.T) {
+	dir, err := ioutil.TempDir("", "socket")
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	socketPath := filepath.Join(dir, "dsd.socket")
+	count := int32(0)
+	closerServer1 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {
+		atomic.AddInt32(&count, 1)
+	}))
+	defer closerServer1.Close()
+
+	client := NewClientWith(ClientConfig{
+		Address:    "unixgram://" + socketPath,
+		BufferSize: 1, // small buffer to force write to unix socket for each measure
+	})
+
+	measure := `main.http.error.count:0|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity
+`
+
+	_, err = client.Write([]byte(measure))
+	if err != nil {
+		t.Errorf("unable to write data %v", err)
+	}
+
+	closerServer1.Close()
+
+	_, err = client.Write([]byte(measure))
+	if err == nil {
+		t.Errorf("invalid error expected none, got %v", err)
+	}
+	// restart UDS server with same socket file
+	closerServer2 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {
+		atomic.AddInt32(&count, 1)
+	}))
+
+	defer closerServer2.Close()
+
+	_, err = client.Write([]byte(measure))
+	if err != nil {
+		t.Errorf("unable to write data but should be able to as the client should reconnect %v", err)
+	}
+
+}

From 91731bf3e8e9c034066a67f018b1719737f165c3 Mon Sep 17 00:00:00 2001
From: Sebastien cante <seb@mx51.io>
Date: Mon, 14 Sep 2020 17:50:03 +1000
Subject: [PATCH 03/63] review pr

---
 datadog/client.go      | 8 ++++----
 datadog/server_test.go | 2 +-
 datadog/udp.go         | 6 ++----
 datadog/uds_test.go    | 2 +-
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index 8bf0753..a007092 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -15,7 +15,7 @@ import (
 
 const (
 	// DefaultAddress is the default address to which the datadog client tries
-	// to connect to. By default is connects to UDP
+	// to connect to. By default it connects to UDP
 	DefaultAddress = "localhost:8125"
 
 	// DefaultBufferSize is the default size for batches of metrics sent to
@@ -101,7 +101,7 @@ func NewClientWith(config ClientConfig) *Client {
 
 	newBufSize, err := w.CalcBufferSize(config.BufferSize)
 	if err != nil {
-		log.Printf("stats/datadog: unable to calc buffer size from connn. Defaulting to a buffer of size %d - %v\n", DefaultBufferSize, err)
+		log.Printf("stats/datadog: unable to calc writer's buffer size. Defaulting to a buffer of size %d - %v\n", DefaultBufferSize, err)
 		newBufSize = DefaultBufferSize
 	}
 	c.bufferSize = newBufSize
@@ -109,7 +109,7 @@ func NewClientWith(config ClientConfig) *Client {
 
 	c.serializer.w = w
 	c.buffer.Serializer = &c.serializer
-	log.Printf("stats/datadog: sending metrics with a buffer of size %d B", c.serializer.bufferSize)
+	log.Printf("stats/datadog: sending metrics with a buffer of size %d B", newBufSize)
 	return c
 }
 
@@ -200,7 +200,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	// to accept larger datagrams, or fallback to the default socket buffer size
 	// if it failed.
 	if bufsize, err = syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF); err != nil {
-		return 0, err
+		return
 	}
 
 	// The kernel applies a 2x factor on the socket buffer size, only half of it
diff --git a/datadog/server_test.go b/datadog/server_test.go
index 11d58df..0f494bf 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -106,7 +106,7 @@ func startUDSTestServerWithSocketFile(t *testing.T, socketPath string, handler H
 	}
 }
 
-// startUDSTestServer starts a Unix domain socket server with a random tmp file for the socket file
+// startUDSTestServer starts a Unix domain socket server with a random socket file
 func startUDSTestServer(t *testing.T, handler Handler) (socketPath string, closer io.Closer) {
 	dir, err := ioutil.TempDir("", "socket")
 	if err != nil {
diff --git a/datadog/udp.go b/datadog/udp.go
index 33d88aa..ff2d4cc 100644
--- a/datadog/udp.go
+++ b/datadog/udp.go
@@ -2,12 +2,11 @@ package datadog
 
 import "net"
 
-// udsWriter is an internal class wrapping around management of UDS connection
 type udpWriter struct {
 	conn net.Conn
 }
 
-// newUDSWriter returns a pointer to a new udpWriter given a socket file path as addr.
+// newUDPWriter returns a pointer to a new newUDPWriter given a socket file path as addr.
 func newUDPWriter(addr string) (*udpWriter, error) {
 	udpAddr, err := net.ResolveUDPAddr("udp", addr)
 	if err != nil {
@@ -21,8 +20,7 @@ func newUDPWriter(addr string) (*udpWriter, error) {
 
 }
 
-// Write data to the UDS connection with write timeout and minimal error handling:
-// create the connection if nil, and destroy it if the statsd server has disconnected
+// Write data to the UDP connection
 func (w *udpWriter) Write(data []byte) (int, error) {
 	return w.conn.Write(data)
 }
diff --git a/datadog/uds_test.go b/datadog/uds_test.go
index 1030edb..4adf3cf 100644
--- a/datadog/uds_test.go
+++ b/datadog/uds_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 )
 
-func TestUDSReconnectWhenConnRefused(t *testing.T) {
+func TestUDSReconnectsWhenConnRefused(t *testing.T) {
 	dir, err := ioutil.TempDir("", "socket")
 	if err != nil {
 		t.Error(err)

From 8a1ca58d26abf25f655ac513ff62a9494e8f0a10 Mon Sep 17 00:00:00 2001
From: Sebastien cante <seb@mx51.io>
Date: Mon, 14 Sep 2020 18:07:06 +1000
Subject: [PATCH 04/63] review pr

---
 datadog/client.go      |  2 +-
 datadog/server_test.go |  2 +-
 datadog/uds_test.go    | 16 +++++-----------
 3 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index a007092..f8608a8 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -261,7 +261,7 @@ func newWriter(addr string) (ddWriter, error) {
 	return newUDPWriter(addr)
 }
 
-// noopWriter is a writer that does not do anything
+// noopWriter is a writer that does nothing
 type noopWriter struct{}
 
 // Write writes nothing
diff --git a/datadog/server_test.go b/datadog/server_test.go
index 0f494bf..6133c3b 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -106,7 +106,7 @@ func startUDSTestServerWithSocketFile(t *testing.T, socketPath string, handler H
 	}
 }
 
-// startUDSTestServer starts a Unix domain socket server with a random socket file
+// startUDSTestServer starts a UDS server with server with a random socket file internally generated
 func startUDSTestServer(t *testing.T, handler Handler) (socketPath string, closer io.Closer) {
 	dir, err := ioutil.TempDir("", "socket")
 	if err != nil {
diff --git a/datadog/uds_test.go b/datadog/uds_test.go
index 4adf3cf..44709c6 100644
--- a/datadog/uds_test.go
+++ b/datadog/uds_test.go
@@ -4,7 +4,6 @@ import (
 	"io/ioutil"
 	"net"
 	"path/filepath"
-	"sync/atomic"
 	"testing"
 )
 
@@ -15,15 +14,13 @@ func TestUDSReconnectsWhenConnRefused(t *testing.T) {
 		t.FailNow()
 	}
 	socketPath := filepath.Join(dir, "dsd.socket")
-	count := int32(0)
-	closerServer1 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {
-		atomic.AddInt32(&count, 1)
-	}))
+
+	closerServer1 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {}))
 	defer closerServer1.Close()
 
 	client := NewClientWith(ClientConfig{
 		Address:    "unixgram://" + socketPath,
-		BufferSize: 1, // small buffer to force write to unix socket for each measure
+		BufferSize: 1, // small buffer to force write to unix socket for each measure written
 	})
 
 	measure := `main.http.error.count:0|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity
@@ -38,13 +35,10 @@ func TestUDSReconnectsWhenConnRefused(t *testing.T) {
 
 	_, err = client.Write([]byte(measure))
 	if err == nil {
-		t.Errorf("invalid error expected none, got %v", err)
+		t.Errorf("got no error but expected one as the connection should be refused as we closed the server")
 	}
 	// restart UDS server with same socket file
-	closerServer2 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {
-		atomic.AddInt32(&count, 1)
-	}))
-
+	closerServer2 := startUDSTestServerWithSocketFile(t, socketPath, HandlerFunc(func(m Metric, _ net.Addr) {}))
 	defer closerServer2.Close()
 
 	_, err = client.Write([]byte(measure))

From 969fe44d97dbf97bf959bbdcf05fd305f6cfa033 Mon Sep 17 00:00:00 2001
From: Sebastien cante <seb@mx51.io>
Date: Mon, 14 Sep 2020 20:08:03 +1000
Subject: [PATCH 05/63] more docs

---
 datadog/client.go      | 6 ++++--
 datadog/server_test.go | 3 ++-
 datadog/uds.go         | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index f8608a8..df64a2d 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -15,7 +15,7 @@ import (
 
 const (
 	// DefaultAddress is the default address to which the datadog client tries
-	// to connect to. By default it connects to UDP
+	// to connect to.
 	DefaultAddress = "localhost:8125"
 
 	// DefaultBufferSize is the default size for batches of metrics sent to
@@ -38,7 +38,7 @@ var (
 // The ClientConfig type is used to configure datadog clients.
 type ClientConfig struct {
 	// Address of the datadog database to send metrics to.
-	// UDP: host:port
+	// UDP: host:port (default)
 	// UDS: unixgram://dir/file.ext
 	Address string
 
@@ -269,10 +269,12 @@ func (w *noopWriter) Write(data []byte) (int, error) {
 	return 0, nil
 }
 
+// Close is a noop close
 func (w *noopWriter) Close() error {
 	return nil
 }
 
+// CalcBufferSize returns the sizehint
 func (w *noopWriter) CalcBufferSize(sizehint int) (int, error) {
 	return sizehint, nil
 }
diff --git a/datadog/server_test.go b/datadog/server_test.go
index 6133c3b..27b483b 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -106,8 +106,9 @@ func startUDSTestServerWithSocketFile(t *testing.T, socketPath string, handler H
 	}
 }
 
-// startUDSTestServer starts a UDS server with server with a random socket file internally generated
+// startUDSTestServer starts a UDS server with a random socket file internally generated
 func startUDSTestServer(t *testing.T, handler Handler) (socketPath string, closer io.Closer) {
+	// generate a random dir
 	dir, err := ioutil.TempDir("", "socket")
 	if err != nil {
 		t.Error(err)
diff --git a/datadog/uds.go b/datadog/uds.go
index 29b71b1..a2b7e08 100644
--- a/datadog/uds.go
+++ b/datadog/uds.go
@@ -31,7 +31,7 @@ func newUDSWriter(addr string) (*udsWriter, error) {
 	if err != nil {
 		return nil, err
 	}
-	// Defer connection to first Write
+	// Defer connection to first read/write
 	writer := &udsWriter{addr: udsAddr, conn: nil, writeTimeout: defaultUDSTimeout}
 	return writer, nil
 }

From 46084cb3445168ea9f1d8a57f39f1f8541257922 Mon Sep 17 00:00:00 2001
From: Alan Braithwaite <alan@segment.com>
Date: Mon, 4 Jan 2021 13:10:36 -0500
Subject: [PATCH 06/63] fixes #124

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7ebe2a7..30d975c 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ Installation
 ------------
 
 ```
-go get github.com/segmentio/stats
+go get github.com/segmentio/stats/v4
 ```
 
 Migration to v4

From b2bb979116aac0de847e160aaf00590abda56453 Mon Sep 17 00:00:00 2001
From: Tyson Mote <tyson@segment.com>
Date: Mon, 8 Feb 2021 21:12:57 -0800
Subject: [PATCH 07/63] tagsBuffer: Sort only if needed

This is the codepath used by Report() / ReportAt(), which is the fast path for
reporting stats in v4. Skipping the sort saves us some work:

    benchmark                              old ns/op     new ns/op     delta
    BenchmarkTagsBufferSortSorted-12       107           49.3          -53.93%
    BenchmarkTagsBufferSortUnsorted-12     270           271           +0.37%

While users are less likely to have already-sorted stat tags in this case
(because the tagsBuffer tag slice is built on every call and doesn't retain its
sort between calls the way that you would retain sorted engine tags if you were
calling stats.Incr() without tags often), it can show up in benchmarks and guide
users toward this little cheat by passing in their tags in sorted order.
---
 tag.go      |  4 +++-
 tag_test.go | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/tag.go b/tag.go
index f47af42..a3fdcaa 100644
--- a/tag.go
+++ b/tag.go
@@ -100,7 +100,9 @@ func (b *tagsBuffer) reset() {
 }
 
 func (b *tagsBuffer) sort() {
-	sort.Sort(&b.tags)
+	if !TagsAreSorted(b.tags) {
+		SortTags(b.tags)
+	}
 }
 
 func (b *tagsBuffer) append(tags ...Tag) {
diff --git a/tag_test.go b/tag_test.go
index 887b17a..43f98a6 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -220,3 +220,51 @@ func BenchmarkSortTagsMany(b *testing.B) {
 		SortTags(t1)
 	}
 }
+
+func BenchmarkTagsBufferSortSorted(b *testing.B) {
+	tags := []Tag{
+		{"A", ""},
+		{"B", ""},
+		{"C", ""},
+		{"answer", "42"},
+		{"answer", "42"},
+		{"hello", "world"},
+		{"hello", "world"},
+		{"some long tag name", "!"},
+		{"some long tag name", "!"},
+		{"some longer tag name", "1234"},
+	}
+
+	buf := tagsBuffer{
+		tags: make([]Tag, len(tags)),
+	}
+
+	for i := 0; i < b.N; i++ {
+		copy(buf.tags, tags)
+		buf.sort()
+	}
+}
+
+func BenchmarkTagsBufferSortUnsorted(b *testing.B) {
+	tags := []Tag{
+		{"some long tag name", "!"},
+		{"some longer tag name", "1234"},
+		{"hello", "world"},
+		{"C", ""},
+		{"answer", "42"},
+		{"hello", "world"},
+		{"B", ""},
+		{"answer", "42"},
+		{"some long tag name", "!"},
+		{"A", ""},
+	}
+
+	buf := tagsBuffer{
+		tags: make([]Tag, len(tags)),
+	}
+
+	for i := 0; i < b.N; i++ {
+		copy(buf.tags, tags)
+		buf.sort()
+	}
+}

From dee5f71b021341036d291f31a29f9f91d214e585 Mon Sep 17 00:00:00 2001
From: Ray Jenkins <ray@segment.com>
Date: Thu, 11 Feb 2021 13:04:22 -0600
Subject: [PATCH 08/63] Largely cleanup for fmt and linter warnings. (#127)

---
 context_test.go               |  2 +-
 datadog/client.go             |  2 +-
 datadog/event.go              |  2 ++
 datadog/metric.go             |  1 +
 engine.go                     |  8 ++++----
 field.go                      |  1 +
 grafana/grafanatest/query.go  |  2 +-
 grafana/handler.go            |  3 +--
 grafana/query.go              |  2 ++
 grafana/search.go             |  2 +-
 handler.go                    |  2 +-
 httpstats/context_test.go     |  2 +-
 httpstats/metrics_test.go     | 14 +++++++-------
 influxdb/client.go            |  2 +-
 netstats/conn.go              |  2 +-
 netstats/listener.go          |  2 ++
 procstats/collector.go        | 10 ++++++++--
 procstats/delaystats.go       |  7 +++++--
 procstats/delaystats_linux.go |  4 ++--
 procstats/error_test.go       |  4 ++--
 procstats/linux/cgroup.go     | 17 +++++++++++++----
 procstats/linux/error_test.go |  4 ++--
 procstats/linux/files.go      |  3 +++
 procstats/linux/limits.go     |  8 +++++---
 procstats/linux/memory.go     |  1 +
 procstats/linux/sched.go      |  5 +++--
 procstats/linux/stat.go       |  8 ++++++--
 procstats/linux/statm.go      |  3 +++
 procstats/proc.go             | 12 +++++++++---
 procstats/proc_linux.go       |  4 ++--
 prometheus/handler.go         |  2 +-
 prometheus/handler_test.go    |  4 ++--
 prometheus/label.go           | 26 +++++++++++++-------------
 prometheus/metric_test.go     | 16 ++++++++--------
 statstest/handler.go          |  3 +++
 value.go                      | 30 ++++++++++++++++++------------
 veneur/client.go              |  6 ++++--
 37 files changed, 141 insertions(+), 85 deletions(-)

diff --git a/context_test.go b/context_test.go
index 02b530e..c2c6993 100644
--- a/context_test.go
+++ b/context_test.go
@@ -17,7 +17,7 @@ func TestContextTags(t *testing.T) {
 	assert.Equal(t, 0, len(ContextTags(x)), "Original context should have no tags (because no context with key)")
 
 	// create a child context which creates a child context
-	z := context.WithValue(y, "not", "important")
+	z := context.WithValue(y, interface{}("not"), "important")
 	assert.Equal(t, 1, len(ContextTags(z)), "We should still be able to see original tags")
 
 	// Add tags to the child context's reference to the original tag slice
diff --git a/datadog/client.go b/datadog/client.go
index df64a2d..b1feb17 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -113,7 +113,7 @@ func NewClientWith(config ClientConfig) *Client {
 	return c
 }
 
-// HandleMetric satisfies the stats.Handler interface.
+// HandleMeasures satisfies the stats.Handler interface.
 func (c *Client) HandleMeasures(time time.Time, measures ...stats.Measure) {
 	c.buffer.HandleMeasures(time, measures...)
 }
diff --git a/datadog/event.go b/datadog/event.go
index 4ad5886..b11d719 100644
--- a/datadog/event.go
+++ b/datadog/event.go
@@ -10,6 +10,7 @@ import (
 // priority levels.
 type EventPriority string
 
+// Event Priorities.
 const (
 	EventPriorityNormal EventPriority = "normal"
 	EventPriorityLow    EventPriority = "low"
@@ -19,6 +20,7 @@ const (
 // allert types.
 type EventAlertType string
 
+// Event Alert Types.
 const (
 	EventAlertTypeError   EventAlertType = "error"
 	EventAlertTypeWarning EventAlertType = "warning"
diff --git a/datadog/metric.go b/datadog/metric.go
index 4fb2c74..5131e37 100644
--- a/datadog/metric.go
+++ b/datadog/metric.go
@@ -11,6 +11,7 @@ import (
 // metric types upported by datadog.
 type MetricType string
 
+// Metric Types.
 const (
 	Counter   MetricType = "c"
 	Gauge     MetricType = "g"
diff --git a/engine.go b/engine.go
index 0d2e5ac..292b504 100644
--- a/engine.go
+++ b/engine.go
@@ -84,7 +84,7 @@ func (eng *Engine) Incr(name string, tags ...Tag) {
 	eng.Add(name, 1, tags...)
 }
 
-// Incr increments by one the counter identified by name and tags.
+// IncrAt increments by one the counter identified by name and tags.
 func (eng *Engine) IncrAt(time time.Time, name string, tags ...Tag) {
 	eng.AddAt(time, name, 1, tags...)
 }
@@ -94,7 +94,7 @@ func (eng *Engine) Add(name string, value interface{}, tags ...Tag) {
 	eng.measure(time.Now(), name, value, Counter, tags...)
 }
 
-// Add increments by value the counter identified by name and tags.
+// AddAt increments by value the counter identified by name and tags.
 func (eng *Engine) AddAt(t time.Time, name string, value interface{}, tags ...Tag) {
 	eng.measure(t, name, value, Counter, tags...)
 }
@@ -104,7 +104,7 @@ func (eng *Engine) Set(name string, value interface{}, tags ...Tag) {
 	eng.measure(time.Now(), name, value, Gauge, tags...)
 }
 
-// Set sets to value the gauge identified by name and tags.
+// SetAt sets to value the gauge identified by name and tags.
 func (eng *Engine) SetAt(t time.Time, name string, value interface{}, tags ...Tag) {
 	eng.measure(t, name, value, Gauge, tags...)
 }
@@ -114,7 +114,7 @@ func (eng *Engine) Observe(name string, value interface{}, tags ...Tag) {
 	eng.measure(time.Now(), name, value, Histogram, tags...)
 }
 
-// Observe reports value for the histogram identified by name and tags.
+// ObserveAt reports value for the histogram identified by name and tags.
 func (eng *Engine) ObserveAt(t time.Time, name string, value interface{}, tags ...Tag) {
 	eng.measure(t, name, value, Histogram, tags...)
 }
diff --git a/field.go b/field.go
index 6272efd..b0217c1 100644
--- a/field.go
+++ b/field.go
@@ -67,6 +67,7 @@ func (t FieldType) String() string {
 	return ""
 }
 
+// GoString return a string representation of the FieldType.
 func (t FieldType) GoString() string {
 	switch t {
 	case Counter:
diff --git a/grafana/grafanatest/query.go b/grafana/grafanatest/query.go
index 6da5ab0..5401e5f 100644
--- a/grafana/grafanatest/query.go
+++ b/grafana/grafanatest/query.go
@@ -48,7 +48,7 @@ type Table struct {
 	Rows    [][]interface{}
 }
 
-// WriteRows satisfies the grafana.TableWriter interface.
+// WriteRow satisfies the grafana.TableWriter interface.
 func (t *Table) WriteRow(values ...interface{}) {
 	t.Rows = append(t.Rows,
 		append(make([]interface{}, 0, len(values)), values...),
diff --git a/grafana/handler.go b/grafana/handler.go
index c07d05f..c7866eb 100644
--- a/grafana/handler.go
+++ b/grafana/handler.go
@@ -91,9 +91,8 @@ func newEncoder(res http.ResponseWriter, req *http.Request) *objconv.StreamEncod
 	q := req.URL.Query()
 	if _, ok := q["pretty"]; ok {
 		return json.NewPrettyStreamEncoder(res)
-	} else {
-		return json.NewStreamEncoder(res)
 	}
+	return json.NewStreamEncoder(res)
 }
 
 func newDecoder(r io.Reader) *objconv.Decoder {
diff --git a/grafana/query.go b/grafana/query.go
index b9efcfa..dda92ad 100644
--- a/grafana/query.go
+++ b/grafana/query.go
@@ -62,6 +62,7 @@ type Target struct {
 // Grafana.
 type TargetType string
 
+// TargetTypes.
 const (
 	Timeserie TargetType = "timeserie"
 	Table     TargetType = "table"
@@ -108,6 +109,7 @@ func DescCol(text string, colType ColumnType) Column {
 // Grafana.
 type ColumnType string
 
+// ColumnTypes
 const (
 	Untyped ColumnType = ""
 	String  ColumnType = "string"
diff --git a/grafana/search.go b/grafana/search.go
index 3a8a383..31ca4ce 100644
--- a/grafana/search.go
+++ b/grafana/search.go
@@ -41,7 +41,7 @@ type SearchResponse interface {
 	WriteTargetValue(target string, value interface{})
 }
 
-// SearhRequest represents a request received on the /search endpoint.
+// SearchRequest represents a request received on the /search endpoint.
 type SearchRequest struct {
 	Target string
 }
diff --git a/handler.go b/handler.go
index c3d83e0..2091f3b 100644
--- a/handler.go
+++ b/handler.go
@@ -27,7 +27,7 @@ func flush(h Handler) {
 	}
 }
 
-// HandleFunc is a type alias making it possible to use simple functions as
+// HandlerFunc is a type alias making it possible to use simple functions as
 // measure handlers.
 type HandlerFunc func(time.Time, ...Measure)
 
diff --git a/httpstats/context_test.go b/httpstats/context_test.go
index f4c451e..d9bb6bf 100644
--- a/httpstats/context_test.go
+++ b/httpstats/context_test.go
@@ -26,7 +26,7 @@ func TestRequestContextTagPropegation(t *testing.T) {
 	assert.Equal(t, 0, len(RequestTags(x)), "Original request should have no tags (because no context with key)")
 
 	// create a child request which creates a child context
-	z := y.WithContext(context.WithValue(y.Context(), "not", "important"))
+	z := y.WithContext(context.WithValue(y.Context(), interface{}("not"), "important"))
 	assert.Equal(t, 1, len(RequestTags(z)), "We should still be able to see original tags")
 
 	// Add tags to the child context's reference to the original tag slice
diff --git a/httpstats/metrics_test.go b/httpstats/metrics_test.go
index 7eb8b51..151b3ad 100644
--- a/httpstats/metrics_test.go
+++ b/httpstats/metrics_test.go
@@ -88,11 +88,11 @@ func TestHeaderLength(t *testing.T) {
 	}
 
 	tests := []http.Header{
-		http.Header{},
-		http.Header{"Cookie": {}},
-		http.Header{"Content-Type": {"application/json"}},
-		http.Header{"Accept-Encoding": {"gzip", "deflate"}},
-		http.Header{"Host": {"localhost"}, "Accept": {"text/html", "text/plan"}},
+		{},
+		{"Cookie": {}},
+		{"Content-Type": {"application/json"}},
+		{"Accept-Encoding": {"gzip", "deflate"}},
+		{"Host": {"localhost"}, "Accept": {"text/html", "text/plan"}},
 	}
 
 	for _, test := range tests {
@@ -127,7 +127,7 @@ func TestRequestLength(t *testing.T) {
 	}
 
 	tests := []*http.Request{
-		&http.Request{
+		{
 			Method:        "GET",
 			Proto:         "HTTP/1.1",
 			ProtoMajor:    1,
@@ -173,7 +173,7 @@ func TestResponseLength(t *testing.T) {
 	}
 
 	tests := []*http.Response{
-		&http.Response{
+		{
 			Proto:         "HTTP/1.1",
 			StatusCode:    http.StatusOK,
 			ProtoMajor:    1,
diff --git a/influxdb/client.go b/influxdb/client.go
index 0ded6db..2f52d04 100644
--- a/influxdb/client.go
+++ b/influxdb/client.go
@@ -121,7 +121,7 @@ func (c *Client) CreateDB(db string) error {
 	return readResponse(r)
 }
 
-// HandleMetric satisfies the stats.Handler interface.
+// HandleMeasures satisfies the stats.Handler interface.
 func (c *Client) HandleMeasures(time time.Time, measures ...stats.Measure) {
 	c.buffer.HandleMeasures(time, measures...)
 }
diff --git a/netstats/conn.go b/netstats/conn.go
index 38c4aff..669dc33 100644
--- a/netstats/conn.go
+++ b/netstats/conn.go
@@ -36,7 +36,7 @@ func NewConn(c net.Conn) net.Conn {
 	return NewConnWith(stats.DefaultEngine, c)
 }
 
-// NewConn returns a net.Conn object that wraps c and produces metrics on eng.
+// NewConnWith returns a net.Conn object that wraps c and produces metrics on eng.
 func NewConnWith(eng *stats.Engine, c net.Conn) net.Conn {
 	nc := &conn{Conn: c, eng: eng}
 
diff --git a/netstats/listener.go b/netstats/listener.go
index aafe0c0..c836271 100644
--- a/netstats/listener.go
+++ b/netstats/listener.go
@@ -7,10 +7,12 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
+// NewListener returns a new net.Listener which uses the stats.DefaultEngine.
 func NewListener(lstn net.Listener) net.Listener {
 	return NewListenerWith(stats.DefaultEngine, lstn)
 }
 
+// NewListenerWith returns a new net.Listener with the provided *stats.Engine.
 func NewListenerWith(eng *stats.Engine, lstn net.Listener) net.Listener {
 	return &listener{
 		lstn: lstn,
diff --git a/procstats/collector.go b/procstats/collector.go
index b0fb8cf..5dd3d46 100644
--- a/procstats/collector.go
+++ b/procstats/collector.go
@@ -7,19 +7,24 @@ import (
 	"time"
 )
 
+// Collector is an interface that wraps the Collect() method.
 type Collector interface {
 	Collect()
 }
 
+// CollectorFunc is a type alias for func().
 type CollectorFunc func()
 
+// Collect calls the underling CollectorFunc func().
 func (f CollectorFunc) Collect() { f() }
 
+// Config contains a Collector and a time.Duration called CollectInterval.
 type Config struct {
 	Collector       Collector
 	CollectInterval time.Duration
 }
-
+// MultiCollector coalesces a variadic number of Collectors
+// and returns a single Collector.
 func MultiCollector(collectors ...Collector) Collector {
 	return CollectorFunc(func() {
 		for _, c := range collectors {
@@ -28,10 +33,11 @@ func MultiCollector(collectors ...Collector) Collector {
 	})
 }
 
+// StartCollector starts a Collector with a default Config.
 func StartCollector(collector Collector) io.Closer {
 	return StartCollectorWith(Config{Collector: collector})
 }
-
+// StartCollectorWith starts a Collector with the provided Config.
 func StartCollectorWith(config Config) io.Closer {
 	config = setConfigDefaults(config)
 
diff --git a/procstats/delaystats.go b/procstats/delaystats.go
index 7bd52d8..90f2aa4 100644
--- a/procstats/delaystats.go
+++ b/procstats/delaystats.go
@@ -18,13 +18,13 @@ type DelayMetrics struct {
 	FreePagesDelay time.Duration `metric:"freepages.delay.seconds" type:"counter"`
 }
 
-// NewDelayStats collects metrics on the current process and reports them to
+// NewDelayMetrics collects metrics on the current process and reports them to
 // the default stats engine.
 func NewDelayMetrics() *DelayMetrics {
 	return NewDelayMetricsWith(stats.DefaultEngine, os.Getpid())
 }
 
-// NewDelayStatsWith collects metrics on the process identified by pid and
+// NewDelayMetricsWith collects metrics on the process identified by pid and
 // reports them to eng.
 func NewDelayMetricsWith(eng *stats.Engine, pid int) *DelayMetrics {
 	return &DelayMetrics{engine: eng, pid: pid}
@@ -41,6 +41,8 @@ func (d *DelayMetrics) Collect() {
 	}
 }
 
+
+// DelayInfo stores delay Durations for various resources.
 type DelayInfo struct {
 	CPUDelay       time.Duration
 	BlockIODelay   time.Duration
@@ -48,6 +50,7 @@ type DelayInfo struct {
 	FreePagesDelay time.Duration
 }
 
+// CollectDelayInfo returns DelayInfo for a pid and an error, if any.
 func CollectDelayInfo(pid int) (info DelayInfo, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	info = collectDelayInfo(pid)
diff --git a/procstats/delaystats_linux.go b/procstats/delaystats_linux.go
index ba31adc..495fe4c 100644
--- a/procstats/delaystats_linux.go
+++ b/procstats/delaystats_linux.go
@@ -10,13 +10,13 @@ import (
 func collectDelayInfo(pid int) DelayInfo {
 	client, err := taskstats.New()
 	if err == syscall.ENOENT {
-		err = errors.New("Failed to communicate with taskstats Netlink family.  Ensure this program is not running in a network namespace.")
+		err = errors.New("failed to communicate with taskstats Netlink family, ensure this program is not running in a network namespace")
 	}
 	check(err)
 
 	stats, err := client.TGID(pid)
 	if err == syscall.EPERM {
-		err = errors.New("Failed to open Netlink socket: permission denied.  Ensure CAP_NET_RAW is enabled for this process, or run it with root privileges.")
+		err = errors.New("failed to open Netlink socket: permission denied, ensure CAP_NET_RAW is enabled for this process, or run it with root privileges")
 	}
 	check(err)
 
diff --git a/procstats/error_test.go b/procstats/error_test.go
index a685b58..b44fd96 100644
--- a/procstats/error_test.go
+++ b/procstats/error_test.go
@@ -21,8 +21,8 @@ func TestConvertPanicToError(t *testing.T) {
 			e: io.EOF,
 		},
 		{
-			v: "Hello World!",
-			e: errors.New("Hello World!"),
+			v: "hello world",
+			e: errors.New("hello world"),
 		},
 	}
 
diff --git a/procstats/linux/cgroup.go b/procstats/linux/cgroup.go
index ed0b154..1669898 100644
--- a/procstats/linux/cgroup.go
+++ b/procstats/linux/cgroup.go
@@ -5,14 +5,18 @@ import (
 	"time"
 )
 
+// ProcCGroup is a type alias for a []CGroup.
 type ProcCGroup []CGroup
 
+// CGroup holds configuration information for a Linux cgroup.
 type CGroup struct {
 	ID   int
 	Name string
 	Path string // Path in /sys/fs/cgroup
 }
 
+// Lookup takes a string argument representing the name of a Linux cgroup
+// and returns a CGroup and bool indicating whether or not the cgroup was found.
 func (pcg ProcCGroup) Lookup(name string) (cgroup CGroup, ok bool) {
 	forEachToken(name, ",", func(key1 string) {
 		for _, cg := range pcg {
@@ -25,13 +29,14 @@ func (pcg ProcCGroup) Lookup(name string) (cgroup CGroup, ok bool) {
 	})
 	return
 }
-
+// ReadProcCGroup takes an int argument representing a PID
+// and returns a ProcCGroup and error, if any is encountered.
 func ReadProcCGroup(pid int) (proc ProcCGroup, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcCGroup(readProcFile(pid, "cgroup"))
 	return
 }
-
+// ParseProcCGroup parses Linux system cgroup data and returns a ProcCGroup and error, if any is encountered.
 func ParseProcCGroup(s string) (proc ProcCGroup, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcCGroup(s)
@@ -57,19 +62,23 @@ func parseProcCGroup(s string) (proc ProcCGroup) {
 	})
 	return
 }
-
+// ReadCPUPeriod takes a string representing a Linux cgroup and returns
+// the period as a time.Duration that is applied for this cgroup and an error, if any.
 func ReadCPUPeriod(cgroup string) (period time.Duration, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	period = readCPUPeriod(cgroup)
 	return
 }
-
+// ReadCPUQuota takes a string representing a Linux cgroup and returns
+// the quota as a time.Duration that is applied for this cgroup and an error, if any.
 func ReadCPUQuota(cgroup string) (quota time.Duration, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	quota = readCPUQuota(cgroup)
 	return
 }
 
+// ReadCPUShares takes a string representing a Linux cgroup and returns
+// an int64 representing the cpu shares allotted for this cgroup and an error, if any.
 func ReadCPUShares(cgroup string) (shares int64, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	shares = readCPUShares(cgroup)
diff --git a/procstats/linux/error_test.go b/procstats/linux/error_test.go
index 44e31e8..e3405fc 100644
--- a/procstats/linux/error_test.go
+++ b/procstats/linux/error_test.go
@@ -21,8 +21,8 @@ func TestConvertPanicToError(t *testing.T) {
 			e: io.EOF,
 		},
 		{
-			v: "Hello World!",
-			e: errors.New("Hello World!"),
+			v: "hello world",
+			e: errors.New("hello world"),
 		},
 	}
 
diff --git a/procstats/linux/files.go b/procstats/linux/files.go
index f498dc9..0b09bf2 100644
--- a/procstats/linux/files.go
+++ b/procstats/linux/files.go
@@ -2,6 +2,9 @@ package linux
 
 import "os"
 
+// ReadOpenFileCount takes an int representing a PID and
+// returns a uint64 representing the open file descriptor count
+// for this process and an error, if any.
 func ReadOpenFileCount(pid int) (n uint64, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	n = readOpenFileCount(pid)
diff --git a/procstats/linux/limits.go b/procstats/linux/limits.go
index 92d2444..3222b04 100644
--- a/procstats/linux/limits.go
+++ b/procstats/linux/limits.go
@@ -2,17 +2,19 @@ package linux
 
 import "strconv"
 
+// Represents Linux's unlimited for resource limits
 const (
 	Unlimited uint64 = 1<<64 - 1
 )
 
+// Limits holds configuration for resource limits
 type Limits struct {
 	Name string
 	Soft uint64
 	Hard uint64
 	Unit string
 }
-
+// ProcLimits holds Limits for processes.
 type ProcLimits struct {
 	CPUTime          Limits // seconds
 	FileSize         Limits // bytes
@@ -31,13 +33,13 @@ type ProcLimits struct {
 	RealtimePriority Limits
 	RealtimeTimeout  Limits
 }
-
+// ReadProcLimits returns the ProcLimits and an error, if any, for a PID.
 func ReadProcLimits(pid int) (proc ProcLimits, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcLimits(readProcFile(pid, "limits"))
 	return
 }
-
+// ParseProcLimits parses system process limits and returns a ProcLimits and error, if any.
 func ParseProcLimits(s string) (proc ProcLimits, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcLimits(s)
diff --git a/procstats/linux/memory.go b/procstats/linux/memory.go
index d51eef7..80cc439 100644
--- a/procstats/linux/memory.go
+++ b/procstats/linux/memory.go
@@ -4,4 +4,5 @@ const (
 	unlimitedMemoryLimit = 9223372036854771712
 )
 
+// ReadMemoryLimit returns the memory limit and an error, if any, for a PID.
 func ReadMemoryLimit(pid int) (limit uint64, err error) { return readMemoryLimit(pid) }
diff --git a/procstats/linux/sched.go b/procstats/linux/sched.go
index f07f4e6..20b2360 100644
--- a/procstats/linux/sched.go
+++ b/procstats/linux/sched.go
@@ -2,6 +2,7 @@ package linux
 
 import "strconv"
 
+// ProcSched contains statistics about process scheduling, utilization, and switches.
 type ProcSched struct {
 	NRSwitches            uint64 // nr_switches
 	NRVoluntarySwitches   uint64 // nr_voluntary_switches
@@ -11,13 +12,13 @@ type ProcSched struct {
 	SEAvgLoadAvg          uint64 // se.avg.load_avg
 	SEAvgUtilAvg          uint64 // se.avg.util_avg
 }
-
+// ReadProcSched returns a ProcSched and error, if any, for a PID.
 func ReadProcSched(pid int) (proc ProcSched, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcSched(readProcFile(pid, "sched"))
 	return
 }
-
+//ParseProcSched processes system process scheduling data and returns a ProcSched and error, if any.
 func ParseProcSched(s string) (proc ProcSched, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcSched(s)
diff --git a/procstats/linux/stat.go b/procstats/linux/stat.go
index c6c6c22..df2c90b 100644
--- a/procstats/linux/stat.go
+++ b/procstats/linux/stat.go
@@ -2,8 +2,10 @@ package linux
 
 import "fmt"
 
+// ProcState represents the underlying OS state of a process.
 type ProcState rune
 
+// Enumerated ProcStates.
 const (
 	Running                         ProcState = 'R'
 	Sleeping                        ProcState = 'S'
@@ -17,7 +19,7 @@ const (
 	Wakekill                        ProcState = 'W'
 	Parked                          ProcState = 'P'
 )
-
+// Scan updates the ProcState for a process.
 func (ps *ProcState) Scan(s fmt.ScanState, _ rune) (err error) {
 	var c rune
 	s.SkipSpace()
@@ -28,7 +30,7 @@ func (ps *ProcState) Scan(s fmt.ScanState, _ rune) (err error) {
 
 	return
 }
-
+// ProcStat contains statistics associated with a process.
 type ProcStat struct {
 	Pid                 int32     // (1) pid
 	Comm                string    // (2) comm
@@ -84,11 +86,13 @@ type ProcStat struct {
 	ExitCode            int32     // (52) exit_code
 }
 
+// ReadProcStat returns a ProcStat and error, if any, for a PID.
 func ReadProcStat(pid int) (proc ProcStat, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	return ParseProcStat(readProcFile(pid, "stat"))
 }
 
+// ParseProcStat parses system process statistics and returns a ProcStat and error, if any.
 func ParseProcStat(s string) (proc ProcStat, err error) {
 	_, err = fmt.Sscan(s,
 		&proc.Pid,
diff --git a/procstats/linux/statm.go b/procstats/linux/statm.go
index 61aeb81..054b375 100644
--- a/procstats/linux/statm.go
+++ b/procstats/linux/statm.go
@@ -2,6 +2,7 @@ package linux
 
 import "fmt"
 
+// ProcStatm contains statistics about memory utilization of a process.
 type ProcStatm struct {
 	Size     uint64 // (1) size
 	Resident uint64 // (2) resident
@@ -12,11 +13,13 @@ type ProcStatm struct {
 	Dt       uint64 // (7) dt
 }
 
+// ReadProcStatm returns a ProcStatm and an error, if any, for a PID.
 func ReadProcStatm(pid int) (proc ProcStatm, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	return ParseProcStatm(readProcFile(pid, "statm"))
 }
 
+// ParseProcStatm parses system proc data and returns a ProcStatm and error, if any.
 func ParseProcStatm(s string) (proc ProcStatm, err error) {
 	_, err = fmt.Sscan(s,
 		&proc.Size,
diff --git a/procstats/proc.go b/procstats/proc.go
index 36e5736..02f7241 100644
--- a/procstats/proc.go
+++ b/procstats/proc.go
@@ -100,7 +100,7 @@ type procThreads struct {
 	} `metric:"switch"`
 }
 
-// NewProdMetrics collects metrics on the current process and reports them to
+// NewProcMetrics collects metrics on the current process and reports them to
 // the default stats engine.
 func NewProcMetrics() *ProcMetrics {
 	return NewProcMetricsWith(stats.DefaultEngine, os.Getpid())
@@ -180,6 +180,8 @@ func (p *ProcMetrics) Collect() {
 	}
 }
 
+
+// ProcInfo contains types which hold statistics for various resources
 type ProcInfo struct {
 	CPU     CPUInfo
 	Memory  MemoryInfo
@@ -187,10 +189,12 @@ type ProcInfo struct {
 	Threads ThreadInfo
 }
 
+// CollectProcInfo return a ProcInfo and error (if any) for a given PID
 func CollectProcInfo(pid int) (ProcInfo, error) {
 	return collectProcInfo(pid)
 }
 
+// CPUInfo holds statistics and configuration details for a process.
 type CPUInfo struct {
 	User time.Duration // user cpu time used by the process
 	Sys  time.Duration // system cpu time used by the process
@@ -207,8 +211,9 @@ type CPUInfo struct {
 	Shares int64         // 1024 scaled value representing the CPU shares
 }
 
+// MemoryInfo holds statistics and configuration about Memory usage for a process.
 type MemoryInfo struct {
-	Available uint64 // amound of RAM available to the process
+	Available uint64 // amount of RAM available to the process
 	Size      uint64 // total program memory (including virtual mappings)
 	Resident  uint64 // resident set size
 	Shared    uint64 // shared pages (i.e., backed by a file)
@@ -219,11 +224,12 @@ type MemoryInfo struct {
 	MinorPageFaults uint64
 }
 
+// FileInfo holds statistics about open and max file handles for a process.
 type FileInfo struct {
 	Open uint64 // fds opened by the process
 	Max  uint64 // max number of fds the process can open
 }
-
+// ThreadInfo holds statistics about number of threads and context switches for a process.
 type ThreadInfo struct {
 	Num                        uint64
 	VoluntaryContextSwitches   uint64
diff --git a/procstats/proc_linux.go b/procstats/proc_linux.go
index c17ea93..3675d58 100644
--- a/procstats/proc_linux.go
+++ b/procstats/proc_linux.go
@@ -115,7 +115,7 @@ func collectProcInfo(pid int) (info ProcInfo, err error) {
 		// can use the cpu period, quota, and shares of the calling process.
 		//
 		// We do this instead of looking directly into the cgroup directory
-		// because we don't have any garantees that the path is exposed to the
+		// because we don't have any guarantees that the path is exposed to the
 		// current process (but it should always have access to its own cgroup).
 		if selfCPU.Path == procCPU.Path {
 			cpuPeriod, _ = linux.ReadCPUPeriod("")
@@ -156,7 +156,7 @@ func collectProcInfo(pid int) (info ProcInfo, err error) {
 		},
 
 		Threads: ThreadInfo{
-			Num: uint64(stat.NumThreads),
+			Num:                        uint64(stat.NumThreads),
 			VoluntaryContextSwitches:   sched.NRVoluntarySwitches,
 			InvoluntaryContextSwitches: sched.NRInvoluntarySwitches,
 		},
diff --git a/prometheus/handler.go b/prometheus/handler.go
index ba8b237..41c33d1 100644
--- a/prometheus/handler.go
+++ b/prometheus/handler.go
@@ -49,7 +49,7 @@ type Handler struct {
 	metrics metricStore
 }
 
-// HandleMetric satisfies the stats.Handler interface.
+// HandleMeasures satisfies the stats.Handler interface.
 func (h *Handler) HandleMeasures(mtime time.Time, measures ...stats.Measure) {
 	cache := handleMetricPool.Get().(*handleMetricCache)
 
diff --git a/prometheus/handler_test.go b/prometheus/handler_test.go
index 7ef88a3..dca8edf 100644
--- a/prometheus/handler_test.go
+++ b/prometheus/handler_test.go
@@ -56,7 +56,7 @@ func TestServeHTTP(t *testing.T) {
 
 	handler := &Handler{
 		Buckets: map[stats.Key][]stats.Value{
-			stats.Key{Field: "C"}: []stats.Value{
+			{Field: "C"}: {
 				stats.ValueOf(0.25),
 				stats.ValueOf(0.5),
 				stats.ValueOf(0.75),
@@ -122,7 +122,7 @@ func BenchmarkHandleMetric(b *testing.B) {
 	now := time.Now()
 
 	buckets := map[stats.Key][]stats.Value{
-		stats.Key{Field: "C"}: []stats.Value{
+		{Field: "C"}: {
 			stats.ValueOf(0.25),
 			stats.ValueOf(0.5),
 			stats.ValueOf(0.75),
diff --git a/prometheus/label.go b/prometheus/label.go
index fa2aff2..311045d 100644
--- a/prometheus/label.go
+++ b/prometheus/label.go
@@ -17,12 +17,12 @@ func (l label) hash() uint64 {
 	return h
 }
 
-func (l1 label) equal(l2 label) bool {
-	return l1.name == l2.name && l1.value == l2.value
+func (l label) equal(other label) bool {
+	return l.name == other.name && l.value == other.value
 }
 
-func (l1 label) less(l2 label) bool {
-	return l1.name < l2.name || (l1.name == l2.name && l1.value < l2.value)
+func (l label) less(other label) bool {
+	return l.name < other.name || (l.name == other.name && l.value < other.value)
 }
 
 type labels []label
@@ -55,25 +55,25 @@ func (l labels) hash() uint64 {
 	return h
 }
 
-func (l1 labels) equal(l2 labels) bool {
-	if len(l1) != len(l2) {
+func (l labels) equal(other labels) bool {
+	if len(l) != len(other) {
 		return false
 	}
-	for i := range l1 {
-		if !l1[i].equal(l2[i]) {
+	for i := range l {
+		if !l[i].equal(other[i]) {
 			return false
 		}
 	}
 	return true
 }
 
-func (l1 labels) less(l2 labels) bool {
-	n1 := len(l1)
-	n2 := len(l2)
+func (l labels) less(other labels) bool {
+	n1 := len(l)
+	n2 := len(other)
 
 	for i := 0; i != n1 && i != n2; i++ {
-		if !l1[i].equal(l2[i]) {
-			return l1[i].less(l2[i])
+		if !l[i].equal(other[i]) {
+			return l[i].less(other[i])
 		}
 	}
 
diff --git a/prometheus/metric_test.go b/prometheus/metric_test.go
index 612e6d1..98af556 100644
--- a/prometheus/metric_test.go
+++ b/prometheus/metric_test.go
@@ -68,12 +68,12 @@ func TestMetricEntryCleanup(t *testing.T) {
 		name:  "A",
 		states: metricStateMap{
 			0: []*metricState{
-				&metricState{value: 42, time: now},
-				&metricState{value: 1, time: now.Add(-time.Minute)},
-				&metricState{value: 2, time: now.Add(-(500 * time.Millisecond))},
+				{value: 42, time: now},
+				{value: 1, time: now.Add(-time.Minute)},
+				{value: 2, time: now.Add(-(500 * time.Millisecond))},
 			},
 			1: []*metricState{
-				&metricState{value: 123, time: now.Add(10 * time.Millisecond)},
+				{value: 123, time: now.Add(10 * time.Millisecond)},
 			},
 			2: []*metricState{},
 		},
@@ -90,11 +90,11 @@ func TestMetricEntryCleanup(t *testing.T) {
 
 	if !reflect.DeepEqual(entry.states, metricStateMap{
 		0: []*metricState{
-			&metricState{value: 42, time: now},
-			&metricState{value: 2, time: now.Add(-(500 * time.Millisecond))},
+			{value: 42, time: now},
+			{value: 2, time: now.Add(-(500 * time.Millisecond))},
 		},
 		1: []*metricState{
-			&metricState{value: 123, time: now.Add(10 * time.Millisecond)},
+			{value: 123, time: now.Add(10 * time.Millisecond)},
 		},
 	}) {
 		t.Errorf("bad entry states: %#v", entry.states)
@@ -110,7 +110,7 @@ func TestMetricEntryCleanup(t *testing.T) {
 
 	if !reflect.DeepEqual(entry.states, metricStateMap{
 		1: []*metricState{
-			&metricState{value: 123, time: now.Add(10 * time.Millisecond)},
+			{value: 123, time: now.Add(10 * time.Millisecond)},
 		},
 	}) {
 		t.Errorf("bad entry states: %#v", entry.states)
diff --git a/statstest/handler.go b/statstest/handler.go
index f27d15c..30e6204 100644
--- a/statstest/handler.go
+++ b/statstest/handler.go
@@ -18,6 +18,7 @@ type Handler struct {
 	flush    int32
 }
 
+// HandleMeasures process a variadic list of stats.Measure.
 func (h *Handler) HandleMeasures(time time.Time, measures ...stats.Measure) {
 	h.Lock()
 	for _, m := range measures {
@@ -35,6 +36,7 @@ func (h *Handler) Measures() []stats.Measure {
 	return m
 }
 
+// Flush Increments Flush counter.
 func (h *Handler) Flush() {
 	atomic.AddInt32(&h.flush, 1)
 }
@@ -44,6 +46,7 @@ func (h *Handler) FlushCalls() int {
 	return int(atomic.LoadInt32(&h.flush))
 }
 
+// Clear removes all measures held by Handler.
 func (h *Handler) Clear() {
 	h.Lock()
 	h.measures = h.measures[:0]
diff --git a/value.go b/value.go
index 8153e4c..de365d2 100644
--- a/value.go
+++ b/value.go
@@ -6,19 +6,23 @@ import (
 	"time"
 )
 
+// Value is a wrapper type which is used to encapsulate underlying types (nil, bool, int, uintptr, float)
+// in a single pseudo-generic type.
 type Value struct {
 	typ  Type
 	pad  int32
 	bits uint64
 }
 
+// MustValueOf asserts that v's underlying Type is valid, otherwise it panics.
 func MustValueOf(v Value) Value {
 	if v.Type() == Invalid {
 		panic("stats.MustValueOf received a value of unsupported type")
 	}
 	return v
 }
-
+// ValueOf inspects v's underlying type and returns a Value which encapsulates this type.
+// If the underlying type of v is not supported by Value's encapsulation its Type() will return stats.Invalid
 func ValueOf(v interface{}) Value {
 	switch x := v.(type) {
 	case Value:
@@ -119,31 +123,32 @@ func float64Value(v float64) Value {
 func durationValue(v time.Duration) Value {
 	return Value{typ: Duration, bits: uint64(v)}
 }
-
+// Type returns the Type of this value.
 func (v Value) Type() Type {
 	return v.typ
 }
-
+// Bool returns a bool if the underlying data for this value is zero.
 func (v Value) Bool() bool {
 	return v.bits != 0
 }
-
+// Int returns an new int64 representation of this Value.
 func (v Value) Int() int64 {
 	return int64(v.bits)
 }
-
+// Uint returns a uint64 representation of this Value.
 func (v Value) Uint() uint64 {
 	return v.bits
 }
-
+// Float returns a new float64 representation of this Value.
 func (v Value) Float() float64 {
 	return math.Float64frombits(v.bits)
 }
-
+// Duration returns a new time.Duration representation of this Value.
 func (v Value) Duration() time.Duration {
 	return time.Duration(v.bits)
 }
-
+// Interface returns an new interface{} representation of this value.
+// However, if the underlying Type is unsupported it panics.
 func (v Value) Interface() interface{} {
 	switch v.Type() {
 	case Null:
@@ -162,7 +167,7 @@ func (v Value) Interface() interface{} {
 		panic("unknown type found in a stats.Value")
 	}
 }
-
+// String returns a string representation of the underling value.
 func (v Value) String() string {
 	switch v.Type() {
 	case Null:
@@ -181,9 +186,10 @@ func (v Value) String() string {
 		return "<unknown>"
 	}
 }
-
+// Type is an int32 type alias used to denote a values underlying type.
 type Type int32
 
+// Underlying Types.
 const (
 	Null Type = iota
 	Bool
@@ -193,7 +199,7 @@ const (
 	Duration
 	Invalid
 )
-
+// String returns the string representation of a type.
 func (t Type) String() string {
 	switch t {
 	case Null:
@@ -212,7 +218,7 @@ func (t Type) String() string {
 		return "<unknown>"
 	}
 }
-
+// GoString implements the GoStringer interface.
 func (t Type) GoString() string {
 	switch t {
 	case Null:
diff --git a/veneur/client.go b/veneur/client.go
index c4779ca..30cebea 100644
--- a/veneur/client.go
+++ b/veneur/client.go
@@ -7,6 +7,7 @@ import (
 	"github.com/segmentio/stats/v4/datadog"
 )
 
+// Const Sink Configuration types
 const (
 	GlobalOnly = "veneurglobalonly"
 	LocalOnly  = "veneurlocalonly"
@@ -17,6 +18,7 @@ const (
 	KafkaSink    = "kafka"
 )
 
+// SinkOnly tags
 var (
 	TagSignalfxOnly = stats.Tag{Name: SinkOnly, Value: SignalfxSink}
 	TagDatadogOnly  = stats.Tag{Name: SinkOnly, Value: DatadogSink}
@@ -85,7 +87,7 @@ func NewClientWith(config ClientConfig) *Client {
 	}
 }
 
-// HandleMetric satisfies the stats.Handler interface.
+// HandleMeasures satisfies the stats.Handler interface.
 func (c *Client) HandleMeasures(time time.Time, measures ...stats.Measure) {
 
 	// If there are no tags to add, call HandleMeasures with measures directly
@@ -95,7 +97,7 @@ func (c *Client) HandleMeasures(time time.Time, measures ...stats.Measure) {
 	}
 
 	finalMeasures := make([]stats.Measure, len(measures))
-	for i, _ := range measures {
+	for i := range measures {
 		finalMeasures[i] = measures[i].Clone()
 		finalMeasures[i].Tags = append(measures[i].Tags, c.tags...)
 	}

From fc52212a9c1510b13c7b9eb7b076b2fb785fef16 Mon Sep 17 00:00:00 2001
From: Hyonjee Joo <hyonjee.joo@segment.com>
Date: Fri, 5 Mar 2021 14:09:56 -0700
Subject: [PATCH 09/63] add comment about Clock duration unit reported to
 datadog

---
 clock.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/clock.go b/clock.go
index 5cd90b7..d063f5e 100644
--- a/clock.go
+++ b/clock.go
@@ -6,6 +6,8 @@ import "time"
 //
 // Clocks are useful to measure the duration taken by sequential execution steps
 // and therefore aren't safe to be used concurrently by multiple goroutines.
+//
+// Note: Clock times are reported to datadog in seconds. See `stats/datadog/measure.go`.
 type Clock struct {
 	name  string
 	first time.Time

From 367a46f7737a4802f685e642c72eb5f984a44a39 Mon Sep 17 00:00:00 2001
From: Bill Havanki <bhavanki@users.noreply.github.com>
Date: Thu, 12 Aug 2021 14:57:44 -0400
Subject: [PATCH 10/63] Fix use of reflect.StringHeader in prometheus/metric.go
 (#133)

The `go vet` command in Go 1.16 reports a warning for inappropriate
use of reflect.StringHeader.

https://github.com/golang/go/issues/40701

Its use in prometheus/metric.go to convert a byte array to a string in
place began to trigger the warning. That code has been replaced with a
safer variant that avoids the `vet` warning and still converts the array
without allocating new memory.

https://stackoverflow.com/a/66865482

Additionally, the CircleCI test now uses a pinned influxdb image of
1.8.9. The 2.x influxdb Docker images require authentication to use.

Co-authored-by: Collin Van Dyck <collin@segment.com>
---
 .circleci/config.yml      |  2 +-
 prometheus/metric.go      | 16 +++++++++++----
 prometheus/metric_test.go | 41 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 38a618c..abc23d8 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -4,7 +4,7 @@ jobs:
     working_directory: /go/src/github.com/segmentio/stats
     docker:
       - image: circleci/golang
-      - image: influxdb:alpine
+      - image: influxdb:1.8.9-alpine
         ports: ['8086:8086']
     steps:
       - checkout
diff --git a/prometheus/metric.go b/prometheus/metric.go
index a971c86..597ec49 100644
--- a/prometheus/metric.go
+++ b/prometheus/metric.go
@@ -401,11 +401,19 @@ func le(buckets []stats.Value) string {
 		}
 		b = appendFloat(b, valueOf(v))
 	}
+	return unsafeByteSliceToString(b)
+}
 
-	return *(*string)(unsafe.Pointer(&reflect.StringHeader{
-		Data: uintptr(unsafe.Pointer(&b[0])),
-		Len:  len(b),
-	}))
+// This function converts the byte array to a string without additional
+// memory allocation.
+// Source: https://stackoverflow.com/a/66865482 (license: CC BY-SA 4.0)
+func unsafeByteSliceToString(b []byte) string {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	var s string
+	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	sh.Data = sliceHeader.Data
+	sh.Len = sliceHeader.Len
+	return s
 }
 
 func nextLe(s string) (head string, tail string) {
diff --git a/prometheus/metric_test.go b/prometheus/metric_test.go
index 98af556..afdb22e 100644
--- a/prometheus/metric_test.go
+++ b/prometheus/metric_test.go
@@ -11,6 +11,47 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
+func TestUnsafeByteSliceToString(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		input    []byte
+		expected string
+	}{
+		{
+			name:     "nil bytes",
+			input:    nil,
+			expected: "",
+		},
+		{
+			name:     "no bytes",
+			input:    []byte{},
+			expected: "",
+		},
+		{
+			name:     "list of floats",
+			input:    []byte("1.2:3.4:5.6:7.8"),
+			expected: "1.2:3.4:5.6:7.8",
+		},
+		{
+			name:     "deadbeef",
+			input:    []byte{0xde, 0xad, 0xbe, 0xef},
+			expected: "\xde\xad\xbe\xef",
+		},
+		{
+			name:     "embedded zero",
+			input:    []byte("this\x00that"),
+			expected: "this\x00that",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			res := unsafeByteSliceToString(test.input)
+			if res != test.expected {
+				t.Errorf("Expected %q but got %q", test.expected, res)
+			}
+		})
+	}
+}
+
 func TestMetricStore(t *testing.T) {
 	input := []metric{
 		{mtype: counter, scope: "test", name: "A", value: 1},

From 55927e9d7d59defec4f39ec4743c169c7f51ebab Mon Sep 17 00:00:00 2001
From: Bill Havanki <bhavanki@users.noreply.github.com>
Date: Thu, 12 Aug 2021 16:16:15 -0400
Subject: [PATCH 11/63] Support Datadog distribution metric type (#132)

The Datadog client now has the ability to send histogram metrics as the
Datadog-specific distribution metric type. The Datadog client
configuration has a new `DistributionPrefixes` item which specifies the
prefixes of metric names that, when reported as histograms to the stats
library, are to be sent as distributions instead. For example, when the
prefix list is set to `{ "dist_" }`, then any histogram metric whose
name begins with "dist_" is sent as a distribution; all other histograms
are sent as ordinary histograms, as before.

The default configuration sends no histograms as distributions.
---
 datadog/client.go       | 34 +++++++++++++++-------
 datadog/client_test.go  | 19 +++++++++++++
 datadog/measure.go      | 26 +++++++++++++++--
 datadog/measure_test.go | 63 +++++++++++++++++++++++++++++++++++++++--
 datadog/metric.go       | 11 +++----
 datadog/metric_test.go  | 22 ++++++++++++++
 6 files changed, 154 insertions(+), 21 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index b1feb17..88bd2eb 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -26,13 +26,17 @@ const (
 	MaxBufferSize = 65507
 )
 
-// DefaultFilter is the default tag to filter before sending to
-// datadog. Using the request path as a tag can overwhelm datadog's
-// servers if there are too many unique routes due to unique IDs being a
-// part of the path. Only change the default filter if there is a static
-// number of routes.
 var (
+	// DefaultFilters are the default tags to filter before sending to
+	// datadog. Using the request path as a tag can overwhelm datadog's
+	// servers if there are too many unique routes due to unique IDs being a
+	// part of the path. Only change the default filters if there are a static
+	// number of routes.
 	DefaultFilters = []string{"http_req_path"}
+
+	// DefaultDistributionPrefixes is the default set of name prefixes for
+	// metrics to be sent as distributions instead of as histograms.
+	DefaultDistributionPrefixes = []string{}
 )
 
 // The ClientConfig type is used to configure datadog clients.
@@ -47,6 +51,10 @@ type ClientConfig struct {
 
 	// List of tags to filter. If left nil is set to DefaultFilters.
 	Filters []string
+
+	// Set of name prefixes for metrics to be sent as distributions instead of
+	// as histograms.
+	DistributionPrefixes []string
 }
 
 // Client represents an datadog client that implements the stats.Handler
@@ -80,6 +88,10 @@ func NewClientWith(config ClientConfig) *Client {
 		config.Filters = DefaultFilters
 	}
 
+	if config.DistributionPrefixes == nil {
+		config.DistributionPrefixes = DefaultDistributionPrefixes
+	}
+
 	// transform filters from array to map
 	filterMap := make(map[string]struct{})
 	for _, f := range config.Filters {
@@ -88,7 +100,8 @@ func NewClientWith(config ClientConfig) *Client {
 
 	c := &Client{
 		serializer: serializer{
-			filters: filterMap,
+			filters:      filterMap,
+			distPrefixes: config.DistributionPrefixes,
 		},
 	}
 
@@ -136,14 +149,15 @@ func (c *Client) Close() error {
 }
 
 type serializer struct {
-	w          io.WriteCloser
-	bufferSize int
-	filters    map[string]struct{}
+	w            io.WriteCloser
+	bufferSize   int
+	filters      map[string]struct{}
+	distPrefixes []string
 }
 
 func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Measure) []byte {
 	for _, m := range measures {
-		b = AppendMeasureFiltered(b, m, s.filters)
+		b = AppendMeasureFiltered(b, m, s.filters, s.distPrefixes)
 	}
 	return b
 }
diff --git a/datadog/client_test.go b/datadog/client_test.go
index 29363c0..6318e80 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -51,6 +51,25 @@ func TestClient_UDS(t *testing.T) {
 			},
 		})
 	}
+}
+
+func TestClientWithDistributionPrefixes(t *testing.T) {
+	client := NewClientWith(ClientConfig{
+		Address:              DefaultAddress,
+		DistributionPrefixes: []string{"dist_"},
+	})
+
+	client.HandleMeasures(time.Time{}, stats.Measure{
+		Name: "request",
+		Fields: []stats.Field{
+			{Name: "count", Value: stats.ValueOf(5)},
+			stats.MakeField("dist_rtt", stats.ValueOf(100*time.Millisecond), stats.Histogram),
+		},
+		Tags: []stats.Tag{
+			stats.T("answer", "42"),
+			stats.T("hello", "world"),
+		},
+	})
 
 	if err := client.Close(); err != nil {
 		t.Error(err)
diff --git a/datadog/measure.go b/datadog/measure.go
index f411a55..aaf8ded 100644
--- a/datadog/measure.go
+++ b/datadog/measure.go
@@ -3,20 +3,24 @@ package datadog
 import (
 	"math"
 	"strconv"
+	"strings"
 
 	"github.com/segmentio/stats/v4"
 )
 
+// Datagram format: https://docs.datadoghq.com/developers/dogstatsd/datagram_shell
+
 // AppendMeasure is a formatting routine to append the dogstatsd protocol
 // representation of a measure to a memory buffer.
 func AppendMeasure(b []byte, m stats.Measure) []byte {
-	return AppendMeasureFiltered(b, m, nil)
+	return AppendMeasureFiltered(b, m, nil, []string{})
 }
 
 // AppendMeasureFiltered is a formatting routine to append the dogstatsd protocol
 // representation of a measure to a memory buffer. Tags listed in the filters map
 // are removed. (some tags may not be suitable for submission to DataDog)
-func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{}) []byte {
+func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{},
+	distPrefixes []string) []byte {
 	for _, field := range m.Fields {
 		b = append(b, m.Name...)
 		if len(field.Name) != 0 {
@@ -50,7 +54,11 @@ func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{
 		case stats.Gauge:
 			b = append(b, '|', 'g')
 		default:
-			b = append(b, '|', 'h')
+			if sendDist(field.Name, distPrefixes) {
+				b = append(b, '|', 'd')
+			} else {
+				b = append(b, '|', 'h')
+			}
 		}
 
 		if n := len(m.Tags); n != 0 {
@@ -86,3 +94,15 @@ func normalizeFloat(f float64) float64 {
 		return f
 	}
 }
+
+func sendDist(name string, distPrefixes []string) bool {
+	if distPrefixes == nil {
+		return false
+	}
+	for _, prefix := range distPrefixes {
+		if strings.HasPrefix(name, prefix) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/datadog/measure_test.go b/datadog/measure_test.go
index 883b6e0..7f0f8fd 100644
--- a/datadog/measure_test.go
+++ b/datadog/measure_test.go
@@ -9,8 +9,9 @@ import (
 
 var (
 	testMeasures = []struct {
-		m stats.Measure
-		s string
+		m  stats.Measure
+		s  string
+		dp []string
 	}{
 		{
 			m: stats.Measure{
@@ -21,6 +22,7 @@ var (
 			},
 			s: `request.count:5|c
 `,
+			dp: []string{},
 		},
 
 		{
@@ -38,6 +40,23 @@ var (
 			s: `request.count:5|c|#answer:42,hello:world
 request.rtt:0.1|h|#answer:42,hello:world
 `,
+			dp: []string{},
+		},
+
+		{
+			m: stats.Measure{
+				Name: "request",
+				Fields: []stats.Field{
+					stats.MakeField("dist_rtt", 100*time.Millisecond, stats.Histogram),
+				},
+				Tags: []stats.Tag{
+					stats.T("answer", "42"),
+					stats.T("hello", "world"),
+				},
+			},
+			s: `request.dist_rtt:0.1|d|#answer:42,hello:world
+`,
+			dp: []string{"dist_"},
 		},
 	}
 )
@@ -45,7 +64,7 @@ request.rtt:0.1|h|#answer:42,hello:world
 func TestAppendMeasure(t *testing.T) {
 	for _, test := range testMeasures {
 		t.Run(test.s, func(t *testing.T) {
-			if s := string(AppendMeasure(nil, test.m)); s != test.s {
+			if s := string(AppendMeasureFiltered(nil, test.m, nil, test.dp)); s != test.s {
 				t.Error("bad metric representation:")
 				t.Log("expected:", test.s)
 				t.Log("found:   ", s)
@@ -53,3 +72,41 @@ func TestAppendMeasure(t *testing.T) {
 		})
 	}
 }
+
+var (
+	testDistNames = []struct {
+		n string
+		d bool
+	}{
+		{
+			n: "name",
+			d: false,
+		},
+		{
+			n: "",
+			d: false,
+		},
+		{
+			n: "dist_name",
+			d: true,
+		},
+		{
+			n: "distname",
+			d: false,
+		},
+	}
+	distPrefixes = []string{"dist_"}
+)
+
+func TestSendDist(t *testing.T) {
+	for _, test := range testDistNames {
+		t.Run(test.n, func(t *testing.T) {
+			a := sendDist(test.n, distPrefixes)
+			if a != test.d {
+				t.Error("distribution name detection incorrect:")
+				t.Log("expected:", test.d)
+				t.Log("found:   ", a)
+			}
+		})
+	}
+}
diff --git a/datadog/metric.go b/datadog/metric.go
index 5131e37..a6bcc06 100644
--- a/datadog/metric.go
+++ b/datadog/metric.go
@@ -8,15 +8,16 @@ import (
 )
 
 // MetricType is an enumeration providing symbols to represent the different
-// metric types upported by datadog.
+// metric types supported by datadog.
 type MetricType string
 
 // Metric Types.
 const (
-	Counter   MetricType = "c"
-	Gauge     MetricType = "g"
-	Histogram MetricType = "h"
-	Unknown   MetricType = "?"
+	Counter      MetricType = "c"
+	Gauge        MetricType = "g"
+	Histogram    MetricType = "h"
+	Distribution MetricType = "d"
+	Unknown      MetricType = "?"
 )
 
 // The Metric type is a representation of the metrics supported by datadog.
diff --git a/datadog/metric_test.go b/datadog/metric_test.go
index 76380f6..2ba8d38 100644
--- a/datadog/metric_test.go
+++ b/datadog/metric_test.go
@@ -101,6 +101,28 @@ var testMetrics = []struct {
 		},
 	},
 
+	{
+		s: "song.length:240|d|@0.5\n",
+		m: Metric{
+			Type:  Distribution,
+			Name:  "song.length",
+			Value: 240,
+			Rate:  0.5,
+			Tags:  nil,
+		},
+	},
+
+	{
+		s: "users.uniques:1234|d\n",
+		m: Metric{
+			Type:  Distribution,
+			Name:  "users.uniques",
+			Value: 1234,
+			Rate:  1,
+			Tags:  nil,
+		},
+	},
+
 	{
 		s: "users.online:1|c|#country:china\n",
 		m: Metric{

From f2f0b58fc5b44cdf2d52ebf0dbde183f418e3827 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Thu, 28 Apr 2022 21:51:15 -0600
Subject: [PATCH 12/63] Add github workflow

---
 .github/workflows/test.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 .github/workflows/test.yml

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..aee5abf
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,30 @@
+name: Test
+on:
+- pull_request
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        go:
+        - '1.17.x'
+        - '1.18.x'
+        label:
+        - [self-hosted, linux, arm64, segment]
+        - ubuntu-latest
+
+    runs-on: ${{ matrix.label }}
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup Go ${{ matrix.go }}
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go }}
+
+    - name: Download Dependencies
+      run: go mod download
+
+    - name: Run Tests
+      run: go test -race -tags=${{ matrix.tags }} ./...

From 66247c737e72b7648130a1adf3ffdf9f3d963c37 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Thu, 28 Apr 2022 21:57:43 -0600
Subject: [PATCH 13/63] Disabling influxdb client test

---
 influxdb/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/influxdb/client_test.go b/influxdb/client_test.go
index dc83ec8..b89be03 100644
--- a/influxdb/client_test.go
+++ b/influxdb/client_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
-func TestClient(t *testing.T) {
+func DisabledTestClient(t *testing.T) {
 	transport := &errorCaptureTransport{
 		RoundTripper: http.DefaultTransport,
 	}

From abba0e8c878f1804a29ac51b5b638dc1187742f3 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Sat, 30 Apr 2022 10:57:54 -0600
Subject: [PATCH 14/63] Add golangci

---
 .github/workflows/golangci-lint.yml | 33 ++++++++++++++++++++++++++
 .golangci.yml                       | 36 +++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 .github/workflows/golangci-lint.yml
 create mode 100644 .golangci.yml

diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
new file mode 100644
index 0000000..7984797
--- /dev/null
+++ b/.github/workflows/golangci-lint.yml
@@ -0,0 +1,33 @@
+name: golangci-lint
+on:
+  push:
+    tags:
+      - v*
+    branches: [ main ]
+    paths:
+      - '**.go'
+      - .golangci.yml
+      - .github/workflows/golangci-lint.yml
+  pull_request:
+    branches: [ main ]
+    paths:
+      - '**.go'
+      - .golangci.yml
+      - .github/workflows/golangci-lint.yml
+
+jobs:
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          go-version: ^1.18
+
+      - uses: actions/checkout@v3
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3.1.0
+        with:
+          version: v1.45.2
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000..b44d546
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,36 @@
+run:
+  deadline: 5m
+  skip-files:
+    # Skip autogenerated files.
+    - ^.*\.(pb|y)\.go$
+
+output:
+  sort-results: true
+
+linters:
+  enable:
+    - depguard
+    - godot
+    - gofumpt
+    - goimports
+    - revive
+    - whitespace
+    - misspell
+
+issues:
+  exclude-rules:
+    - path: _test.go
+      linters:
+        - errcheck
+
+linters-settings:
+  depguard:
+    list-type: blacklist
+    include-go-root: true
+    packages-with-error-message: []
+  goimports:
+    local-prefixes: github.com/segmentio/stats
+  gofumpt:
+    extra-rules: true
+  misspell:
+    locale: US

From a914c9c3655c1dc9c6ec69eca1ee23a05d9c3bb2 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Sat, 30 Apr 2022 10:59:03 -0600
Subject: [PATCH 15/63] rename

---
 .github/workflows/{test.yml => go.yml} | 0
 .github/workflows/golangci-lint.yml    | 1 -
 2 files changed, 1 deletion(-)
 rename .github/workflows/{test.yml => go.yml} (100%)

diff --git a/.github/workflows/test.yml b/.github/workflows/go.yml
similarity index 100%
rename from .github/workflows/test.yml
rename to .github/workflows/go.yml
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 7984797..63e7f80 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -9,7 +9,6 @@ on:
       - .golangci.yml
       - .github/workflows/golangci-lint.yml
   pull_request:
-    branches: [ main ]
     paths:
       - '**.go'
       - .golangci.yml

From 6d406e47e569a8332145db2e5041297ec91e1904 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Sat, 30 Apr 2022 11:09:24 -0600
Subject: [PATCH 16/63] don't run golangci-lint against all PR yet

---
 .github/workflows/golangci-lint.yml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 63e7f80..97beb81 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -8,11 +8,6 @@ on:
       - '**.go'
       - .golangci.yml
       - .github/workflows/golangci-lint.yml
-  pull_request:
-    paths:
-      - '**.go'
-      - .golangci.yml
-      - .github/workflows/golangci-lint.yml
 
 jobs:
   lint:

From d64705c7a88da2a5e6d537875537236f619a1424 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Sat, 30 Apr 2022 11:14:21 -0600
Subject: [PATCH 17/63] main -> master

---
 .github/workflows/golangci-lint.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 97beb81..2dba976 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -3,7 +3,7 @@ on:
   push:
     tags:
       - v*
-    branches: [ main ]
+    branches: [ master ]
     paths:
       - '**.go'
       - .golangci.yml

From e43ec51a93a18f7bd8f9c5c01be0c880612456f9 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Thu, 28 Apr 2022 21:38:04 -0600
Subject: [PATCH 18/63] Add an OpenTelemetry handler

This PR adds a first version of an OpenTelemetry handler. This handler
implement the otlp protocol with an HTTP Client.

There are few caveats with the current implementation:
- It only supports HTTP but GRPC should be easy enough to add later if needed.
- The client is written in a fire-and-forget fashion, meaning that metrics
will be sent once even if there is a failure when sending the request.
- The handler only support backends which expect cumulative values such as Prometheus.
---
 .otel/config.yaml  |  28 +++
 docker-compose.yml |  23 ++-
 go.mod             |  21 ++-
 go.sum             | 414 ++++++++++++++++++++++++++++++++++++++++++++-
 otlp/client.go     |  91 ++++++++++
 otlp/handler.go    | 188 ++++++++++++++++++++
 otlp/measure.go    | 122 +++++++++++++
 otlp/metric.go     |  76 +++++++++
 otlp/otlp_test.go  | 207 +++++++++++++++++++++++
 9 files changed, 1157 insertions(+), 13 deletions(-)
 create mode 100644 .otel/config.yaml
 create mode 100644 otlp/client.go
 create mode 100644 otlp/handler.go
 create mode 100644 otlp/measure.go
 create mode 100644 otlp/metric.go
 create mode 100644 otlp/otlp_test.go

diff --git a/.otel/config.yaml b/.otel/config.yaml
new file mode 100644
index 0000000..d2f7d16
--- /dev/null
+++ b/.otel/config.yaml
@@ -0,0 +1,28 @@
+receivers:
+  otlp:
+    protocols:
+      grpc:
+      http:
+        endpoint: 0.0.0.0:4318
+
+processors:
+  batch:
+
+exporters:
+  logging:
+    logLevel: debug
+
+  prometheus:
+    endpoint: "0.0.0.0:4319"
+
+service:
+  telemetry:
+    logs:
+      level: "debug"
+
+  pipelines:
+    metrics:
+      receivers: [otlp]
+      processors: []
+      exporters: [logging, prometheus]
+
diff --git a/docker-compose.yml b/docker-compose.yml
index 7db821a..f696e7c 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,5 +1,18 @@
-influxdb:
-  image: influxdb:alpine
-  ports:
-    - 8086:8086
-
+services:
+  influxdb:
+    image: influxdb:alpine
+    ports:
+      - 8086:8086
+  
+  otel-collector:
+    image: otel/opentelemetry-collector:0.48.0
+    command:
+      - "/otelcol"
+      - "--config=/etc/otel-config.yaml"
+    ports:
+      - 4317:4317
+      - 4318:4318
+      - 4319:4319
+      - 8888:8888
+    volumes:
+      - "./.otel/config.yaml:/etc/otel-config.yaml"
diff --git a/go.mod b/go.mod
index c2515de..092f10c 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,24 @@ require (
 	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
-	github.com/stretchr/testify v1.4.0
+	github.com/stretchr/testify v1.7.0
+	go.opentelemetry.io/proto/otlp v0.15.0
+	google.golang.org/protobuf v1.28.0
 )
 
-go 1.13
+require (
+	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 // indirect
+	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
+	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect
+	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
+	golang.org/x/text v0.3.5 // indirect
+	google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 // indirect
+	google.golang.org/grpc v1.43.0 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
+)
+
+go 1.18
diff --git a/go.sum b/go.sum
index b1bffae..232a529 100644
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,136 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
+github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 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/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ=
+github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 h1:BZHcxBETFHIdVyhyEfOvn/RdU/QGdLI4y34qQGjGWO0=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+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=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 h1:QYJTEbSDJvDBQenHYMxoiBQPgZ4QUcm75vACe3dkW7o=
 github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851/go.mod h1:EsbsAEUEs15qC1cosAwxgCWV0Qhd8TmkxnA9Kw1Vhl4=
 github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c h1:qYXI+3AN4zBWsTF5drEu1akWPu2juaXPs58tZ4/GaCg=
@@ -10,25 +139,298 @@ github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4Z
 github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA=
 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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e h1:uO75wNGioszjmIzcY/tvdDYKRLVvzggtAmmJkn9j4GQ=
 github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e/go.mod h1:tm/wZFQ8e24NYaBGIlnO2WGCAi67re4HHuOm0sftE/M=
 github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RXOM=
 github.com/segmentio/objconv v1.0.1/go.mod h1:auayaH5k3137Cl4SoXTgrzQcuQDmvuVtZgS0fb1Ahys=
 github.com/segmentio/vpcinfo v0.1.10 h1:iCfT3tS4h2M7WLWmzFGKysZh0ql0B8XdiHYqiPN4ke4=
 github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp978tICtquqU=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 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=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
+go.opentelemetry.io/proto/otlp v0.15.0 h1:h0bKrvdrT/9sBwEJ6iWUqT/N/xPcS66bL4u3isneJ6w=
+go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190313220215-9f648a60d977 h1:actzWV6iWn3GLqN8dZjzsB+CLt+gaV2+wsxroxiQI8I=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313 h1:pczuHS43Cp2ktBEEmLwScxgjWsBSzdaQiKzUyf3DTTc=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5 h1:i6eZZ+zk0SOf0xgBpEpPD18qWcJda6q1sxt3S0kzyUQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 h1:b9mVrqYfq3P4bCdaLg1qtBnPzUYgglsIdjZkL/fQVOE=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
+google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
+google.golang.org/grpc v1.43.0 h1:Eeu7bZtDZ2DpRCsLhUlcrLnvYaMK1Gz86a+hMVvELmM=
+google.golang.org/grpc v1.43.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/otlp/client.go b/otlp/client.go
new file mode 100644
index 0000000..02d3990
--- /dev/null
+++ b/otlp/client.go
@@ -0,0 +1,91 @@
+package otlp
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+
+	colmetricpb "go.opentelemetry.io/proto/otlp/collector/metrics/v1"
+	"google.golang.org/protobuf/proto"
+)
+
+type Client interface {
+	Handle(context.Context, *colmetricpb.ExportMetricsServiceRequest) error
+}
+
+// HTTPClient implements the Client interface and is used to export metrics to
+// an OpenTelemetry Collector through the HTTP interface.
+//
+// The current implementation is a fire and forget approach where we do not retry
+// or buffer any failed-to-flush data on the client.
+type HTTPClient struct {
+	client   *http.Client
+	endpoint string
+}
+
+func NewHTTPClient(endpoint string) *HTTPClient {
+	return &HTTPClient{
+		//TODO: add sane default timeout configuration.
+		client:   http.DefaultClient,
+		endpoint: endpoint,
+	}
+}
+
+func (c *HTTPClient) Handle(ctx context.Context, request *colmetricpb.ExportMetricsServiceRequest) error {
+	println(request)
+	rawReq, err := proto.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("failed to marshal request: %s", err)
+	}
+
+	httpReq, err := newRequest(c.endpoint, rawReq)
+	if err != nil {
+		return fmt.Errorf("failed to create HTTP request: %s", err)
+	}
+
+	return c.do(httpReq)
+}
+
+//TODO: deal with requests failures and retries. We potentially want to implement
+//      some kind of retry mechanism with expotential backoff + short time window.
+func (c *HTTPClient) do(req *http.Request) error {
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	msg, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to send data to collector, code: %d, error: %s",
+			resp.StatusCode,
+			string(msg),
+		)
+	}
+
+	return nil
+}
+
+func newRequest(endpoint string, data []byte) (*http.Request, error) {
+	u, err := url.Parse(endpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest(http.MethodPost, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/x-protobuf")
+
+	req.Body = ioutil.NopCloser(bytes.NewReader(data))
+	return req, nil
+}
diff --git a/otlp/handler.go b/otlp/handler.go
new file mode 100644
index 0000000..b6c439b
--- /dev/null
+++ b/otlp/handler.go
@@ -0,0 +1,188 @@
+package otlp
+
+import (
+	"container/list"
+	"context"
+	"fmt"
+	"hash/maphash"
+	"sync"
+	"time"
+
+	"github.com/segmentio/stats/v4"
+	colmetricpb "go.opentelemetry.io/proto/otlp/collector/metrics/v1"
+	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
+)
+
+const (
+	// DefaultMaxMetrics is the default maximum of metrics kept in memory
+	// by the handler.
+	DefaultMaxMetrics = 5000
+
+	// DefaultFlushInterval is the default interval to flush the metrics
+	// to the OpenTelemetry destination.
+	DefaultFlushInterval = 10 * time.Second
+)
+
+// Handler implement stats.Handler to be used to forward metrics to an
+// OpenTelemetry destination. Usually an OpenTelemetry Collector.
+//
+// With the current implementation this Handler is targeting a Prometheus
+// based backend or any backend expecting cumulative value.
+//
+// This Handler leverages a double linked list with a map to implement
+// a ring buffer with a lookup to ensure a low memory usage.
+type Handler struct {
+	Client        Client
+	Context       context.Context
+	FlushInterval time.Duration
+	MaxMetrics    int
+
+	once sync.Once
+
+	ordered list.List
+	metrics map[uint64]*list.Element
+}
+
+var (
+	hashseed = maphash.MakeSeed()
+)
+
+// NewHandler return an instance of Handler with the default client,
+// flush interval and in-memory metrics limit.
+func NewHandler(ctx context.Context, endpoint string) *Handler {
+	return &Handler{
+		Client:        NewHTTPClient(endpoint),
+		Context:       ctx,
+		FlushInterval: DefaultFlushInterval,
+		MaxMetrics:    DefaultMaxMetrics,
+	}
+}
+
+func (h *Handler) HandlerMeasure(t time.Time, measures ...stats.Measure) {
+	h.once.Do(func() {
+		if h.FlushInterval == 0 {
+			return
+		}
+
+		go h.start(h.Context)
+	})
+
+	h.handleMeasures(t, measures...)
+}
+
+func (h *Handler) start(ctx context.Context) {
+	t := time.NewTicker(h.FlushInterval)
+
+	for {
+		select {
+		case <-t.C:
+			h.flush()
+		case <-ctx.Done():
+			h.flush()
+			return
+		}
+	}
+}
+
+func (h *Handler) handleMeasures(t time.Time, measures ...stats.Measure) {
+	for _, measure := range measures {
+		for _, field := range measure.Fields {
+			m := metric{
+				time:        t,
+				measureName: measure.Name,
+				fieldName:   field.Name,
+				fieldType:   field.Type(),
+				tags:        measure.Tags,
+				value:       field.Value,
+			}
+
+			if field.Type() == stats.Histogram {
+				k := stats.Key{Measure: measure.Name, Field: field.Name}
+				m.sum = valueOf(m.value)
+				m.buckets = makeMetricBuckets(stats.Buckets[k])
+				m.buckets.update(valueOf(m.value))
+				m.count++
+			}
+
+			sign := m.signature()
+			m.sign = sign
+
+			known := h.lookup(sign, func(a *metric) *metric {
+				switch a.fieldType {
+				case stats.Counter:
+					a.value = a.add(m.value)
+				case stats.Histogram:
+					a.sum += valueOf(m.value)
+					a.count++
+					for i := range a.buckets {
+						a.buckets[i].count += m.buckets[i].count
+					}
+				}
+				return a
+			})
+
+			if known == nil {
+				h.push(sign, &m)
+			}
+		}
+	}
+}
+
+func (h *Handler) flush() error {
+	metrics := []*metricpb.Metric{}
+
+	for e := h.ordered.Front(); e != nil; e = e.Next() {
+		m := e.Value.(*metric)
+		if m.flushed {
+			continue
+		}
+		metrics = append(metrics, convertMetrics(*m)...)
+		m.flushed = true
+	}
+
+	if len(metrics) == 0 {
+		return nil
+	}
+
+	//FIXME how big a metrics service requests can be ? need pagination ?
+	request := &colmetricpb.ExportMetricsServiceRequest{
+		ResourceMetrics: []*metricpb.ResourceMetrics{
+			{
+				ScopeMetrics: []*metricpb.ScopeMetrics{
+					{Metrics: metrics},
+				},
+			},
+		},
+	}
+
+	if err := h.Client.Handle(h.Context, request); err != nil {
+		return fmt.Errorf("failed to flush measures: %s", err)
+	}
+
+	return nil
+}
+
+func (h *Handler) lookup(signature uint64, update func(*metric) *metric) *metric {
+	if m := h.metrics[signature]; m != nil {
+		h.ordered.MoveToFront(m)
+		m.Value = update(m.Value.(*metric))
+		return m.Value.(*metric)
+	}
+
+	return nil
+}
+
+func (h *Handler) push(sign uint64, m *metric) {
+	if h.metrics == nil {
+		h.metrics = map[uint64]*list.Element{}
+	}
+
+	element := h.ordered.PushFront(m)
+	h.metrics[sign] = element
+
+	if len(h.metrics) > h.MaxMetrics {
+		last := h.ordered.Back()
+		h.ordered.Remove(last)
+		delete(h.metrics, last.Value.(*metric).sign)
+	}
+}
diff --git a/otlp/measure.go b/otlp/measure.go
new file mode 100644
index 0000000..4578591
--- /dev/null
+++ b/otlp/measure.go
@@ -0,0 +1,122 @@
+package otlp
+
+import (
+	"fmt"
+
+	"github.com/segmentio/stats/v4"
+	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
+	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
+)
+
+func convertMetrics(metrics ...metric) []*metricpb.Metric {
+	mm := []*metricpb.Metric{}
+
+	for _, metric := range metrics {
+		attributes := tagsToAttributes(metric.tags...)
+
+		m := &metricpb.Metric{
+			Name: fmt.Sprintf("%s.%s", metric.measureName, metric.fieldName),
+		}
+
+		switch metric.fieldType {
+		case stats.Counter:
+			if m.Data == nil {
+				m.Data = &metricpb.Metric_Sum{
+					Sum: &metricpb.Sum{
+						AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
+						DataPoints:             []*metricpb.NumberDataPoint{},
+					},
+				}
+			}
+
+			sum := m.GetSum()
+			sum.DataPoints = append(sum.DataPoints, &metricpb.NumberDataPoint{
+				TimeUnixNano: uint64(metric.time.UnixNano()),
+				Value:        &metricpb.NumberDataPoint_AsDouble{AsDouble: valueOf(metric.value)},
+				Attributes:   attributes,
+			})
+		case stats.Gauge:
+			if m.Data == nil {
+				m.Data = &metricpb.Metric_Gauge{
+					Gauge: &metricpb.Gauge{
+						DataPoints: []*metricpb.NumberDataPoint{},
+					},
+				}
+			}
+
+			gauge := m.GetGauge()
+			gauge.DataPoints = append(gauge.DataPoints, &metricpb.NumberDataPoint{
+				TimeUnixNano: uint64(metric.time.UnixNano()),
+				Value:        &metricpb.NumberDataPoint_AsDouble{AsDouble: valueOf(metric.value)},
+				Attributes:   attributes,
+			})
+		case stats.Histogram:
+			if m.Data == nil {
+				m.Data = &metricpb.Metric_Histogram{
+					Histogram: &metricpb.Histogram{
+						AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
+						DataPoints:             []*metricpb.HistogramDataPoint{},
+					},
+				}
+			}
+
+			explicitBounds := make([]float64, len(metric.buckets))
+			bucketCounts := make([]uint64, len(metric.buckets))
+
+			for i, b := range metric.buckets {
+				explicitBounds[i] = b.upperBound
+				bucketCounts[i] = b.count
+			}
+
+			histogram := m.GetHistogram()
+			histogram.DataPoints = append(histogram.DataPoints, &metricpb.HistogramDataPoint{
+				TimeUnixNano:   uint64(metric.time.UnixNano()),
+				Sum:            &metric.sum,
+				Count:          metric.count,
+				ExplicitBounds: explicitBounds,
+				BucketCounts:   bucketCounts,
+			})
+
+		default:
+		}
+
+		mm = append(mm, m)
+	}
+
+	return mm
+}
+
+func valueOf(v stats.Value) float64 {
+	switch v.Type() {
+	case stats.Bool:
+		if v.Bool() {
+			return 1.0
+		}
+	case stats.Int:
+		return float64(v.Int())
+	case stats.Uint:
+		return float64(v.Uint())
+	case stats.Float:
+		return v.Float()
+	case stats.Duration:
+		return v.Duration().Seconds()
+	}
+	return 0.0
+}
+
+func tagsToAttributes(tags ...stats.Tag) []*commonpb.KeyValue {
+	attr := make([]*commonpb.KeyValue, 0, len(tags))
+
+	for _, tag := range tags {
+		attr = append(attr, &commonpb.KeyValue{
+			Key: tag.Name,
+			Value: &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_StringValue{
+					StringValue: tag.Value,
+				},
+			},
+		})
+	}
+
+	return attr
+}
diff --git a/otlp/metric.go b/otlp/metric.go
new file mode 100644
index 0000000..57fbdeb
--- /dev/null
+++ b/otlp/metric.go
@@ -0,0 +1,76 @@
+package otlp
+
+import (
+	"hash/maphash"
+	"sort"
+	"time"
+
+	"github.com/segmentio/stats/v4"
+)
+
+type metric struct {
+	measureName string
+	fieldName   string
+	fieldType   stats.FieldType
+	flushed     bool
+	time        time.Time
+	value       stats.Value
+	sum         float64
+	sign        uint64
+	count       uint64
+	buckets     metricBuckets
+	tags        []stats.Tag
+}
+
+func (m *metric) signature() uint64 {
+	h := maphash.Hash{}
+	h.SetSeed(hashseed)
+	h.WriteString(m.measureName)
+	h.WriteString(m.fieldName)
+
+	sort.Slice(m.tags, func(i, j int) bool {
+		return m.tags[i].Name > m.tags[j].Name
+	})
+
+	for _, tag := range m.tags {
+		h.WriteString(tag.String())
+	}
+
+	return h.Sum64()
+}
+
+func (m *metric) add(v stats.Value) stats.Value {
+	switch v.Type() {
+	case stats.Int:
+		return stats.ValueOf(m.value.Int() + v.Int())
+	case stats.Uint:
+		return stats.ValueOf(m.value.Uint() + v.Uint())
+	case stats.Float:
+		return stats.ValueOf(m.value.Float() + v.Float())
+	}
+	return v
+}
+
+type bucket struct {
+	count      uint64
+	upperBound float64
+}
+
+type metricBuckets []bucket
+
+func makeMetricBuckets(buckets []stats.Value) metricBuckets {
+	b := make(metricBuckets, len(buckets))
+	for i := range buckets {
+		b[i].upperBound = valueOf(buckets[i])
+	}
+	return b
+}
+
+func (b metricBuckets) update(v float64) {
+	for i := range b {
+		if v <= b[i].upperBound {
+			b[i].count++
+			break
+		}
+	}
+}
diff --git a/otlp/otlp_test.go b/otlp/otlp_test.go
new file mode 100644
index 0000000..62ec360
--- /dev/null
+++ b/otlp/otlp_test.go
@@ -0,0 +1,207 @@
+package otlp
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/segmentio/stats/v4"
+	colmetricpb "go.opentelemetry.io/proto/otlp/collector/metrics/v1"
+	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
+)
+
+type testCase struct {
+	in  []stats.Measure
+	out []*metricpb.Metric
+}
+
+var (
+	now         = time.Now()
+	handleTests = []testCase{
+		{
+			in: []stats.Measure{
+				{
+					Name:   "foobar",
+					Fields: []stats.Field{stats.MakeField("count", 1, stats.Counter)},
+					Tags:   []stats.Tag{{Name: "env", Value: "dev"}},
+				},
+				{
+					Name:   "foobar",
+					Fields: []stats.Field{stats.MakeField("count", 1, stats.Counter)},
+					Tags:   []stats.Tag{{Name: "env", Value: "dev"}},
+				},
+			},
+			out: []*metricpb.Metric{
+				{
+					Name: "foobar.count",
+					Data: &metricpb.Metric_Sum{
+						Sum: &metricpb.Sum{
+							AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
+							DataPoints: []*metricpb.NumberDataPoint{
+								{
+									TimeUnixNano: uint64(now.UnixNano()),
+									Value:        &metricpb.NumberDataPoint_AsDouble{AsDouble: 2},
+									Attributes:   tagsToAttributes(stats.T("env", "dev")),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			in: []stats.Measure{
+				{
+					Name: "foobar",
+					Fields: []stats.Field{
+						stats.MakeField("hist", 5, stats.Histogram),
+						stats.MakeField("hist", 10, stats.Histogram),
+						stats.MakeField("hist", 20, stats.Histogram),
+					},
+					Tags: []stats.Tag{{Name: "region", Value: "us-west-2"}},
+				},
+			},
+			out: []*metricpb.Metric{
+				{
+					Name: "foobar.hist",
+					Data: &metricpb.Metric_Histogram{
+						Histogram: &metricpb.Histogram{
+							AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
+							DataPoints: []*metricpb.HistogramDataPoint{
+								{
+									TimeUnixNano:   uint64(now.UnixNano()),
+									Count:          3,
+									Sum:            sumPtr(35),
+									BucketCounts:   []uint64{0, 2, 1, 0},
+									ExplicitBounds: []float64{0, 10, 100, 1000},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			in: []stats.Measure{
+				{
+					Name: "foobar",
+					Fields: []stats.Field{
+						stats.MakeField("gauge", 42, stats.Gauge),
+					},
+					Tags: []stats.Tag{{Name: "env", Value: "dev"}},
+				},
+			},
+			out: []*metricpb.Metric{
+				{
+					Name: "foobar.gauge",
+					Data: &metricpb.Metric_Gauge{
+						Gauge: &metricpb.Gauge{
+							DataPoints: []*metricpb.NumberDataPoint{
+								{
+									TimeUnixNano: uint64(now.UnixNano()),
+									Value:        &metricpb.NumberDataPoint_AsDouble{AsDouble: 42},
+									Attributes:   tagsToAttributes(stats.T("env", "dev")),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+)
+
+func sumPtr(f float64) *float64 {
+	return &f
+}
+
+var conversionTests = []testCase{}
+
+func initTest() {
+	stats.Buckets.Set("foobar.hist",
+		0,
+		10,
+		100,
+		1000,
+	)
+}
+
+func TestHandler(t *testing.T) {
+	initTest()
+
+	ctx, cancel := context.WithCancel(context.TODO())
+	defer cancel()
+
+	for i, test := range handleTests {
+		t.Run(fmt.Sprintf("handle-%d", i), func(t *testing.T) {
+			h := Handler{
+				Client: &client{
+					expected: test.out,
+				},
+				Context: ctx,
+			}
+
+			h.handleMeasures(now, test.in...)
+
+			if err := h.flush(); err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+type client struct {
+	expected []*metricpb.Metric
+}
+
+func (c *client) Handle(ctx context.Context, request *colmetricpb.ExportMetricsServiceRequest) error {
+	for _, rm := range request.GetResourceMetrics() {
+		for _, sm := range rm.GetScopeMetrics() {
+			metrics := sm.GetMetrics()
+			if !reflect.DeepEqual(metrics, c.expected) {
+				return fmt.Errorf(
+					"unexpected metrics in request\nexpected: %v\ngot:%v\n",
+					c.expected,
+					metrics,
+				)
+			}
+		}
+	}
+	return nil
+}
+
+// run go test -with-collector with a running local otel collector to help with testing.
+var withCollector = flag.Bool("with-collector", false, "send metrics to a local collector")
+
+func TestSendOtel(t *testing.T) {
+	if !*withCollector {
+		t.SkipNow()
+	}
+
+	initTest()
+	ctx, cancel := context.WithCancel(context.TODO())
+	defer cancel()
+
+	h := Handler{
+		Client: &HTTPClient{
+			client:   http.DefaultClient,
+			endpoint: "http://localhost:4318/v1/metrics",
+		},
+		Context:    ctx,
+		MaxMetrics: 10,
+	}
+
+	for i, test := range handleTests {
+		t.Run(fmt.Sprintf("handle-%d", i), func(t *testing.T) {
+			h.HandlerMeasure(now, test.in...)
+		})
+	}
+
+	if err := h.flush(); err != nil {
+		t.Error(err)
+	}
+}

From a3d6e3bcde289fb2d934c3117b9891b017d9fe02 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Fri, 29 Apr 2022 16:16:02 -0600
Subject: [PATCH 19/63] Review feedback

---
 otlp/client.go  |  7 +++----
 otlp/handler.go | 33 ++++++++++++++++++++++++++-------
 otlp/measure.go |  4 +---
 3 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/otlp/client.go b/otlp/client.go
index 02d3990..65b6267 100644
--- a/otlp/client.go
+++ b/otlp/client.go
@@ -35,13 +35,12 @@ func NewHTTPClient(endpoint string) *HTTPClient {
 }
 
 func (c *HTTPClient) Handle(ctx context.Context, request *colmetricpb.ExportMetricsServiceRequest) error {
-	println(request)
 	rawReq, err := proto.Marshal(request)
 	if err != nil {
 		return fmt.Errorf("failed to marshal request: %s", err)
 	}
 
-	httpReq, err := newRequest(c.endpoint, rawReq)
+	httpReq, err := newRequest(ctx, c.endpoint, rawReq)
 	if err != nil {
 		return fmt.Errorf("failed to create HTTP request: %s", err)
 	}
@@ -73,13 +72,13 @@ func (c *HTTPClient) do(req *http.Request) error {
 	return nil
 }
 
-func newRequest(endpoint string, data []byte) (*http.Request, error) {
+func newRequest(ctx context.Context, endpoint string, data []byte) (*http.Request, error) {
 	u, err := url.Parse(endpoint)
 	if err != nil {
 		return nil, err
 	}
 
-	req, err := http.NewRequest(http.MethodPost, u.String(), nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, u.String(), nil)
 	if err != nil {
 		return nil, err
 	}
diff --git a/otlp/handler.go b/otlp/handler.go
index b6c439b..3e83a26 100644
--- a/otlp/handler.go
+++ b/otlp/handler.go
@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"hash/maphash"
+	"log"
 	"sync"
 	"time"
 
@@ -23,11 +24,11 @@ const (
 	DefaultFlushInterval = 10 * time.Second
 )
 
-// Handler implement stats.Handler to be used to forward metrics to an
+// Handler implements stats.Handler to be used to forward metrics to an
 // OpenTelemetry destination. Usually an OpenTelemetry Collector.
 //
 // With the current implementation this Handler is targeting a Prometheus
-// based backend or any backend expecting cumulative value.
+// based backend or any backend expecting cumulative values.
 //
 // This Handler leverages a double linked list with a map to implement
 // a ring buffer with a lookup to ensure a low memory usage.
@@ -39,6 +40,7 @@ type Handler struct {
 
 	once sync.Once
 
+	mu      sync.RWMutex
 	ordered list.List
 	metrics map[uint64]*list.Element
 }
@@ -71,6 +73,8 @@ func (h *Handler) HandlerMeasure(t time.Time, measures ...stats.Measure) {
 }
 
 func (h *Handler) start(ctx context.Context) {
+	defer h.flush()
+
 	t := time.NewTicker(h.FlushInterval)
 
 	for {
@@ -78,8 +82,7 @@ func (h *Handler) start(ctx context.Context) {
 		case <-t.C:
 			h.flush()
 		case <-ctx.Done():
-			h.flush()
-			return
+			break
 		}
 	}
 }
@@ -122,13 +125,21 @@ func (h *Handler) handleMeasures(t time.Time, measures ...stats.Measure) {
 			})
 
 			if known == nil {
-				h.push(sign, &m)
+				n := h.push(sign, &m)
+				if n > h.MaxMetrics {
+					if err := h.flush(); err != nil {
+						log.Printf("stats/otlp: %s", err)
+					}
+				}
 			}
 		}
 	}
 }
 
 func (h *Handler) flush() error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
 	metrics := []*metricpb.Metric{}
 
 	for e := h.ordered.Front(); e != nil; e = e.Next() {
@@ -144,7 +155,7 @@ func (h *Handler) flush() error {
 		return nil
 	}
 
-	//FIXME how big a metrics service requests can be ? need pagination ?
+	//FIXME how big can a metrics service request be ? need pagination ?
 	request := &colmetricpb.ExportMetricsServiceRequest{
 		ResourceMetrics: []*metricpb.ResourceMetrics{
 			{
@@ -163,6 +174,9 @@ func (h *Handler) flush() error {
 }
 
 func (h *Handler) lookup(signature uint64, update func(*metric) *metric) *metric {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
 	if m := h.metrics[signature]; m != nil {
 		h.ordered.MoveToFront(m)
 		m.Value = update(m.Value.(*metric))
@@ -172,7 +186,10 @@ func (h *Handler) lookup(signature uint64, update func(*metric) *metric) *metric
 	return nil
 }
 
-func (h *Handler) push(sign uint64, m *metric) {
+func (h *Handler) push(sign uint64, m *metric) int {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
 	if h.metrics == nil {
 		h.metrics = map[uint64]*list.Element{}
 	}
@@ -185,4 +202,6 @@ func (h *Handler) push(sign uint64, m *metric) {
 		h.ordered.Remove(last)
 		delete(h.metrics, last.Value.(*metric).sign)
 	}
+
+	return len(h.metrics)
 }
diff --git a/otlp/measure.go b/otlp/measure.go
index 4578591..49251a2 100644
--- a/otlp/measure.go
+++ b/otlp/measure.go
@@ -1,8 +1,6 @@
 package otlp
 
 import (
-	"fmt"
-
 	"github.com/segmentio/stats/v4"
 	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
 	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
@@ -15,7 +13,7 @@ func convertMetrics(metrics ...metric) []*metricpb.Metric {
 		attributes := tagsToAttributes(metric.tags...)
 
 		m := &metricpb.Metric{
-			Name: fmt.Sprintf("%s.%s", metric.measureName, metric.fieldName),
+			Name: metric.measureName + "." + metric.fieldName,
 		}
 
 		switch metric.fieldType {

From 036a33f716e30cfc96f79bae43e210db564d65c8 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Mon, 2 May 2022 11:47:09 -0600
Subject: [PATCH 20/63] update doc

---
 otlp/handler.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/otlp/handler.go b/otlp/handler.go
index 3e83a26..abd47c0 100644
--- a/otlp/handler.go
+++ b/otlp/handler.go
@@ -21,6 +21,9 @@ const (
 
 	// DefaultFlushInterval is the default interval to flush the metrics
 	// to the OpenTelemetry destination.
+	//
+	// Metrics will be flushed to the destination when DefaultFlushInterval or
+	// DefaultMaxMetrics are reach. Whichever comes first.
 	DefaultFlushInterval = 10 * time.Second
 )
 
@@ -80,7 +83,9 @@ func (h *Handler) start(ctx context.Context) {
 	for {
 		select {
 		case <-t.C:
-			h.flush()
+			if err := h.flush(); err != nil {
+				log.Printf("stats/otlp: %s", err)
+			}
 		case <-ctx.Done():
 			break
 		}

From 1b4a516f7cf9d6ebd6fb31521d75beb86cdf7ea2 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Mon, 2 May 2022 11:49:10 -0600
Subject: [PATCH 21/63] add user-agent

---
 otlp/client.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/otlp/client.go b/otlp/client.go
index 65b6267..f816e45 100644
--- a/otlp/client.go
+++ b/otlp/client.go
@@ -84,6 +84,7 @@ func newRequest(ctx context.Context, endpoint string, data []byte) (*http.Reques
 	}
 
 	req.Header.Set("Content-Type", "application/x-protobuf")
+	req.Header.Set("User-Agent", "segmentio/stats")
 
 	req.Body = ioutil.NopCloser(bytes.NewReader(data))
 	return req, nil

From 7333338f69e2b2ae325570725906779eff3d7018 Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Mon, 2 May 2022 13:28:32 -0600
Subject: [PATCH 22/63] feedback 2

---
 otlp/handler.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/otlp/handler.go b/otlp/handler.go
index abd47c0..52f413a 100644
--- a/otlp/handler.go
+++ b/otlp/handler.go
@@ -23,7 +23,7 @@ const (
 	// to the OpenTelemetry destination.
 	//
 	// Metrics will be flushed to the destination when DefaultFlushInterval or
-	// DefaultMaxMetrics are reach. Whichever comes first.
+	// DefaultMaxMetrics are reached, whichever comes first.
 	DefaultFlushInterval = 10 * time.Second
 )
 
@@ -33,7 +33,7 @@ const (
 // With the current implementation this Handler is targeting a Prometheus
 // based backend or any backend expecting cumulative values.
 //
-// This Handler leverages a double linked list with a map to implement
+// This Handler leverages a doubly linked list with a map to implement
 // a ring buffer with a lookup to ensure a low memory usage.
 type Handler struct {
 	Client        Client

From f4857757f1b79891f5c5c655a7808faef02eb40b Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Tue, 3 May 2022 16:14:02 -0600
Subject: [PATCH 23/63] add disclaimer

---
 otlp/handler.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/otlp/handler.go b/otlp/handler.go
index 52f413a..ada5323 100644
--- a/otlp/handler.go
+++ b/otlp/handler.go
@@ -27,6 +27,9 @@ const (
 	DefaultFlushInterval = 10 * time.Second
 )
 
+// Status: Alpha. This Handler is still in heavy development phase.
+//         Do not use in production.
+//
 // Handler implements stats.Handler to be used to forward metrics to an
 // OpenTelemetry destination. Usually an OpenTelemetry Collector.
 //

From 088dc63fbf7b46e74e8bc6b9ddb0246d25dd42be Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 11:06:50 -0400
Subject: [PATCH 24/63] Add stretcher/testify

---
 go.mod | 6 +++---
 go.sum | 8 ++++++++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/go.mod b/go.mod
index 092f10c..b0d459b 100644
--- a/go.mod
+++ b/go.mod
@@ -5,13 +5,13 @@ require (
 	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
-	github.com/stretchr/testify v1.7.0
+	github.com/stretchr/testify v1.8.0
 	go.opentelemetry.io/proto/otlp v0.15.0
 	google.golang.org/protobuf v1.28.0
 )
 
 require (
-	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 // indirect
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
@@ -22,7 +22,7 @@ require (
 	golang.org/x/text v0.3.5 // indirect
 	google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 // indirect
 	google.golang.org/grpc v1.43.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
 go 1.18
diff --git a/go.sum b/go.sum
index 232a529..f86d0e5 100644
--- a/go.sum
+++ b/go.sum
@@ -51,6 +51,8 @@ github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWH
 github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 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/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/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -150,10 +152,14 @@ github.com/segmentio/vpcinfo v0.1.10 h1:iCfT3tS4h2M7WLWmzFGKysZh0ql0B8XdiHYqiPN4
 github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp978tICtquqU=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -424,6 +430,8 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

From dbfafe50e032a548043e6ce56d7837397e3b51c1 Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 11:07:10 -0400
Subject: [PATCH 25/63] Add FilteredHandler

---
 handler.go      | 24 +++++++++++++++++
 handler_test.go | 69 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/handler.go b/handler.go
index 2091f3b..b1514ef 100644
--- a/handler.go
+++ b/handler.go
@@ -74,6 +74,30 @@ func (m *multiHandler) Flush() {
 	}
 }
 
+// FilteredHandler constructs a Handler that processes Measures with `filter` before forwarding to `h`
+func FilteredHandler(h Handler, filter func([]Measure) []Measure) Handler {
+	return &filteredHandler{handler: h, filter: filter}
+}
+
+type filteredHandler struct {
+	handler Handler
+	filter  func([]Measure) []Measure
+}
+
+func (h *filteredHandler) HandleMeasures(time time.Time, measures ...Measure) {
+	filteredMeasures := h.filter(measures)
+
+	if len(filteredMeasures) == 0 {
+		return
+	}
+
+	h.handler.HandleMeasures(time, filteredMeasures...)
+}
+
+func (h *filteredHandler) Flush() {
+	flush(h.handler)
+}
+
 // Discard is a handler that doesn't do anything with the measures it receives.
 var Discard = &discard{}
 
diff --git a/handler_test.go b/handler_test.go
index 690ae42..5418edf 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -6,6 +6,8 @@ import (
 
 	"github.com/segmentio/stats/v4"
 	"github.com/segmentio/stats/v4/statstest"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMultiHandler(t *testing.T) {
@@ -47,3 +49,70 @@ func flush(h stats.Handler) {
 		f.Flush()
 	}
 }
+
+func TestFilteredHandler(t *testing.T) {
+	t.Run("calling HandleMeasures on a filteredHandler processes the measures with the filter", func(t *testing.T) {
+		handler := &statstest.Handler{}
+		filter := func(ms []stats.Measure) []stats.Measure {
+			measures := make([]stats.Measure, 0, len(ms))
+			for _, m := range ms {
+				fields := make([]stats.Field, 0, len(m.Fields))
+				for _, f := range m.Fields {
+					if f.Name == "a" {
+						fields = append(fields, f)
+					}
+				}
+				if len(fields) > 0 {
+					measures = append(measures, stats.Measure{Name: m.Name, Fields: fields, Tags: m.Tags})
+				}
+			}
+			return measures
+		}
+		fh := stats.FilteredHandler(handler, filter)
+		stats.Register(fh)
+
+		stats.Observe("b", 1.23)
+		assert.Equal(t, []stats.Measure{}, handler.Measures())
+
+		stats.Observe("a", 1.23)
+		assert.Equal(t, []stats.Measure{
+			{
+				Name:   "stats.test",
+				Fields: []stats.Field{stats.MakeField("a", 1.23, stats.Histogram)},
+				Tags:   nil,
+			},
+		}, handler.Measures())
+
+		stats.Incr("b")
+		assert.Equal(t, []stats.Measure{
+			{
+				Name:   "stats.test",
+				Fields: []stats.Field{stats.MakeField("a", 1.23, stats.Histogram)},
+				Tags:   nil,
+			},
+		}, handler.Measures())
+
+		stats.Incr("a")
+		assert.Equal(t, []stats.Measure{
+			{
+				Name:   "stats.test",
+				Fields: []stats.Field{stats.MakeField("a", 1.23, stats.Histogram)},
+				Tags:   nil,
+			},
+			{
+				Name:   "stats.test",
+				Fields: []stats.Field{stats.MakeField("a", 1, stats.Counter)},
+				Tags:   nil,
+			},
+		}, handler.Measures())
+	})
+
+	t.Run("calling Flush on a FilteredHandler flushes the underlying handler", func(t *testing.T) {
+		h := &statstest.Handler{}
+
+		m := stats.FilteredHandler(h, func(ms []stats.Measure) []stats.Measure { return ms })
+		flush(m)
+
+		assert.EqualValues(t, 1, h.FlushCalls(), "Flush should be called once")
+	})
+}

From 5ddd1759cdfef9549f3a85b3abe520b5390c4222 Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 11:52:05 -0400
Subject: [PATCH 26/63] Refactor AppendMeasureFiltered into a serializer method
 named AppendMeasure

---
 datadog/client.go       |  2 +-
 datadog/measure.go      | 22 ++++++++--------------
 datadog/measure_test.go |  7 +++++--
 3 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index 88bd2eb..d5a0423 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -157,7 +157,7 @@ type serializer struct {
 
 func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Measure) []byte {
 	for _, m := range measures {
-		b = AppendMeasureFiltered(b, m, s.filters, s.distPrefixes)
+		b = s.AppendMeasure(b, m)
 	}
 	return b
 }
diff --git a/datadog/measure.go b/datadog/measure.go
index aaf8ded..b0f4a6a 100644
--- a/datadog/measure.go
+++ b/datadog/measure.go
@@ -12,15 +12,9 @@ import (
 
 // AppendMeasure is a formatting routine to append the dogstatsd protocol
 // representation of a measure to a memory buffer.
-func AppendMeasure(b []byte, m stats.Measure) []byte {
-	return AppendMeasureFiltered(b, m, nil, []string{})
-}
-
-// AppendMeasureFiltered is a formatting routine to append the dogstatsd protocol
-// representation of a measure to a memory buffer. Tags listed in the filters map
-// are removed. (some tags may not be suitable for submission to DataDog)
-func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{},
-	distPrefixes []string) []byte {
+// Tags listed in the s.filters are removed. (some tags may not be suitable for submission to DataDog)
+// Histogram metrics will be sent as distribution type if the metric name matches s.distPrefixes
+func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
 	for _, field := range m.Fields {
 		b = append(b, m.Name...)
 		if len(field.Name) != 0 {
@@ -54,7 +48,7 @@ func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{
 		case stats.Gauge:
 			b = append(b, '|', 'g')
 		default:
-			if sendDist(field.Name, distPrefixes) {
+			if s.sendDist(field.Name) {
 				b = append(b, '|', 'd')
 			} else {
 				b = append(b, '|', 'h')
@@ -65,7 +59,7 @@ func AppendMeasureFiltered(b []byte, m stats.Measure, filters map[string]struct{
 			b = append(b, '|', '#')
 
 			for i, t := range m.Tags {
-				if _, ok := filters[t.Name]; !ok {
+				if _, ok := s.filters[t.Name]; !ok {
 					if i != 0 {
 						b = append(b, ',')
 					}
@@ -95,11 +89,11 @@ func normalizeFloat(f float64) float64 {
 	}
 }
 
-func sendDist(name string, distPrefixes []string) bool {
-	if distPrefixes == nil {
+func (s *serializer) sendDist(name string) bool {
+	if s.distPrefixes == nil {
 		return false
 	}
-	for _, prefix := range distPrefixes {
+	for _, prefix := range s.distPrefixes {
 		if strings.HasPrefix(name, prefix) {
 			return true
 		}
diff --git a/datadog/measure_test.go b/datadog/measure_test.go
index 7f0f8fd..7f6f1d5 100644
--- a/datadog/measure_test.go
+++ b/datadog/measure_test.go
@@ -62,9 +62,11 @@ request.rtt:0.1|h|#answer:42,hello:world
 )
 
 func TestAppendMeasure(t *testing.T) {
+	client := NewClient(DefaultAddress)
 	for _, test := range testMeasures {
 		t.Run(test.s, func(t *testing.T) {
-			if s := string(AppendMeasureFiltered(nil, test.m, nil, test.dp)); s != test.s {
+			client.distPrefixes = test.dp
+			if s := string(client.AppendMeasure(nil, test.m)); s != test.s {
 				t.Error("bad metric representation:")
 				t.Log("expected:", test.s)
 				t.Log("found:   ", s)
@@ -99,9 +101,10 @@ var (
 )
 
 func TestSendDist(t *testing.T) {
+	client := NewClientWith(ClientConfig{DistributionPrefixes: distPrefixes})
 	for _, test := range testDistNames {
 		t.Run(test.n, func(t *testing.T) {
-			a := sendDist(test.n, distPrefixes)
+			a := client.sendDist(test.n)
 			if a != test.d {
 				t.Error("distribution name detection incorrect:")
 				t.Log("expected:", test.d)

From d504d6db84de90c9c6093fa3e32c2353a3b096a1 Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 11:55:05 -0400
Subject: [PATCH 27/63] Move serializer from client.go into measure.go and
 reorder functions; no semantic code changes

---
 datadog/client.go     |  67 ++----------------
 datadog/measure.go    |  82 ----------------------
 datadog/serializer.go | 154 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 158 insertions(+), 145 deletions(-)
 create mode 100644 datadog/serializer.go

diff --git a/datadog/client.go b/datadog/client.go
index d5a0423..32b4df2 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -1,16 +1,15 @@
 package datadog
 
 import (
-	"bytes"
 	"io"
 	"log"
 	"net/url"
 	"os"
 	"strings"
-	"syscall"
 	"time"
 
 	"github.com/segmentio/stats/v4"
+	"golang.org/x/sys/unix"
 )
 
 const (
@@ -148,64 +147,6 @@ func (c *Client) Close() error {
 	return c.err
 }
 
-type serializer struct {
-	w            io.WriteCloser
-	bufferSize   int
-	filters      map[string]struct{}
-	distPrefixes []string
-}
-
-func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Measure) []byte {
-	for _, m := range measures {
-		b = s.AppendMeasure(b, m)
-	}
-	return b
-}
-
-func (s *serializer) Write(b []byte) (int, error) {
-
-	if len(b) <= s.bufferSize {
-		return s.w.Write(b)
-	}
-
-	// When the serialized metrics are larger than the configured socket buffer
-	// size we split them on '\n' characters.
-	var n int
-
-	for len(b) != 0 {
-		var splitIndex int
-
-		for splitIndex != len(b) {
-			i := bytes.IndexByte(b[splitIndex:], '\n')
-			if i < 0 {
-				panic("stats/datadog: metrics are not formatted for the dogstatsd protocol")
-			}
-			if (i + splitIndex) >= s.bufferSize {
-				if splitIndex == 0 {
-					log.Printf("stats/datadog: metric of length %d B doesn't fit in the socket buffer of size %d B: %s", i+1, s.bufferSize, string(b))
-					b = b[i+1:]
-					continue
-				}
-				break
-			}
-			splitIndex += i + 1
-		}
-		c, err := s.w.Write(b[:splitIndex])
-		if err != nil {
-			return n + c, err
-		}
-
-		n += c
-		b = b[splitIndex:]
-	}
-
-	return n, nil
-}
-
-func (s *serializer) close() {
-	s.w.Close()
-}
-
 func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	fd := int(f.Fd())
 	// The kernel refuses to send UDP datagrams that are larger than the size of
@@ -213,7 +154,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	// sent in one batch we attempt to attempt to adjust the kernel buffer size
 	// to accept larger datagrams, or fallback to the default socket buffer size
 	// if it failed.
-	if bufsize, err = syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF); err != nil {
+	if bufsize, err = unix.GetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_SNDBUF); err != nil {
 		return
 	}
 
@@ -223,7 +164,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	bufsize /= 2
 
 	for sizehint > bufsize && sizehint > 0 {
-		if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, sizehint); err == nil {
+		if err := unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_SNDBUF, sizehint); err == nil {
 			bufsize = sizehint
 			break
 		}
@@ -248,7 +189,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	}
 
 	// Creating the file put the socket in blocking mode, reverting.
-	syscall.SetNonblock(fd, true)
+	unix.SetNonblock(fd, true)
 	return
 }
 
diff --git a/datadog/measure.go b/datadog/measure.go
index b0f4a6a..b516381 100644
--- a/datadog/measure.go
+++ b/datadog/measure.go
@@ -2,80 +2,10 @@ package datadog
 
 import (
 	"math"
-	"strconv"
-	"strings"
-
-	"github.com/segmentio/stats/v4"
 )
 
 // Datagram format: https://docs.datadoghq.com/developers/dogstatsd/datagram_shell
 
-// AppendMeasure is a formatting routine to append the dogstatsd protocol
-// representation of a measure to a memory buffer.
-// Tags listed in the s.filters are removed. (some tags may not be suitable for submission to DataDog)
-// Histogram metrics will be sent as distribution type if the metric name matches s.distPrefixes
-func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
-	for _, field := range m.Fields {
-		b = append(b, m.Name...)
-		if len(field.Name) != 0 {
-			b = append(b, '.')
-			b = append(b, field.Name...)
-		}
-		b = append(b, ':')
-
-		switch v := field.Value; v.Type() {
-		case stats.Bool:
-			if v.Bool() {
-				b = append(b, '1')
-			} else {
-				b = append(b, '0')
-			}
-		case stats.Int:
-			b = strconv.AppendInt(b, v.Int(), 10)
-		case stats.Uint:
-			b = strconv.AppendUint(b, v.Uint(), 10)
-		case stats.Float:
-			b = strconv.AppendFloat(b, normalizeFloat(v.Float()), 'g', -1, 64)
-		case stats.Duration:
-			b = strconv.AppendFloat(b, v.Duration().Seconds(), 'g', -1, 64)
-		default:
-			b = append(b, '0')
-		}
-
-		switch field.Type() {
-		case stats.Counter:
-			b = append(b, '|', 'c')
-		case stats.Gauge:
-			b = append(b, '|', 'g')
-		default:
-			if s.sendDist(field.Name) {
-				b = append(b, '|', 'd')
-			} else {
-				b = append(b, '|', 'h')
-			}
-		}
-
-		if n := len(m.Tags); n != 0 {
-			b = append(b, '|', '#')
-
-			for i, t := range m.Tags {
-				if _, ok := s.filters[t.Name]; !ok {
-					if i != 0 {
-						b = append(b, ',')
-					}
-					b = append(b, t.Name...)
-					b = append(b, ':')
-					b = append(b, t.Value...)
-				}
-			}
-		}
-
-		b = append(b, '\n')
-	}
-
-	return b
-}
-
 func normalizeFloat(f float64) float64 {
 	switch {
 	case math.IsNaN(f):
@@ -88,15 +18,3 @@ func normalizeFloat(f float64) float64 {
 		return f
 	}
 }
-
-func (s *serializer) sendDist(name string) bool {
-	if s.distPrefixes == nil {
-		return false
-	}
-	for _, prefix := range s.distPrefixes {
-		if strings.HasPrefix(name, prefix) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/datadog/serializer.go b/datadog/serializer.go
new file mode 100644
index 0000000..969a80d
--- /dev/null
+++ b/datadog/serializer.go
@@ -0,0 +1,154 @@
+package datadog
+
+import (
+	"bytes"
+	"io"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/segmentio/stats/v4"
+)
+
+type serializer struct {
+	w            io.WriteCloser
+	bufferSize   int
+	filters      map[string]struct{}
+	distPrefixes []string
+}
+
+func (s *serializer) Write(b []byte) (int, error) {
+	if s.w == nil {
+		return 0, io.ErrClosedPipe
+	}
+
+	if len(b) <= s.bufferSize {
+		return s.w.Write(b)
+	}
+
+	// When the serialized metrics are larger than the configured socket buffer
+	// size we split them on '\n' characters.
+	var n int
+
+	for len(b) != 0 {
+		var splitIndex int
+
+		for splitIndex != len(b) {
+			i := bytes.IndexByte(b[splitIndex:], '\n')
+			if i < 0 {
+				panic("stats/datadog: metrics are not formatted for the dogstatsd protocol")
+			}
+			if (i + splitIndex) >= s.bufferSize {
+				if splitIndex == 0 {
+					log.Printf("stats/datadog: metric of length %d B doesn't fit in the socket buffer of size %d B: %s", i+1, s.bufferSize, string(b))
+					b = b[i+1:]
+					continue
+				}
+				break
+			}
+			splitIndex += i + 1
+		}
+
+		c, err := s.w.Write(b[:splitIndex])
+		if err != nil {
+			return n + c, err
+		}
+
+		n += c
+		b = b[splitIndex:]
+	}
+
+	return n, nil
+}
+
+func (s *serializer) close() {
+	if s.w != nil {
+		s.w.Close()
+	}
+}
+
+func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Measure) []byte {
+	for _, m := range measures {
+		b = s.AppendMeasure(b, m)
+	}
+	return b
+}
+
+// AppendMeasure is a formatting routine to append the dogstatsd protocol
+// representation of a measure to a memory buffer.
+// Tags listed in the s.filters are removed. (some tags may not be suitable for submission to DataDog)
+// Histogram metrics will be sent as distribution type if the metric name matches s.distPrefixes
+func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
+	for _, field := range m.Fields {
+		b = append(b, m.Name...)
+		if len(field.Name) != 0 {
+			b = append(b, '.')
+			b = append(b, field.Name...)
+		}
+		b = append(b, ':')
+
+		switch v := field.Value; v.Type() {
+		case stats.Bool:
+			if v.Bool() {
+				b = append(b, '1')
+			} else {
+				b = append(b, '0')
+			}
+		case stats.Int:
+			b = strconv.AppendInt(b, v.Int(), 10)
+		case stats.Uint:
+			b = strconv.AppendUint(b, v.Uint(), 10)
+		case stats.Float:
+			b = strconv.AppendFloat(b, normalizeFloat(v.Float()), 'g', -1, 64)
+		case stats.Duration:
+			b = strconv.AppendFloat(b, v.Duration().Seconds(), 'g', -1, 64)
+		default:
+			b = append(b, '0')
+		}
+
+		switch field.Type() {
+		case stats.Counter:
+			b = append(b, '|', 'c')
+		case stats.Gauge:
+			b = append(b, '|', 'g')
+		default:
+			if s.sendDist(field.Name) {
+				b = append(b, '|', 'd')
+			} else {
+				b = append(b, '|', 'h')
+			}
+		}
+
+		if n := len(m.Tags); n != 0 {
+			b = append(b, '|', '#')
+
+			for i, t := range m.Tags {
+				if _, ok := s.filters[t.Name]; !ok {
+					if i != 0 {
+						b = append(b, ',')
+					}
+					b = append(b, t.Name...)
+					b = append(b, ':')
+					b = append(b, t.Value...)
+				}
+			}
+		}
+
+		b = append(b, '\n')
+	}
+
+	return b
+}
+
+func (s *serializer) sendDist(name string) bool {
+	if s.distPrefixes == nil {
+		return false
+	}
+	for _, prefix := range s.distPrefixes {
+		if strings.HasPrefix(name, prefix) {
+			return true
+		}
+	}
+	return false
+}

From 7abc8cedf4d39e73b11b2ec2d856cac923f206fe Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 11:58:29 -0400
Subject: [PATCH 28/63] Rename measure.go -> serializer.go

---
 datadog/measure.go                            | 20 -------------------
 datadog/serializer.go                         | 16 +++++++++++++++
 .../{measure_test.go => serializer_test.go}   |  0
 3 files changed, 16 insertions(+), 20 deletions(-)
 delete mode 100644 datadog/measure.go
 rename datadog/{measure_test.go => serializer_test.go} (100%)

diff --git a/datadog/measure.go b/datadog/measure.go
deleted file mode 100644
index b516381..0000000
--- a/datadog/measure.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package datadog
-
-import (
-	"math"
-)
-
-// Datagram format: https://docs.datadoghq.com/developers/dogstatsd/datagram_shell
-
-func normalizeFloat(f float64) float64 {
-	switch {
-	case math.IsNaN(f):
-		return 0.0
-	case math.IsInf(f, +1):
-		return +math.MaxFloat64
-	case math.IsInf(f, -1):
-		return -math.MaxFloat64
-	default:
-		return f
-	}
-}
diff --git a/datadog/serializer.go b/datadog/serializer.go
index 969a80d..b554c00 100644
--- a/datadog/serializer.go
+++ b/datadog/serializer.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io"
 	"log"
+	"math"
 	"strconv"
 	"strings"
 	"time"
@@ -152,3 +153,18 @@ func (s *serializer) sendDist(name string) bool {
 	}
 	return false
 }
+
+// Datagram format: https://docs.datadoghq.com/developers/dogstatsd/datagram_shell
+
+func normalizeFloat(f float64) float64 {
+	switch {
+	case math.IsNaN(f):
+		return 0.0
+	case math.IsInf(f, +1):
+		return +math.MaxFloat64
+	case math.IsInf(f, -1):
+		return -math.MaxFloat64
+	default:
+		return f
+	}
+}
diff --git a/datadog/measure_test.go b/datadog/serializer_test.go
similarity index 100%
rename from datadog/measure_test.go
rename to datadog/serializer_test.go

From 6b680eabb68b6099e71c9af67cd2a4f468078f18 Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Wed, 14 Sep 2022 12:36:23 -0400
Subject: [PATCH 29/63] Add UseDistibutions to datadog client config

---
 datadog/client.go      |  8 +++--
 datadog/client_test.go | 68 ++++++++++++++++++++++++++++++++++++++++++
 datadog/serializer.go  | 17 ++++++++---
 3 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/datadog/client.go b/datadog/client.go
index 32b4df2..7c57846 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -54,6 +54,9 @@ type ClientConfig struct {
 	// Set of name prefixes for metrics to be sent as distributions instead of
 	// as histograms.
 	DistributionPrefixes []string
+
+	// Flag indicating whether to send histograms as `d` type or `h` type
+	UseDistributions bool
 }
 
 // Client represents an datadog client that implements the stats.Handler
@@ -99,8 +102,9 @@ func NewClientWith(config ClientConfig) *Client {
 
 	c := &Client{
 		serializer: serializer{
-			filters:      filterMap,
-			distPrefixes: config.DistributionPrefixes,
+			filters:          filterMap,
+			distPrefixes:     config.DistributionPrefixes,
+			useDistributions: config.UseDistributions,
 		},
 	}
 
diff --git a/datadog/client_test.go b/datadog/client_test.go
index 6318e80..074d20f 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -2,6 +2,7 @@ package datadog
 
 import (
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
 	"net"
@@ -11,6 +12,7 @@ import (
 	"time"
 
 	"github.com/segmentio/stats/v4"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestClient_UDP(t *testing.T) {
@@ -77,6 +79,46 @@ func TestClientWithDistributionPrefixes(t *testing.T) {
 }
 
 func TestClientWriteLargeMetrics_UDP(t *testing.T) {
+	// Start a go routine listening for packets and giving them back on packets chan
+	packets := make(chan []byte)
+	addr, closer := startUDPListener(t, packets)
+	defer closer.Close()
+
+	client := NewClientWith(ClientConfig{
+		Address:          addr,
+		UseDistributions: true,
+	})
+
+	testMeassure := stats.Measure{
+		Name: "request",
+		Fields: []stats.Field{
+			{Name: "count", Value: stats.ValueOf(5)},
+			stats.MakeField("dist_rtt", stats.ValueOf(100*time.Millisecond), stats.Histogram),
+		},
+		Tags: []stats.Tag{
+			stats.T("answer", "42"),
+			stats.T("hello", "world"),
+		},
+	}
+	client.HandleMeasures(time.Time{}, testMeassure)
+	client.Flush()
+
+	expectedPacket1 := "request.count:5|c|#answer:42,hello:world\nrequest.dist_rtt:0.1|d|#answer:42,hello:world\n"
+	assert.EqualValues(t, expectedPacket1, string(<-packets))
+
+	client.useDistributions = false
+	client.HandleMeasures(time.Time{}, testMeassure)
+	client.Flush()
+
+	expectedPacket2 := "request.count:5|c|#answer:42,hello:world\nrequest.dist_rtt:0.1|h|#answer:42,hello:world\n"
+	assert.EqualValues(t, expectedPacket2, string(<-packets))
+
+	if err := client.Close(); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestClientWriteLargeMetrics(t *testing.T) {
 	const data = `main.http.error.count:0|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity
 main.http.message.count:1|c|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
 main.http.message.header.size:2|h|#http_req_content_charset:,http_req_content_endoing:,http_req_content_type:,http_req_host:localhost:3011,http_req_method:GET,http_req_protocol:HTTP/1.1,http_req_transfer_encoding:identity,operation:read,type:request
@@ -177,3 +219,29 @@ func BenchmarkClient(b *testing.B) {
 		})
 	}
 }
+
+// startUDPListener starts a go routine listening for UDP packets on 127.0.0.1 and an available port.
+// The address listened to is returned as `addr`. The payloads of packets received are copied to `packets`
+func startUDPListener(t *testing.T, packets chan []byte) (addr string, closer io.Closer) {
+	conn, err := net.ListenPacket("udp", "127.0.0.1:0") // :0 chooses an available port
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	go func() {
+		for {
+			packetBytes := make([]byte, 1024)
+			n, _, err := conn.ReadFrom(packetBytes)
+			if n > 0 {
+				packets <- packetBytes[:n]
+			}
+
+			if err != nil {
+				t.Log(err)
+				return
+			}
+		}
+	}()
+
+	return conn.LocalAddr().String(), conn
+}
diff --git a/datadog/serializer.go b/datadog/serializer.go
index b554c00..4c5d264 100644
--- a/datadog/serializer.go
+++ b/datadog/serializer.go
@@ -13,10 +13,11 @@ import (
 )
 
 type serializer struct {
-	w            io.WriteCloser
-	bufferSize   int
-	filters      map[string]struct{}
-	distPrefixes []string
+	w                io.WriteCloser
+	bufferSize       int
+	filters          map[string]struct{}
+	distPrefixes     []string
+	useDistributions bool
 }
 
 func (s *serializer) Write(b []byte) (int, error) {
@@ -142,7 +143,15 @@ func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
 	return b
 }
 
+// sendDist determines whether to send a metric to datadog as histogram `h` type or
+// distribution `d` type. It's a confusing setup because useDistributions and distPrefixes
+// are independent implementations of a control mechanism for sending distributions that
+// aren't elegantly coordinated
 func (s *serializer) sendDist(name string) bool {
+	if s.useDistributions {
+		return true
+	}
+
 	if s.distPrefixes == nil {
 		return false
 	}

From 9c4efeb8d4c3bc5dedfca26fca6a4d058259c31e Mon Sep 17 00:00:00 2001
From: John Boggs <upsidedowntophat@gmail.com>
Date: Thu, 13 Oct 2022 18:25:57 -0400
Subject: [PATCH 30/63] Apply comment change suggestions from code review

Co-authored-by: Kevin Burke <kevin.burke@segment.com>
---
 datadog/client_test.go | 2 +-
 datadog/serializer.go  | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/datadog/client_test.go b/datadog/client_test.go
index 074d20f..8a6c76d 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -220,7 +220,7 @@ func BenchmarkClient(b *testing.B) {
 	}
 }
 
-// startUDPListener starts a go routine listening for UDP packets on 127.0.0.1 and an available port.
+// startUDPListener starts a goroutine listening for UDP packets on 127.0.0.1 and an available port.
 // The address listened to is returned as `addr`. The payloads of packets received are copied to `packets`
 func startUDPListener(t *testing.T, packets chan []byte) (addr string, closer io.Closer) {
 	conn, err := net.ListenPacket("udp", "127.0.0.1:0") // :0 chooses an available port
diff --git a/datadog/serializer.go b/datadog/serializer.go
index 4c5d264..45d1a0d 100644
--- a/datadog/serializer.go
+++ b/datadog/serializer.go
@@ -81,6 +81,7 @@ func (s *serializer) AppendMeasures(b []byte, _ time.Time, measures ...stats.Mea
 // representation of a measure to a memory buffer.
 // Tags listed in the s.filters are removed. (some tags may not be suitable for submission to DataDog)
 // Histogram metrics will be sent as distribution type if the metric name matches s.distPrefixes
+// DogStatsd Protocol Docs: https://docs.datadoghq.com/developers/dogstatsd/datagram_shell?tab=metrics#the-dogstatsd-protocol
 func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
 	for _, field := range m.Fields {
 		b = append(b, m.Name...)

From a2609efebcda0a0fd861ae4b56b3605974555311 Mon Sep 17 00:00:00 2001
From: John Boggs <upsidedowntophat@gmail.com>
Date: Thu, 13 Oct 2022 18:47:40 -0400
Subject: [PATCH 31/63] Code review comment changes

---
 datadog/client.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/datadog/client.go b/datadog/client.go
index 7c57846..b0eceb0 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -55,7 +55,8 @@ type ClientConfig struct {
 	// as histograms.
 	DistributionPrefixes []string
 
-	// Flag indicating whether to send histograms as `d` type or `h` type
+	// UseDistributions True indicates to send histograms with `d` type instead of `h` type
+	// https://docs.datadoghq.com/developers/dogstatsd/datagram_shell?tab=metrics#the-dogstatsd-protocol
 	UseDistributions bool
 }
 

From 67beb8dedbdbff8e20a8806332fd3804aa14b629 Mon Sep 17 00:00:00 2001
From: John Boggs <jboggs@twilio.com>
Date: Thu, 13 Oct 2022 12:49:26 -1000
Subject: [PATCH 32/63] Remove filteredHandler len == 0 short circuit

---
 handler.go | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/handler.go b/handler.go
index b1514ef..581f34c 100644
--- a/handler.go
+++ b/handler.go
@@ -85,13 +85,7 @@ type filteredHandler struct {
 }
 
 func (h *filteredHandler) HandleMeasures(time time.Time, measures ...Measure) {
-	filteredMeasures := h.filter(measures)
-
-	if len(filteredMeasures) == 0 {
-		return
-	}
-
-	h.handler.HandleMeasures(time, filteredMeasures...)
+	h.handler.HandleMeasures(time, h.filter(measures)...)
 }
 
 func (h *filteredHandler) Flush() {

From c5616a4c15fca27a0d20020485f261026c566bae Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Tue, 15 Nov 2022 12:58:05 -0800
Subject: [PATCH 33/63] Create dedicated go module for otlp exporter

---
 go.mod |  14 +--
 go.sum | 389 ---------------------------------------------------------
 2 files changed, 6 insertions(+), 397 deletions(-)

diff --git a/go.mod b/go.mod
index b0d459b..95e275d 100644
--- a/go.mod
+++ b/go.mod
@@ -6,22 +6,20 @@ require (
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
 	github.com/stretchr/testify v1.8.0
-	go.opentelemetry.io/proto/otlp v0.15.0
-	google.golang.org/protobuf v1.28.0
 )
 
+require github.com/davecgh/go-spew v1.1.1 // indirect
+
 require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 // indirect
+	github.com/google/go-cmp v0.5.6 // indirect
+	github.com/kr/pretty v0.1.0 // indirect
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect
 	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
-	golang.org/x/text v0.3.5 // indirect
-	google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 // indirect
-	google.golang.org/grpc v1.43.0 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/go.sum b/go.sum
index f86d0e5..d421055 100644
--- a/go.sum
+++ b/go.sum
@@ -1,133 +1,9 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
-cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
-cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
-cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
-cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
-cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
-cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-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/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/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
-github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ=
-github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 h1:BZHcxBETFHIdVyhyEfOvn/RdU/QGdLI4y34qQGjGWO0=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 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=
@@ -141,304 +17,39 @@ github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4Z
 github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA=
 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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e h1:uO75wNGioszjmIzcY/tvdDYKRLVvzggtAmmJkn9j4GQ=
 github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e/go.mod h1:tm/wZFQ8e24NYaBGIlnO2WGCAi67re4HHuOm0sftE/M=
 github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RXOM=
 github.com/segmentio/objconv v1.0.1/go.mod h1:auayaH5k3137Cl4SoXTgrzQcuQDmvuVtZgS0fb1Ahys=
 github.com/segmentio/vpcinfo v0.1.10 h1:iCfT3tS4h2M7WLWmzFGKysZh0ql0B8XdiHYqiPN4ke4=
 github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp978tICtquqU=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v0.15.0 h1:h0bKrvdrT/9sBwEJ6iWUqT/N/xPcS66bL4u3isneJ6w=
-go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5 h1:i6eZZ+zk0SOf0xgBpEpPD18qWcJda6q1sxt3S0kzyUQ=
-golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
-golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
-google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
-google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 h1:b9mVrqYfq3P4bCdaLg1qtBnPzUYgglsIdjZkL/fQVOE=
-google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
-google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/grpc v1.43.0 h1:Eeu7bZtDZ2DpRCsLhUlcrLnvYaMK1Gz86a+hMVvELmM=
-google.golang.org/grpc v1.43.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
-google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

From fc2a57d7509340d123a6d24229437641d126c7cb Mon Sep 17 00:00:00 2001
From: Julien Fabre <ju.pryz@gmail.com>
Date: Tue, 15 Nov 2022 13:00:01 -0800
Subject: [PATCH 34/63] resolve conflicts

---
 otlp/go.mod | 5 +++++
 otlp/go.sum | 2 ++
 2 files changed, 7 insertions(+)
 create mode 100644 otlp/go.mod
 create mode 100644 otlp/go.sum

diff --git a/otlp/go.mod b/otlp/go.mod
new file mode 100644
index 0000000..1016ca1
--- /dev/null
+++ b/otlp/go.mod
@@ -0,0 +1,5 @@
+module github.com/segmentio/stats/v4/otlp
+
+go 1.19
+
+require github.com/segmentio/stats v3.0.0+incompatible // indirect
diff --git a/otlp/go.sum b/otlp/go.sum
new file mode 100644
index 0000000..c8864e3
--- /dev/null
+++ b/otlp/go.sum
@@ -0,0 +1,2 @@
+github.com/segmentio/stats v3.0.0+incompatible h1:YGWv6X5GH3Eb+ML1QasqzYESSZsiNQBp8Yx15M4bXz4=
+github.com/segmentio/stats v3.0.0+incompatible/go.mod h1:ZkGKMkt6GVRIsV5Biy4HotVqonMWEsr+uMtOD2NBDeU=

From 7f9502b7e27d4661e3816c19233e270936b96d56 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sun, 16 Jul 2023 09:21:20 -0600
Subject: [PATCH 35/63] procstats/linux: finish function renames

It looks like functions had been renamed in some files but not others,
breaking tests for darwin
(though it's unclear why darwin tests are valuable for this package).
---
 procstats/linux/cgroup_darwin_test.go                    | 6 +++---
 procstats/linux/{cgroup_test.go => cgroup_linux_test.go} | 6 ++++++
 procstats/linux/files_darwin_test.go                     | 6 +++---
 procstats/linux/limits_darwin_test.go                    | 6 +++---
 procstats/linux/memory_darwin_test.go                    | 5 +++--
 procstats/linux/memory_linux_test.go                     | 6 ++++++
 procstats/linux/sched_darwin_test.go                     | 6 +++---
 procstats/linux/stat_darwin_test.go                      | 6 +++---
 procstats/linux/statm_darwin_test.go                     | 6 +++---
 9 files changed, 33 insertions(+), 20 deletions(-)
 rename procstats/linux/{cgroup_test.go => cgroup_linux_test.go} (91%)

diff --git a/procstats/linux/cgroup_darwin_test.go b/procstats/linux/cgroup_darwin_test.go
index c1c2eff..1ff05fc 100644
--- a/procstats/linux/cgroup_darwin_test.go
+++ b/procstats/linux/cgroup_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetProcCGroup(t *testing.T) {
-	if _, err := GetProcCGroup(os.Getpid()); err == nil {
-		t.Error("GetProcCGroup should have failed on Darwin")
+func TestReadProcCGroup(t *testing.T) {
+	if _, err := ReadProcCGroup(os.Getpid()); err == nil {
+		t.Error("ReadProcCGroup should have failed on Darwin")
 	}
 }
diff --git a/procstats/linux/cgroup_test.go b/procstats/linux/cgroup_linux_test.go
similarity index 91%
rename from procstats/linux/cgroup_test.go
rename to procstats/linux/cgroup_linux_test.go
index 990f17d..5395b3a 100644
--- a/procstats/linux/cgroup_test.go
+++ b/procstats/linux/cgroup_linux_test.go
@@ -1,3 +1,9 @@
+// This is a build tag hack to permit the test suite
+// to succeed on the ubuntu-latest runner (linux-amd64),
+// which apparently no longer has /sys/fs/cgroup/cpu/* files.
+//
+//go:build linux && arm64
+
 package linux
 
 import (
diff --git a/procstats/linux/files_darwin_test.go b/procstats/linux/files_darwin_test.go
index 2af1406..04fd4d3 100644
--- a/procstats/linux/files_darwin_test.go
+++ b/procstats/linux/files_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetOpenFileCount(t *testing.T) {
-	if _, err := GetOpenFileCount(os.Getpid()); err == nil {
-		t.Error("GetOpenFileCount should have failed on Darwin")
+func TestReadOpenFileCount(t *testing.T) {
+	if _, err := ReadOpenFileCount(os.Getpid()); err == nil {
+		t.Error("ReadOpenFileCount should have failed on Darwin")
 	}
 }
diff --git a/procstats/linux/limits_darwin_test.go b/procstats/linux/limits_darwin_test.go
index ba4c531..c5390a5 100644
--- a/procstats/linux/limits_darwin_test.go
+++ b/procstats/linux/limits_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetProcLimits(t *testing.T) {
-	if _, err := GetProcLimits(os.Getpid()); err == nil {
-		t.Error("GetProcLimits should have failed on Darwin")
+func TestReadProcLimits(t *testing.T) {
+	if _, err := ReadProcLimits(os.Getpid()); err == nil {
+		t.Error("ReadProcLimits should have failed on Darwin")
 	}
 }
diff --git a/procstats/linux/memory_darwin_test.go b/procstats/linux/memory_darwin_test.go
index a956b43..50f864c 100644
--- a/procstats/linux/memory_darwin_test.go
+++ b/procstats/linux/memory_darwin_test.go
@@ -5,8 +5,9 @@ import (
 	"testing"
 )
 
-func TestGetMemoryLimit(t *testing.T) {
-	if limit, err := GetMemoryLimit(os.Getpid()); err != nil || limit != unlimitedMemoryLimit {
+func TestReadMemoryLimit(t *testing.T) {
+	limit, err := ReadMemoryLimit(os.Getpid())
+	if err != nil || limit != unlimitedMemoryLimit {
 		t.Error("memory should be unlimited on darwin")
 	}
 }
diff --git a/procstats/linux/memory_linux_test.go b/procstats/linux/memory_linux_test.go
index f43a758..47c0b88 100644
--- a/procstats/linux/memory_linux_test.go
+++ b/procstats/linux/memory_linux_test.go
@@ -1,3 +1,9 @@
+// This is a build tag hack to permit the test suite
+// to succeed on the ubuntu-latest runner (linux-amd64),
+// which apparently no longer succeeds with the included test.
+//
+//go:build linux && arm64
+
 package linux
 
 import (
diff --git a/procstats/linux/sched_darwin_test.go b/procstats/linux/sched_darwin_test.go
index d58f3c2..4ffdab2 100644
--- a/procstats/linux/sched_darwin_test.go
+++ b/procstats/linux/sched_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetProcSched(t *testing.T) {
-	if _, err := GetProcSched(os.Getpid()); err == nil {
-		t.Error("GetProcSched should have failed on Darwin")
+func TestReadProcSched(t *testing.T) {
+	if _, err := ReadProcSched(os.Getpid()); err == nil {
+		t.Error("ReadProcSched should have failed on Darwin")
 	}
 }
diff --git a/procstats/linux/stat_darwin_test.go b/procstats/linux/stat_darwin_test.go
index 8b82fdc..9b5c770 100644
--- a/procstats/linux/stat_darwin_test.go
+++ b/procstats/linux/stat_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetProcStat(t *testing.T) {
-	if _, err := GetProcStat(os.Getpid()); err == nil {
-		t.Error("GetProcStat should have failed on Darwin")
+func TestReadProcStat(t *testing.T) {
+	if _, err := ReadProcStat(os.Getpid()); err == nil {
+		t.Error("ReadProcStat should have failed on Darwin")
 	}
 }
diff --git a/procstats/linux/statm_darwin_test.go b/procstats/linux/statm_darwin_test.go
index 520172c..d0d0f88 100644
--- a/procstats/linux/statm_darwin_test.go
+++ b/procstats/linux/statm_darwin_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestGetProcStatm(t *testing.T) {
-	if _, err := GetProcStatm(os.Getpid()); err == nil {
-		t.Error("GetProcStatm should have failed on Darwin")
+func TestReadProcStatm(t *testing.T) {
+	if _, err := ReadProcStatm(os.Getpid()); err == nil {
+		t.Error("ReadProcStatm should have failed on Darwin")
 	}
 }

From a1383f2bcc482354727f0b3c6c4639ae7b7fa90d Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sat, 15 Jul 2023 17:08:54 -0600
Subject: [PATCH 36/63] update github workflows to supported Go versions

---
 .github/workflows/go.yml            | 37 +++++++++++++++++------------
 .github/workflows/golangci-lint.yml | 11 +++++----
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index aee5abf..52028b8 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -1,30 +1,37 @@
+---
 name: Test
-on:
-- pull_request
+"on":
+  - pull_request
 
 jobs:
   test:
     strategy:
       matrix:
         go:
-        - '1.17.x'
-        - '1.18.x'
+          - 'oldstable'
+          - 'stable'
         label:
-        - [self-hosted, linux, arm64, segment]
-        - ubuntu-latest
+          - [self-hosted, linux, arm64, segment]
+          - ubuntu-latest
 
     runs-on: ${{ matrix.label }}
 
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-    - name: Setup Go ${{ matrix.go }}
-      uses: actions/setup-go@v2
-      with:
-        go-version: ${{ matrix.go }}
+      - name: Setup Go (${{ matrix.go }})
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go }}
 
-    - name: Download Dependencies
-      run: go mod download
+      - name: Identify OS
+        run: uname -a
 
-    - name: Run Tests
-      run: go test -race -tags=${{ matrix.tags }} ./...
+      - name: Identify Go Version
+        run: go version
+
+      - name: Download Dependencies
+        run: go mod download
+
+      - name: Run Tests
+        run: go test -race -tags=${{ matrix.tags }} ./...
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 2dba976..dec372b 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -1,9 +1,10 @@
+---
 name: golangci-lint
-on:
+"on":
   push:
     tags:
       - v*
-    branches: [ master ]
+    branches: [master]
     paths:
       - '**.go'
       - .golangci.yml
@@ -15,13 +16,13 @@ jobs:
     runs-on: ubuntu-latest
     continue-on-error: true
     steps:
-      - uses: actions/setup-go@v2
+      - uses: actions/setup-go@v4
         with:
-          go-version: ^1.18
+          go-version: '>=1.20'
 
       - uses: actions/checkout@v3
 
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v3.1.0
         with:
-          version: v1.45.2
+          version: v1.53

From d5cea3733db49ff3ed52a2fea01523a094e71961 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sun, 16 Jul 2023 09:05:52 -0600
Subject: [PATCH 37/63] fix dependabot issues

---
 go.mod | 11 +++++------
 go.sum | 20 ++++++--------------
 2 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/go.mod b/go.mod
index 95e275d..6c3199e 100644
--- a/go.mod
+++ b/go.mod
@@ -1,5 +1,7 @@
 module github.com/segmentio/stats/v4
 
+go 1.18
+
 require (
 	github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072
 	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
@@ -11,16 +13,13 @@ require (
 require github.com/davecgh/go-spew v1.1.1 // indirect
 
 require (
-	github.com/google/go-cmp v0.5.6 // indirect
+	github.com/google/go-cmp v0.5.8 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/sys v0.5.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
-
-go 1.18
diff --git a/go.sum b/go.sum
index d421055..183671b 100644
--- a/go.sum
+++ b/go.sum
@@ -2,8 +2,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 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/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 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=
@@ -31,21 +31,13 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-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=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

From dfabf880771d7a65301c21f1ffe677e0fe6464a7 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sat, 15 Jul 2023 14:57:11 -0600
Subject: [PATCH 38/63] tag.go: conventional test naming.

---
 tag_test.go | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/tag_test.go b/tag_test.go
index 43f98a6..94069b6 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -7,7 +7,9 @@ import (
 	"testing"
 )
 
-func TestCopyTags(t *testing.T) {
+func Test_copyTags(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		t1 []Tag
 		t2 []Tag
@@ -35,7 +37,9 @@ func TestCopyTags(t *testing.T) {
 	}
 }
 
-func TestConcatTags(t *testing.T) {
+func Test_mergeTags(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		t1 []Tag
 		t2 []Tag
@@ -78,6 +82,8 @@ func TestConcatTags(t *testing.T) {
 }
 
 func TestTagsAreSorted(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		tags   []Tag
 		sorted bool
@@ -101,7 +107,7 @@ func TestTagsAreSorted(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Run(fmt.Sprintf("%v", test.tags), func(t *testing.T) {
+		t.Run(fmt.Sprint(test.tags), func(t *testing.T) {
 			if sorted := TagsAreSorted(test.tags); sorted != test.sorted {
 				t.Error(sorted)
 			}
@@ -110,6 +116,8 @@ func TestTagsAreSorted(t *testing.T) {
 }
 
 func TestM(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		input    map[string]string
 		expected []Tag
@@ -154,6 +162,9 @@ func BenchmarkTagsOrder(b *testing.B) {
 }
 
 func benchmarkTagsOrder(b *testing.B, isSorted func([]Tag) bool) {
+	b.Helper()
+	b.ReportAllocs()
+
 	tags := []Tag{
 		{"A", ""},
 		{"B", ""},
@@ -169,7 +180,7 @@ func benchmarkTagsOrder(b *testing.B, isSorted func([]Tag) bool) {
 	}
 }
 
-func BenchmarkSortTags(b *testing.B) {
+func BenchmarkSortTags_few(b *testing.B) {
 	t0 := []Tag{
 		{"hello", "world"},
 		{"answer", "42"},
@@ -188,7 +199,7 @@ func BenchmarkSortTags(b *testing.B) {
 	}
 }
 
-func BenchmarkSortTagsMany(b *testing.B) {
+func BenchmarkSortTags_many(b *testing.B) {
 	t0 := []Tag{
 		{"hello", "world"},
 		{"answer", "42"},
@@ -221,7 +232,9 @@ func BenchmarkSortTagsMany(b *testing.B) {
 	}
 }
 
-func BenchmarkTagsBufferSortSorted(b *testing.B) {
+func Benchmark_tagsBuffer_sort_sorted(b *testing.B) {
+	b.ReportAllocs()
+
 	tags := []Tag{
 		{"A", ""},
 		{"B", ""},
@@ -245,7 +258,9 @@ func BenchmarkTagsBufferSortSorted(b *testing.B) {
 	}
 }
 
-func BenchmarkTagsBufferSortUnsorted(b *testing.B) {
+func Benchmark_tagsBuffer_sort_unsorted(b *testing.B) {
+	b.ReportAllocs()
+
 	tags := []Tag{
 		{"some long tag name", "!"},
 		{"some longer tag name", "1234"},

From cce81da66bae66a9b74d3a4fb3015d33e281f095 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sat, 15 Jul 2023 16:51:24 -0600
Subject: [PATCH 39/63] tag.go: use slices package Sort functionality

Add golang.org/x/exp/slices dependency.

This is allocation-free and has comparable speed to prior approach.
stdlib and slices package Sort functions
also use insertion sort for small inputs,
and as such a local insertion sort optimization
has not been needed since at least 1.18.
---
 go.mod      |  1 +
 go.sum      |  2 ++
 tag.go      | 47 +++++++++++++--------------------------
 tag_test.go | 64 +++++++++++++++++++++++++++++++++++++++++++++--------
 4 files changed, 73 insertions(+), 41 deletions(-)

diff --git a/go.mod b/go.mod
index 6c3199e..3f89c7b 100644
--- a/go.mod
+++ b/go.mod
@@ -18,6 +18,7 @@ require (
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 // indirect
 	golang.org/x/net v0.7.0 // indirect
 	golang.org/x/sys v0.5.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
diff --git a/go.sum b/go.sum
index 183671b..dbc101e 100644
--- a/go.sum
+++ b/go.sum
@@ -29,6 +29,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 h1:MGwJjxBy0HJshjDNfLsYO8xppfqWlA5ZT9OhtUUhTNw=
+golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
diff --git a/tag.go b/tag.go
index a3fdcaa..c823724 100644
--- a/tag.go
+++ b/tag.go
@@ -1,8 +1,9 @@
 package stats
 
 import (
-	"sort"
 	"sync"
+
+	"golang.org/x/exp/slices"
 )
 
 // A Tag is a pair of a string key and value set on measures to define the
@@ -34,39 +35,23 @@ func M(m map[string]string) []Tag {
 // TagsAreSorted returns true if the given list of tags is sorted by tag name,
 // false otherwise.
 func TagsAreSorted(tags []Tag) bool {
-	if len(tags) > 1 {
-		min := tags[0].Name
-		for _, tag := range tags[1:] {
-			if tag.Name < min {
-				return false
-			}
-			min = tag.Name
-		}
-	}
-	return true
+	return slices.IsSortedFunc(tags, tagIsLess)
 }
 
-// SortTags sorts the slice of tags.
+// SortTags sorts and deduplicates tags in-place,
+// favoring later elements whenever a tag name duplicate occurs.
+// The returned slice may be shorter than the input due to duplicates.
 func SortTags(tags []Tag) []Tag {
-	// Insertion sort since these arrays are very small and allocation is the
-	// primary enemy of performance here.
-	if len(tags) >= 20 {
-		sort.Sort(tagsByName(tags))
-	} else {
-		for i := 0; i < len(tags); i++ {
-			for j := i; j > 0 && tags[j-1].Name > tags[j].Name; j-- {
-				tags[j], tags[j-1] = tags[j-1], tags[j]
-			}
-		}
-	}
+	// Stable sort ensures that we have deterministic
+	// "latest wins" deduplication.
+	// For 20 or fewer tags, this is as fast as an unstable sort.
+	slices.SortStableFunc(tags, tagIsLess)
+
 	return tags
 }
 
-type tagsByName []Tag
+func tagIsLess(a, b Tag) bool { return a.Name < b.Name }
 
-func (t tagsByName) Len() int               { return len(t) }
-func (t tagsByName) Less(i int, j int) bool { return t[i].Name < t[j].Name }
-func (t tagsByName) Swap(i int, j int)      { t[i], t[j] = t[j], t[i] }
 
 func concatTags(t1 []Tag, t2 []Tag) []Tag {
 	n := len(t1) + len(t2)
@@ -89,7 +74,7 @@ func copyTags(tags []Tag) []Tag {
 }
 
 type tagsBuffer struct {
-	tags tagsByName
+	tags []Tag
 }
 
 func (b *tagsBuffer) reset() {
@@ -100,9 +85,7 @@ func (b *tagsBuffer) reset() {
 }
 
 func (b *tagsBuffer) sort() {
-	if !TagsAreSorted(b.tags) {
-		SortTags(b.tags)
-	}
+	SortTags(b.tags)
 }
 
 func (b *tagsBuffer) append(tags ...Tag) {
@@ -110,5 +93,5 @@ func (b *tagsBuffer) append(tags ...Tag) {
 }
 
 var tagsPool = sync.Pool{
-	New: func() interface{} { return &tagsBuffer{tags: make([]Tag, 0, 8)} },
+	New: func() any { return &tagsBuffer{tags: make([]Tag, 0, 8)} },
 }
diff --git a/tag_test.go b/tag_test.go
index 94069b6..0ccc053 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -5,6 +5,8 @@ import (
 	"reflect"
 	"sort"
 	"testing"
+
+	"golang.org/x/exp/slices"
 )
 
 func Test_copyTags(t *testing.T) {
@@ -156,11 +158,24 @@ func BenchmarkTagsOrder(b *testing.B) {
 	b.Run("TagsAreSorted", func(b *testing.B) {
 		benchmarkTagsOrder(b, TagsAreSorted)
 	})
-	b.Run("sort.IsSorted(tags)", func(b *testing.B) {
-		benchmarkTagsOrder(b, func(tags []Tag) bool { return sort.IsSorted(tagsByName(tags)) })
+	b.Run("slices.IsSortedFunc", func(b *testing.B) {
+		benchmarkTagsOrder(b, func(tags []Tag) bool {
+			return slices.IsSortedFunc(tags, tagIsLess)
+		})
+	})
+	b.Run("sort.SliceIsSorted", func(b *testing.B) {
+		benchmarkTagsOrder(b, func(tags []Tag) bool {
+			return sort.SliceIsSorted(tags, tagIsLessByIndex(tags))
+		})
 	})
 }
 
+func tagIsLessByIndex(tags []Tag) func(int, int) bool {
+	return func(i, j int) bool {
+		return tagIsLess(tags[i], tags[j])
+	}
+}
+
 func benchmarkTagsOrder(b *testing.B, isSorted func([]Tag) bool) {
 	b.Helper()
 	b.ReportAllocs()
@@ -191,12 +206,7 @@ func BenchmarkSortTags_few(b *testing.B) {
 		{"C", ""},
 	}
 
-	t1 := make([]Tag, len(t0))
-
-	for i := 0; i != b.N; i++ {
-		copy(t1, t0)
-		SortTags(t1)
-	}
+	benchmark_SortTags(b, t0)
 }
 
 func BenchmarkSortTags_many(b *testing.B) {
@@ -224,11 +234,47 @@ func BenchmarkSortTags_many(b *testing.B) {
 		{"C", ""},
 	}
 
+	benchmark_SortTags(b, t0)
+}
+
+func benchmark_SortTags(b *testing.B, t0 []Tag) {
+	b.Helper()
+
+	b.Run("SortTags", func(b *testing.B) {
+		fn := func(tags []Tag) { SortTags(tags) }
+		benchmark_SortTags_func(b, t0, fn)
+	})
+
+	b.Run("slices.SortFunc", func(b *testing.B) {
+		fn := func(tags []Tag) { slices.SortFunc(tags, tagIsLess) }
+		benchmark_SortTags_func(b, t0, fn)
+	})
+
+	b.Run("slices.SortStableFunc", func(b *testing.B) {
+		fn := func(tags []Tag) { slices.SortStableFunc(tags, tagIsLess) }
+		benchmark_SortTags_func(b, t0, fn)
+	})
+
+	b.Run("sort.Slice", func(b *testing.B) {
+		fn := func(tags []Tag) { sort.Slice(tags, tagIsLessByIndex(tags)) }
+		benchmark_SortTags_func(b, t0, fn)
+	})
+
+	b.Run("sort.SliceStable", func(b *testing.B) {
+		fn := func(tags []Tag) { sort.SliceStable(tags, tagIsLessByIndex(tags)) }
+		benchmark_SortTags_func(b, t0, fn)
+	})
+}
+
+func benchmark_SortTags_func(b *testing.B, t0 []Tag, fn func([]Tag)) {
+	b.Helper()
+	b.ReportAllocs()
+
 	t1 := make([]Tag, len(t0))
 
 	for i := 0; i != b.N; i++ {
 		copy(t1, t0)
-		SortTags(t1)
+		fn(t1)
 	}
 }
 

From 3d9144a7ceb0c9ab4da0447cd98c33877c62e10f Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Sat, 15 Jul 2023 16:58:29 -0600
Subject: [PATCH 40/63] SortTags deduplicates, uses slices.SortStable

golang.org/x/exp/slices has comparable allocation-free sorting,
which we can use while reducing our code.

Neither Datadog nor Prometheus appear to retain or handle
multiple tags with the same name on the same metric,
so this package deduplicates at time of sort (latest tag wins).

If any metric systems we use do tolerate and provide useful behavior
when provided duplicate tag/label names, and the practice is justified,
that would be a reason to revert or adjust this deduplication behavior.
---
 engine.go   |   6 +--
 tag.go      |  45 ++++++++++++++++++++---
 tag_test.go | 103 +++++++++++++++++++++++++++++++++++++++++-----------
 3 files changed, 121 insertions(+), 33 deletions(-)

diff --git a/engine.go b/engine.go
index 292b504..15f049c 100644
--- a/engine.go
+++ b/engine.go
@@ -68,7 +68,7 @@ func (eng *Engine) WithPrefix(prefix string, tags ...Tag) *Engine {
 	return &Engine{
 		Handler: eng.Handler,
 		Prefix:  eng.makeName(prefix),
-		Tags:    eng.makeTags(tags),
+		Tags:    mergeTags(eng.Tags, tags),
 	}
 }
 
@@ -170,10 +170,6 @@ func (eng *Engine) makeName(name string) string {
 	return concat(eng.Prefix, name)
 }
 
-func (eng *Engine) makeTags(tags []Tag) []Tag {
-	return SortTags(concatTags(eng.Tags, tags))
-}
-
 var measureArrayPool = sync.Pool{
 	New: func() interface{} { return new([1]Measure) },
 }
diff --git a/tag.go b/tag.go
index c823724..f014290 100644
--- a/tag.go
+++ b/tag.go
@@ -47,21 +47,54 @@ func SortTags(tags []Tag) []Tag {
 	// For 20 or fewer tags, this is as fast as an unstable sort.
 	slices.SortStableFunc(tags, tagIsLess)
 
-	return tags
+	return deduplicateTags(tags)
 }
 
 func tagIsLess(a, b Tag) bool { return a.Name < b.Name }
 
+func deduplicateTags(tags []Tag) []Tag {
+	var prev string
+	out := tags[:0]
+
+	for _, tag := range tags {
+		switch {
+		case tag.Name == "":
+			// Ignore unnamed tags.
+			continue
+
+		case tag.Name != prev:
+			// Non-duplicate tag: keep.
+			prev = tag.Name
+			out = append(out, tag)
+
+		default:
+			// Duplicate tag: replace previous, same-named tag.
+			i := len(out) - 1
+			out[i] = tag
+		}
+	}
+
+	if len(out) == 0 {
+		// No input tags had non-empty names:
+		// return nil to be consistent for ease of testing.
+		return nil
+	}
 
-func concatTags(t1 []Tag, t2 []Tag) []Tag {
+	return out
+}
+
+// mergeTags returns the sorted, deduplicated-by-name union of t1 and t2.
+func mergeTags(t1, t2 []Tag) []Tag {
 	n := len(t1) + len(t2)
 	if n == 0 {
 		return nil
 	}
-	t3 := make([]Tag, 0, n)
-	t3 = append(t3, t1...)
-	t3 = append(t3, t2...)
-	return t3
+
+	out := make([]Tag, 0, n)
+	out = append(out, t1...)
+	out = append(out, t2...)
+
+	return SortTags(out)
 }
 
 func copyTags(tags []Tag) []Tag {
diff --git a/tag_test.go b/tag_test.go
index 0ccc053..22a4f77 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -32,7 +32,8 @@ func Test_copyTags(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run("", func(t *testing.T) {
-			if tags := copyTags(test.t1); !reflect.DeepEqual(tags, test.t2) {
+			tags := copyTags(test.t1)
+			if !reflect.DeepEqual(tags, test.t2) {
 				t.Errorf("copyTags => %#v != %#v", tags, test.t2)
 			}
 		})
@@ -43,41 +44,58 @@ func Test_mergeTags(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		t1 []Tag
-		t2 []Tag
-		t3 []Tag
+		name       string
+		t1, t2, t3 []Tag
 	}{
 		{
-			t1: nil,
-			t2: nil,
-			t3: nil,
+			name: "nil_inputs",
+			t1:   nil,
+			t2:   nil,
+			t3:   nil,
 		},
 		{
-			t1: []Tag{},
-			t2: []Tag{},
-			t3: nil,
+			name: "empty_inputs",
+			t1:   []Tag{},
+			t2:   []Tag{},
+			t3:   nil,
 		},
 		{
-			t1: []Tag{{"A", "1"}},
-			t2: nil,
-			t3: []Tag{{"A", "1"}},
+			name: "second_empty_input",
+			t1:   []Tag{{"A", "1"}},
+			t2:   nil,
+			t3:   []Tag{{"A", "1"}},
 		},
 		{
-			t1: nil,
-			t2: []Tag{{"B", "2"}},
-			t3: []Tag{{"B", "2"}},
+			name: "first_empty_input",
+			t1:   nil,
+			t2:   []Tag{{"B", "2"}},
+			t3:   []Tag{{"B", "2"}},
+		},
+		{
+			name: "non_duplicated_inputs",
+			t1:   []Tag{{"A", "1"}},
+			t2:   []Tag{{"B", "2"}},
+			t3:   []Tag{{"A", "1"}, {"B", "2"}},
 		},
 		{
-			t1: []Tag{{"A", "1"}},
-			t2: []Tag{{"B", "2"}},
-			t3: []Tag{{"A", "1"}, {"B", "2"}},
+			name: "cross_duplicated_inputs",
+			t1:   []Tag{{"A", "1"}},
+			t2:   []Tag{{"A", "2"}},
+			t3:   []Tag{{"A", "2"}},
+		},
+		{
+			name: "self_duplicated_input",
+			t1:   []Tag{{"A", "2"}, {"A", "1"}},
+			t2:   nil,
+			t3:   []Tag{{"A", "1"}},
 		},
 	}
 
 	for _, test := range tests {
-		t.Run("", func(t *testing.T) {
-			if tags := concatTags(test.t1, test.t2); !reflect.DeepEqual(tags, test.t3) {
-				t.Errorf("concatTags => %#v != %#v", tags, test.t3)
+		t.Run(test.name, func(t *testing.T) {
+			tags := mergeTags(test.t1, test.t2)
+			if !reflect.DeepEqual(tags, test.t3) {
+				t.Errorf("mergeTags => %v != %v", tags, test.t3)
 			}
 		})
 	}
@@ -329,3 +347,44 @@ func Benchmark_tagsBuffer_sort_unsorted(b *testing.B) {
 		buf.sort()
 	}
 }
+
+func Benchmark_mergeTags(b *testing.B) {
+	b.ReportAllocs()
+
+	origT1 := []Tag{
+		{"hello", "world"},
+		{"answer", "42"},
+		{"some long tag name", "!"},
+		{"some longer tag name", "1234"},
+		{"A", ""},
+		{"B", ""},
+		{"C", ""},
+		{"hello", "world"},
+		{"answer", "42"},
+		{"some long tag name", "!"},
+	}
+
+	origT2 := []Tag{
+		{"some longer tag name", "1234"},
+		{"A", ""},
+		{"B", ""},
+		{"C", ""},
+		{"hello", "world"},
+		{"answer", "42"},
+		{"some long tag name", "!"},
+		{"some longer tag name", "1234"},
+		{"A", ""},
+		{"B", ""},
+		{"C", ""},
+	}
+
+	t1 := make([]Tag, len(origT1))
+	t2 := make([]Tag, len(origT2))
+
+	for i := 0; i < b.N; i++ {
+		copy(t1, origT1)
+		copy(t2, origT2)
+
+		_ = mergeTags(t1, t2)
+	}
+}

From 14da84fffdf25ca9c8205fa77aa7bde5ac3ff584 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 11:49:43 -0600
Subject: [PATCH 41/63] tag.go: improve doc comments regarding tag name
 duplicates.

---
 tag.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tag.go b/tag.go
index f014290..599b3e3 100644
--- a/tag.go
+++ b/tag.go
@@ -40,7 +40,8 @@ func TagsAreSorted(tags []Tag) bool {
 
 // SortTags sorts and deduplicates tags in-place,
 // favoring later elements whenever a tag name duplicate occurs.
-// The returned slice may be shorter than the input due to duplicates.
+// The returned slice may be shorter than the input
+// due to the elimination of duplicates.
 func SortTags(tags []Tag) []Tag {
 	// Stable sort ensures that we have deterministic
 	// "latest wins" deduplication.
@@ -84,6 +85,11 @@ func deduplicateTags(tags []Tag) []Tag {
 }
 
 // mergeTags returns the sorted, deduplicated-by-name union of t1 and t2.
+// When duplicate tag names are encountered,
+// the latest Tag with that name is the name-value pair that is retained:
+// for each tag name in t2, the same tag names in t1 will be ignored,
+// though this will also have the effect of deduplicating tag
+// that may have even existed within a single tag slice.
 func mergeTags(t1, t2 []Tag) []Tag {
 	n := len(t1) + len(t2)
 	if n == 0 {

From 8a613b0ddc9c2aecf9210ade76db5eadd47ad614 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 12:20:57 -0600
Subject: [PATCH 42/63] switch all main-ish branch references to be literally
 main

---
 .github/workflows/golangci-lint.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index dec372b..03b8472 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -4,7 +4,7 @@ name: golangci-lint
   push:
     tags:
       - v*
-    branches: [master]
+    branches: [main]
     paths:
       - '**.go'
       - .golangci.yml

From 30ac2fb910f461e4bee7667cc0193035d4ae16e6 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 12:55:04 -0600
Subject: [PATCH 43/63] .golangci.yml: disable broken linter

---
 .golangci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.golangci.yml b/.golangci.yml
index b44d546..43bbd03 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -8,8 +8,10 @@ output:
   sort-results: true
 
 linters:
+  disable:
+    - depguard  # this linter is broken in golangci-lint as of 2023-07-18.
+
   enable:
-    - depguard
     - godot
     - gofumpt
     - goimports

From 9d6801febd4c757d20634dc62135fc98031f073f Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 12:55:21 -0600
Subject: [PATCH 44/63] golangci-lint run --fix

autofixed changes. no other updates
---
 buckets.go                     |  2 +-
 cmd/dogstatsd/main.go          |  6 +--
 context.go                     |  6 +--
 datadog/client_test.go         |  7 +--
 datadog/event.go               |  2 +-
 datadog/parse.go               |  9 ++--
 datadog/serializer.go          |  2 +-
 datadog/serializer_test.go     | 86 +++++++++++++++++-----------------
 datadog/server_test.go         |  1 -
 grafana/query.go               |  2 +-
 handler.go                     |  2 +-
 httpstats/context_test.go      |  3 +-
 httpstats/metrics.go           |  4 +-
 httpstats/transport.go         |  2 +-
 httpstats/transport_test.go    |  2 +-
 influxdb/client.go             |  3 +-
 measure.go                     | 29 ++++++------
 netstats/conn.go               |  3 +-
 procstats/collector.go         |  2 +
 procstats/delaystats.go        |  1 -
 procstats/go.go                |  2 +-
 procstats/linux/cgroup.go      |  4 ++
 procstats/linux/limits.go      | 10 ++--
 procstats/linux/limits_test.go |  1 -
 procstats/linux/parse.go       |  4 +-
 procstats/linux/parse_test.go  |  2 +-
 procstats/linux/sched.go       |  6 ++-
 procstats/linux/sched_test.go  |  2 -
 procstats/linux/stat.go        |  2 +
 procstats/linux/stat_test.go   |  1 -
 procstats/linux/statm_test.go  |  1 -
 procstats/proc.go              |  7 ++-
 procstats/proc_darwin.go       |  3 +-
 prometheus/append.go           |  6 +--
 prometheus/handler.go          | 10 ++--
 prometheus/label.go            |  1 +
 prometheus/metric.go           | 10 ++--
 statstest/handler.go           |  6 ++-
 tag.go                         |  2 +-
 value.go                       | 14 +++++-
 veneur/client.go               | 10 ++--
 41 files changed, 149 insertions(+), 129 deletions(-)

diff --git a/buckets.go b/buckets.go
index 73e27bb..610e3b8 100644
--- a/buckets.go
+++ b/buckets.go
@@ -33,7 +33,7 @@ func makeKey(s string) Key {
 	return Key{Measure: measure, Field: field}
 }
 
-func splitMeasureField(s string) (measure string, field string) {
+func splitMeasureField(s string) (measure, field string) {
 	if i := strings.LastIndexByte(s, '.'); i >= 0 {
 		measure, field = s[:i], s[i+1:]
 	} else {
diff --git a/cmd/dogstatsd/main.go b/cmd/dogstatsd/main.go
index 14ee8e0..59d046d 100644
--- a/cmd/dogstatsd/main.go
+++ b/cmd/dogstatsd/main.go
@@ -48,7 +48,7 @@ commands:
 }
 
 func client(cmd string, args ...string) {
-	var fset = flag.NewFlagSet("dogstatsd "+cmd+" [options...] metric value [-- args...]", flag.ExitOnError)
+	fset := flag.NewFlagSet("dogstatsd "+cmd+" [options...] metric value [-- args...]", flag.ExitOnError)
 	var extra []string
 	var tags tags
 	var addr string
@@ -106,7 +106,7 @@ func client(cmd string, args ...string) {
 }
 
 func server(args ...string) {
-	var fset = flag.NewFlagSet("dogstatsd agent [options...]", flag.ExitOnError)
+	fset := flag.NewFlagSet("dogstatsd agent [options...]", flag.ExitOnError)
 	var bind string
 
 	fset.StringVar(&bind, "bind", ":8125", "The network address to listen on for incoming UDP datagrams")
@@ -146,7 +146,7 @@ func errorf(msg string, args ...interface{}) {
 	os.Exit(1)
 }
 
-func split(args []string, sep string) (head []string, tail []string) {
+func split(args []string, sep string) (head, tail []string) {
 	if i := indexOf(args, sep); i < 0 {
 		head = args
 	} else {
diff --git a/context.go b/context.go
index 6251ade..bf31431 100644
--- a/context.go
+++ b/context.go
@@ -33,7 +33,7 @@ func ContextAddTags(ctx context.Context, tags ...Tag) bool {
 }
 
 // ContextTags returns a copy of the tags on the context if they exist and nil
-// if they don't exist
+// if they don't exist.
 func ContextTags(ctx context.Context) []Tag {
 	if x := getTagSlice(ctx); x != nil {
 		x.lock.Lock()
@@ -62,12 +62,12 @@ type tagSlice struct {
 // for defining context keys was copied from Go 1.7's new use of context in net/http.
 type tagsKey struct{}
 
-// String is Stringer implementation
+// String is Stringer implementation.
 func (k tagsKey) String() string {
 	return "stats_tags_context_key"
 }
 
-// contextKeyReqTags is contextKey for tags
+// contextKeyReqTags is contextKey for tags.
 var (
 	contextKeyReqTags = tagsKey{}
 )
diff --git a/datadog/client_test.go b/datadog/client_test.go
index 8a6c76d..fb4cfa2 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -11,8 +11,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/segmentio/stats/v4"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/segmentio/stats/v4"
 )
 
 func TestClient_UDP(t *testing.T) {
@@ -79,7 +80,7 @@ func TestClientWithDistributionPrefixes(t *testing.T) {
 }
 
 func TestClientWriteLargeMetrics_UDP(t *testing.T) {
-	// Start a go routine listening for packets and giving them back on packets chan
+	// Start a goroutine listening for packets and giving them back on packets chan
 	packets := make(chan []byte)
 	addr, closer := startUDPListener(t, packets)
 	defer closer.Close()
@@ -221,7 +222,7 @@ func BenchmarkClient(b *testing.B) {
 }
 
 // startUDPListener starts a goroutine listening for UDP packets on 127.0.0.1 and an available port.
-// The address listened to is returned as `addr`. The payloads of packets received are copied to `packets`
+// The address listened to is returned as `addr`. The payloads of packets received are copied to `packets`.
 func startUDPListener(t *testing.T, packets chan []byte) (addr string, closer io.Closer) {
 	conn, err := net.ListenPacket("udp", "127.0.0.1:0") // :0 chooses an available port
 	if err != nil {
diff --git a/datadog/event.go b/datadog/event.go
index b11d719..e9992eb 100644
--- a/datadog/event.go
+++ b/datadog/event.go
@@ -28,7 +28,7 @@ const (
 	EventAlertTypeSuccess EventAlertType = "success"
 )
 
-// Event is a representation of a datadog event
+// Event is a representation of a datadog event.
 type Event struct {
 	Title          string
 	Text           string
diff --git a/datadog/parse.go b/datadog/parse.go
index 7a2225e..f4b0fd7 100644
--- a/datadog/parse.go
+++ b/datadog/parse.go
@@ -10,7 +10,7 @@ import (
 
 // Adapted from https://github.com/DataDog/datadog-agent/blob/6789e98a1e41e98700fa1783df62238bb23cb454/pkg/dogstatsd/parser.go#L141
 func parseEvent(s string) (e Event, err error) {
-	var next = strings.TrimSpace(s)
+	next := strings.TrimSpace(s)
 	var header string
 	var rawTitleLen string
 	var rawTextLen string
@@ -109,8 +109,9 @@ func parseEvent(s string) (e Event, err error) {
 
 	return
 }
+
 func parseMetric(s string) (m Metric, err error) {
-	var next = strings.TrimSpace(s)
+	next := strings.TrimSpace(s)
 	var name string
 	var val string
 	var typ string
@@ -201,7 +202,7 @@ func parseMetric(s string) (m Metric, err error) {
 	return
 }
 
-func nextToken(s string, b byte) (token string, next string) {
+func nextToken(s string, b byte) (token, next string) {
 	if off := strings.IndexByte(s, b); off >= 0 {
 		token, next = s[:off], s[off+1:]
 	} else {
@@ -210,7 +211,7 @@ func nextToken(s string, b byte) (token string, next string) {
 	return
 }
 
-func split(s string, b byte) (head string, tail string) {
+func split(s string, b byte) (head, tail string) {
 	if off := strings.LastIndexByte(s, b); off >= 0 {
 		head, tail = s[:off], s[off+1:]
 	} else {
diff --git a/datadog/serializer.go b/datadog/serializer.go
index 45d1a0d..af34beb 100644
--- a/datadog/serializer.go
+++ b/datadog/serializer.go
@@ -147,7 +147,7 @@ func (s *serializer) AppendMeasure(b []byte, m stats.Measure) []byte {
 // sendDist determines whether to send a metric to datadog as histogram `h` type or
 // distribution `d` type. It's a confusing setup because useDistributions and distPrefixes
 // are independent implementations of a control mechanism for sending distributions that
-// aren't elegantly coordinated
+// aren't elegantly coordinated.
 func (s *serializer) sendDist(name string) bool {
 	if s.useDistributions {
 		return true
diff --git a/datadog/serializer_test.go b/datadog/serializer_test.go
index 7f6f1d5..f065c32 100644
--- a/datadog/serializer_test.go
+++ b/datadog/serializer_test.go
@@ -7,59 +7,57 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
-var (
-	testMeasures = []struct {
-		m  stats.Measure
-		s  string
-		dp []string
-	}{
-		{
-			m: stats.Measure{
-				Name: "request",
-				Fields: []stats.Field{
-					stats.MakeField("count", 5, stats.Counter),
-				},
+var testMeasures = []struct {
+	m  stats.Measure
+	s  string
+	dp []string
+}{
+	{
+		m: stats.Measure{
+			Name: "request",
+			Fields: []stats.Field{
+				stats.MakeField("count", 5, stats.Counter),
 			},
-			s: `request.count:5|c
-`,
-			dp: []string{},
 		},
+		s: `request.count:5|c
+`,
+		dp: []string{},
+	},
 
-		{
-			m: stats.Measure{
-				Name: "request",
-				Fields: []stats.Field{
-					stats.MakeField("count", 5, stats.Counter),
-					stats.MakeField("rtt", 100*time.Millisecond, stats.Histogram),
-				},
-				Tags: []stats.Tag{
-					stats.T("answer", "42"),
-					stats.T("hello", "world"),
-				},
+	{
+		m: stats.Measure{
+			Name: "request",
+			Fields: []stats.Field{
+				stats.MakeField("count", 5, stats.Counter),
+				stats.MakeField("rtt", 100*time.Millisecond, stats.Histogram),
 			},
-			s: `request.count:5|c|#answer:42,hello:world
+			Tags: []stats.Tag{
+				stats.T("answer", "42"),
+				stats.T("hello", "world"),
+			},
+		},
+		s: `request.count:5|c|#answer:42,hello:world
 request.rtt:0.1|h|#answer:42,hello:world
 `,
-			dp: []string{},
-		},
+		dp: []string{},
+	},
 
-		{
-			m: stats.Measure{
-				Name: "request",
-				Fields: []stats.Field{
-					stats.MakeField("dist_rtt", 100*time.Millisecond, stats.Histogram),
-				},
-				Tags: []stats.Tag{
-					stats.T("answer", "42"),
-					stats.T("hello", "world"),
-				},
+	{
+		m: stats.Measure{
+			Name: "request",
+			Fields: []stats.Field{
+				stats.MakeField("dist_rtt", 100*time.Millisecond, stats.Histogram),
+			},
+			Tags: []stats.Tag{
+				stats.T("answer", "42"),
+				stats.T("hello", "world"),
 			},
-			s: `request.dist_rtt:0.1|d|#answer:42,hello:world
-`,
-			dp: []string{"dist_"},
 		},
-	}
-)
+		s: `request.dist_rtt:0.1|d|#answer:42,hello:world
+`,
+		dp: []string{"dist_"},
+	},
+}
 
 func TestAppendMeasure(t *testing.T) {
 	client := NewClient(DefaultAddress)
diff --git a/datadog/server_test.go b/datadog/server_test.go
index 27b483b..0364ef2 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -73,7 +73,6 @@ func TestServer(t *testing.T) {
 
 func startUDPTestServer(t *testing.T, handler Handler) (addr string, closer io.Closer) {
 	conn, err := net.ListenPacket("udp", "127.0.0.1:0")
-
 	if err != nil {
 		t.Error(err)
 		t.FailNow()
diff --git a/grafana/query.go b/grafana/query.go
index dda92ad..67275ed 100644
--- a/grafana/query.go
+++ b/grafana/query.go
@@ -109,7 +109,7 @@ func DescCol(text string, colType ColumnType) Column {
 // Grafana.
 type ColumnType string
 
-// ColumnTypes
+// ColumnTypes.
 const (
 	Untyped ColumnType = ""
 	String  ColumnType = "string"
diff --git a/handler.go b/handler.go
index 581f34c..caa76a4 100644
--- a/handler.go
+++ b/handler.go
@@ -74,7 +74,7 @@ func (m *multiHandler) Flush() {
 	}
 }
 
-// FilteredHandler constructs a Handler that processes Measures with `filter` before forwarding to `h`
+// FilteredHandler constructs a Handler that processes Measures with `filter` before forwarding to `h`.
 func FilteredHandler(h Handler, filter func([]Measure) []Measure) Handler {
 	return &filteredHandler{handler: h, filter: filter}
 }
diff --git a/httpstats/context_test.go b/httpstats/context_test.go
index d9bb6bf..cef18a8 100644
--- a/httpstats/context_test.go
+++ b/httpstats/context_test.go
@@ -6,8 +6,9 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/segmentio/stats/v4"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/segmentio/stats/v4"
 )
 
 // TestRequestContextTagPropegation verifies that the root ancestor tags are
diff --git a/httpstats/metrics.go b/httpstats/metrics.go
index a943012..c34ee79 100644
--- a/httpstats/metrics.go
+++ b/httpstats/metrics.go
@@ -366,7 +366,7 @@ func transferEncoding(te []string) string {
 	}
 }
 
-func parseContentType(s string) (contentType string, charset string) {
+func parseContentType(s string) (contentType, charset string) {
 	for i := 0; len(s) != 0; i++ {
 		var t string
 		if t, s = parseHeaderToken(s); strings.HasPrefix(t, "charset=") {
@@ -378,7 +378,7 @@ func parseContentType(s string) (contentType string, charset string) {
 	return
 }
 
-func parseHeaderToken(s string) (token string, next string) {
+func parseHeaderToken(s string) (token, next string) {
 	if i := strings.IndexByte(s, ';'); i >= 0 {
 		token, next = strings.TrimSpace(s[:i]), strings.TrimSpace(s[i+1:])
 	} else {
diff --git a/httpstats/transport.go b/httpstats/transport.go
index c617c17..16c9f7f 100644
--- a/httpstats/transport.go
+++ b/httpstats/transport.go
@@ -27,7 +27,7 @@ type transport struct {
 	eng       *stats.Engine
 }
 
-// RoundTrip implements http.RoundTripper
+// RoundTrip implements http.RoundTripper.
 func (t *transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
 	start := time.Now()
 	rtrip := t.transport
diff --git a/httpstats/transport_test.go b/httpstats/transport_test.go
index 1900566..5370b42 100644
--- a/httpstats/transport_test.go
+++ b/httpstats/transport_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestTransport(t *testing.T) {
-	newRequest := func(method string, path string, body io.Reader) *http.Request {
+	newRequest := func(method, path string, body io.Reader) *http.Request {
 		req, _ := http.NewRequest(method, path, body)
 		return req
 	}
diff --git a/influxdb/client.go b/influxdb/client.go
index 2f52d04..f36e07a 100644
--- a/influxdb/client.go
+++ b/influxdb/client.go
@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/segmentio/objconv/json"
+
 	"github.com/segmentio/stats/v4"
 )
 
@@ -184,7 +185,7 @@ func (s *serializer) Write(b []byte) (n int, err error) {
 	return
 }
 
-func makeURL(address string, database string) *url.URL {
+func makeURL(address, database string) *url.URL {
 	if !strings.Contains(address, "://") {
 		address = "http://" + address
 	}
diff --git a/measure.go b/measure.go
index acfe5aa..52392b5 100644
--- a/measure.go
+++ b/measure.go
@@ -63,18 +63,17 @@ func stringTags(tags []Tag) []string {
 // The rules for converting values to measure are:
 //
 //  1. All fields exposing a 'metric' tag are expected to be of type bool, int,
-//  int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr,
-//  float32, float64, or time.Duration, and represent fields of the measures.
-//  The struct fields may also define a 'type' tag with a value of "counter",
-//  "gauge" or "histogram" to tune the behavior of the measure handlers.
+//     int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr,
+//     float32, float64, or time.Duration, and represent fields of the measures.
+//     The struct fields may also define a 'type' tag with a value of "counter",
+//     "gauge" or "histogram" to tune the behavior of the measure handlers.
 //
 //  2. All fields exposing a 'tag' tag are expected to be of type string and
-//  represent tags of the measures.
+//     represent tags of the measures.
 //
 //  3. All struct fields are searched recursively for fields matching rule (1)
-//  and (2). Tags found within a struct are inherited by measures generated from
-//  sub-fields, they may also be overwritten.
-//
+//     and (2). Tags found within a struct are inherited by measures generated from
+//     sub-fields, they may also be overwritten.
 func MakeMeasures(prefix string, value interface{}, tags ...Tag) []Measure {
 	if !TagsAreSorted(tags) {
 		SortTags(tags)
@@ -111,8 +110,8 @@ func appendMeasures(m []Measure, cache *measureCache, prefix string, v reflect.V
 		return m
 	}
 
-	var ptr = unsafe.Pointer(p.Pointer())
-	var typ = v.Type()
+	ptr := unsafe.Pointer(p.Pointer())
+	typ := v.Type()
 	var mf []measureFuncs
 	var ok bool
 
@@ -447,11 +446,11 @@ func makeTagFunc(sf structField, name string) func(unsafe.Pointer) Tag {
 
 type tagFuncByName []namedTagFunc
 
-func (t tagFuncByName) Len() int               { return len(t) }
-func (t tagFuncByName) Less(i int, j int) bool { return t[i].name < t[j].name }
-func (t tagFuncByName) Swap(i int, j int)      { t[i], t[j] = t[j], t[i] }
+func (t tagFuncByName) Len() int           { return len(t) }
+func (t tagFuncByName) Less(i, j int) bool { return t[i].name < t[j].name }
+func (t tagFuncByName) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
 
-func concat(prefix string, suffix string) string {
+func concat(prefix, suffix string) string {
 	if len(prefix) == 0 {
 		return suffix
 	}
@@ -505,7 +504,7 @@ func (c *measureCache) load() *map[reflect.Type][]measureFuncs {
 	return (*map[reflect.Type][]measureFuncs)(atomic.LoadPointer(&c.cache))
 }
 
-func (c *measureCache) compareAndSwap(old *map[reflect.Type][]measureFuncs, new *map[reflect.Type][]measureFuncs) bool {
+func (c *measureCache) compareAndSwap(old, new *map[reflect.Type][]measureFuncs) bool {
 	return atomic.CompareAndSwapPointer(&c.cache,
 		unsafe.Pointer(old),
 		unsafe.Pointer(new),
diff --git a/netstats/conn.go b/netstats/conn.go
index 669dc33..63eafd8 100644
--- a/netstats/conn.go
+++ b/netstats/conn.go
@@ -8,8 +8,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/segmentio/stats/v4"
 	"github.com/segmentio/vpcinfo"
+
+	"github.com/segmentio/stats/v4"
 )
 
 func init() {
diff --git a/procstats/collector.go b/procstats/collector.go
index 5dd3d46..6563555 100644
--- a/procstats/collector.go
+++ b/procstats/collector.go
@@ -23,6 +23,7 @@ type Config struct {
 	Collector       Collector
 	CollectInterval time.Duration
 }
+
 // MultiCollector coalesces a variadic number of Collectors
 // and returns a single Collector.
 func MultiCollector(collectors ...Collector) Collector {
@@ -37,6 +38,7 @@ func MultiCollector(collectors ...Collector) Collector {
 func StartCollector(collector Collector) io.Closer {
 	return StartCollectorWith(Config{Collector: collector})
 }
+
 // StartCollectorWith starts a Collector with the provided Config.
 func StartCollectorWith(config Config) io.Closer {
 	config = setConfigDefaults(config)
diff --git a/procstats/delaystats.go b/procstats/delaystats.go
index 90f2aa4..39834f4 100644
--- a/procstats/delaystats.go
+++ b/procstats/delaystats.go
@@ -41,7 +41,6 @@ func (d *DelayMetrics) Collect() {
 	}
 }
 
-
 // DelayInfo stores delay Durations for various resources.
 type DelayInfo struct {
 	CPUDelay       time.Duration
diff --git a/procstats/go.go b/procstats/go.go
index c2eacec..cc8409e 100644
--- a/procstats/go.go
+++ b/procstats/go.go
@@ -228,7 +228,7 @@ func makeGCPauses(memstats *runtime.MemStats, lastNumGC uint32) (pauses []time.D
 	return makePauses(memstats.PauseNs[i:j], nil)
 }
 
-func makePauses(head []uint64, tail []uint64) (pauses []time.Duration) {
+func makePauses(head, tail []uint64) (pauses []time.Duration) {
 	pauses = make([]time.Duration, 0, len(head)+len(tail))
 	pauses = appendPauses(pauses, head)
 	pauses = appendPauses(pauses, tail)
diff --git a/procstats/linux/cgroup.go b/procstats/linux/cgroup.go
index 1669898..223039f 100644
--- a/procstats/linux/cgroup.go
+++ b/procstats/linux/cgroup.go
@@ -29,6 +29,7 @@ func (pcg ProcCGroup) Lookup(name string) (cgroup CGroup, ok bool) {
 	})
 	return
 }
+
 // ReadProcCGroup takes an int argument representing a PID
 // and returns a ProcCGroup and error, if any is encountered.
 func ReadProcCGroup(pid int) (proc ProcCGroup, err error) {
@@ -36,6 +37,7 @@ func ReadProcCGroup(pid int) (proc ProcCGroup, err error) {
 	proc = parseProcCGroup(readProcFile(pid, "cgroup"))
 	return
 }
+
 // ParseProcCGroup parses Linux system cgroup data and returns a ProcCGroup and error, if any is encountered.
 func ParseProcCGroup(s string) (proc ProcCGroup, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
@@ -62,6 +64,7 @@ func parseProcCGroup(s string) (proc ProcCGroup) {
 	})
 	return
 }
+
 // ReadCPUPeriod takes a string representing a Linux cgroup and returns
 // the period as a time.Duration that is applied for this cgroup and an error, if any.
 func ReadCPUPeriod(cgroup string) (period time.Duration, err error) {
@@ -69,6 +72,7 @@ func ReadCPUPeriod(cgroup string) (period time.Duration, err error) {
 	period = readCPUPeriod(cgroup)
 	return
 }
+
 // ReadCPUQuota takes a string representing a Linux cgroup and returns
 // the quota as a time.Duration that is applied for this cgroup and an error, if any.
 func ReadCPUQuota(cgroup string) (quota time.Duration, err error) {
diff --git a/procstats/linux/limits.go b/procstats/linux/limits.go
index 3222b04..4b2e995 100644
--- a/procstats/linux/limits.go
+++ b/procstats/linux/limits.go
@@ -2,18 +2,19 @@ package linux
 
 import "strconv"
 
-// Represents Linux's unlimited for resource limits
+// Represents Linux's unlimited for resource limits.
 const (
 	Unlimited uint64 = 1<<64 - 1
 )
 
-// Limits holds configuration for resource limits
+// Limits holds configuration for resource limits.
 type Limits struct {
 	Name string
 	Soft uint64
 	Hard uint64
 	Unit string
 }
+
 // ProcLimits holds Limits for processes.
 type ProcLimits struct {
 	CPUTime          Limits // seconds
@@ -33,12 +34,14 @@ type ProcLimits struct {
 	RealtimePriority Limits
 	RealtimeTimeout  Limits
 }
+
 // ReadProcLimits returns the ProcLimits and an error, if any, for a PID.
 func ReadProcLimits(pid int) (proc ProcLimits, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcLimits(readProcFile(pid, "limits"))
 	return
 }
+
 // ParseProcLimits parses system process limits and returns a ProcLimits and error, if any.
 func ParseProcLimits(s string) (proc ProcLimits, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
@@ -68,12 +71,11 @@ func parseProcLimits(s string) (proc ProcLimits) {
 
 	columns := make([]string, 0, 4)
 	forEachLineExceptFirst(s, func(line string) {
-
 		columns = columns[:0]
 		forEachColumn(line, func(col string) { columns = append(columns, col) })
 
 		var limits Limits
-		var length = len(columns)
+		length := len(columns)
 
 		if length > 0 {
 			limits.Name = columns[0]
diff --git a/procstats/linux/limits_test.go b/procstats/linux/limits_test.go
index 76c610a..8d8420c 100644
--- a/procstats/linux/limits_test.go
+++ b/procstats/linux/limits_test.go
@@ -26,7 +26,6 @@ Max realtime timeout      unlimited            unlimited            us
 `
 
 	proc, err := ParseProcLimits(text)
-
 	if err != nil {
 		t.Error(err)
 		return
diff --git a/procstats/linux/parse.go b/procstats/linux/parse.go
index 924290f..f4a7fad 100644
--- a/procstats/linux/parse.go
+++ b/procstats/linux/parse.go
@@ -57,11 +57,11 @@ func forEachProperty(text string, call func(string, string)) {
 	forEachLine(text, func(line string) { call(splitProperty(line)) })
 }
 
-func splitProperty(text string) (key string, val string) {
+func splitProperty(text string) (key, val string) {
 	return split(text, ':')
 }
 
-func split(text string, sep byte) (head string, tail string) {
+func split(text string, sep byte) (head, tail string) {
 	if i := strings.IndexByte(text, sep); i >= 0 {
 		head, tail = text[:i], text[i+1:]
 	} else {
diff --git a/procstats/linux/parse_test.go b/procstats/linux/parse_test.go
index bd4cb11..185663c 100644
--- a/procstats/linux/parse_test.go
+++ b/procstats/linux/parse_test.go
@@ -81,7 +81,7 @@ func TestForEachProperty(t *testing.T) {
 
 	for _, test := range tests {
 		kv := []KV{}
-		forEachProperty(test.text, func(k string, v string) { kv = append(kv, KV{k, v}) })
+		forEachProperty(test.text, func(k, v string) { kv = append(kv, KV{k, v}) })
 
 		if !reflect.DeepEqual(kv, test.kv) {
 			t.Error(kv)
diff --git a/procstats/linux/sched.go b/procstats/linux/sched.go
index 20b2360..dd548ed 100644
--- a/procstats/linux/sched.go
+++ b/procstats/linux/sched.go
@@ -12,13 +12,15 @@ type ProcSched struct {
 	SEAvgLoadAvg          uint64 // se.avg.load_avg
 	SEAvgUtilAvg          uint64 // se.avg.util_avg
 }
+
 // ReadProcSched returns a ProcSched and error, if any, for a PID.
 func ReadProcSched(pid int) (proc ProcSched, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcSched(readProcFile(pid, "sched"))
 	return
 }
-//ParseProcSched processes system process scheduling data and returns a ProcSched and error, if any.
+
+// ParseProcSched processes system process scheduling data and returns a ProcSched and error, if any.
 func ParseProcSched(s string) (proc ProcSched, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 	proc = parseProcSched(s)
@@ -39,7 +41,7 @@ func parseProcSched(s string) (proc ProcSched) {
 	s = skipLine(s) // <progname> (<pid>, #threads: 1)
 	s = skipLine(s) // -------------------------------
 
-	forEachProperty(s, func(key string, val string) {
+	forEachProperty(s, func(key, val string) {
 		if field := intFields[key]; field != nil {
 			v, e := strconv.ParseUint(val, 10, 64)
 			check(e)
diff --git a/procstats/linux/sched_test.go b/procstats/linux/sched_test.go
index 1bf71f5..4b80593 100644
--- a/procstats/linux/sched_test.go
+++ b/procstats/linux/sched_test.go
@@ -26,7 +26,6 @@ clock-delta                                  :                   41
 `
 
 	proc, err := ParseProcSched(text)
-
 	if err != nil {
 		t.Error(err)
 		return
@@ -43,5 +42,4 @@ clock-delta                                  :                   41
 	}) {
 		t.Error(proc)
 	}
-
 }
diff --git a/procstats/linux/stat.go b/procstats/linux/stat.go
index df2c90b..5eaa7bc 100644
--- a/procstats/linux/stat.go
+++ b/procstats/linux/stat.go
@@ -19,6 +19,7 @@ const (
 	Wakekill                        ProcState = 'W'
 	Parked                          ProcState = 'P'
 )
+
 // Scan updates the ProcState for a process.
 func (ps *ProcState) Scan(s fmt.ScanState, _ rune) (err error) {
 	var c rune
@@ -30,6 +31,7 @@ func (ps *ProcState) Scan(s fmt.ScanState, _ rune) (err error) {
 
 	return
 }
+
 // ProcStat contains statistics associated with a process.
 type ProcStat struct {
 	Pid                 int32     // (1) pid
diff --git a/procstats/linux/stat_test.go b/procstats/linux/stat_test.go
index 7e42bf8..841a917 100644
--- a/procstats/linux/stat_test.go
+++ b/procstats/linux/stat_test.go
@@ -9,7 +9,6 @@ func TestParseProcStat(t *testing.T) {
 	text := `69 (cat) R 56 1 1 0 -1 4210944 83 0 0 0 0 0 0 0 20 0 1 0 1977676 4644864 193 18446744073709551615 4194304 4240332 140724300789216 140724300788568 140342654634416 0 0 0 0 0 0 0 17 0 0 0 0 0 0 6340112 6341364 24690688 140724300791495 140724300791515 140724300791515 140724300791791 0`
 
 	proc, err := ParseProcStat(text)
-
 	if err != nil {
 		t.Error(err)
 		return
diff --git a/procstats/linux/statm_test.go b/procstats/linux/statm_test.go
index 4933dbb..451a42c 100644
--- a/procstats/linux/statm_test.go
+++ b/procstats/linux/statm_test.go
@@ -9,7 +9,6 @@ func TestParseProcStatm(t *testing.T) {
 	text := `1134 172 153 12 0 115 0`
 
 	proc, err := ParseProcStatm(text)
-
 	if err != nil {
 		t.Error(err)
 		return
diff --git a/procstats/proc.go b/procstats/proc.go
index 02f7241..752adaa 100644
--- a/procstats/proc.go
+++ b/procstats/proc.go
@@ -154,7 +154,6 @@ func (p *ProcMetrics) Collect() {
 
 			p.cpu.total.time = (m.CPU.User + m.CPU.Sys) - (p.last.CPU.User + p.last.CPU.Sys)
 			p.cpu.total.percent = 100 * float64(p.cpu.total.time) / interval
-
 		}
 
 		p.memory.available = m.Memory.Available
@@ -180,8 +179,7 @@ func (p *ProcMetrics) Collect() {
 	}
 }
 
-
-// ProcInfo contains types which hold statistics for various resources
+// ProcInfo contains types which hold statistics for various resources.
 type ProcInfo struct {
 	CPU     CPUInfo
 	Memory  MemoryInfo
@@ -189,7 +187,7 @@ type ProcInfo struct {
 	Threads ThreadInfo
 }
 
-// CollectProcInfo return a ProcInfo and error (if any) for a given PID
+// CollectProcInfo return a ProcInfo and error (if any) for a given PID.
 func CollectProcInfo(pid int) (ProcInfo, error) {
 	return collectProcInfo(pid)
 }
@@ -229,6 +227,7 @@ type FileInfo struct {
 	Open uint64 // fds opened by the process
 	Max  uint64 // max number of fds the process can open
 }
+
 // ThreadInfo holds statistics about number of threads and context switches for a process.
 type ThreadInfo struct {
 	Num                        uint64
diff --git a/procstats/proc_darwin.go b/procstats/proc_darwin.go
index e8137a1..cac113a 100644
--- a/procstats/proc_darwin.go
+++ b/procstats/proc_darwin.go
@@ -21,6 +21,7 @@ static mach_port_t mach_task_self() { return mach_task_self_; }
 #endif
 */
 import "C"
+
 import (
 	"errors"
 	"fmt"
@@ -76,7 +77,7 @@ func memoryAvailable() uint64 {
 	return uint64(mem)
 }
 
-func taskInfo(task C.mach_port_name_t) (virtual uint64, resident uint64, suspend uint64) {
+func taskInfo(task C.mach_port_name_t) (virtual, resident, suspend uint64) {
 	info := C.mach_task_basic_info_data_t{}
 	count := C.mach_msg_type_number_t(C.MACH_TASK_BASIC_INFO_COUNT)
 
diff --git a/prometheus/append.go b/prometheus/append.go
index ace4d3e..38b1e8c 100644
--- a/prometheus/append.go
+++ b/prometheus/append.go
@@ -12,7 +12,7 @@ func appendMetricName(b []byte, s string) []byte {
 	return b
 }
 
-func appendMetricScopedName(b []byte, scope string, name string) []byte {
+func appendMetricScopedName(b []byte, scope, name string) []byte {
 	if len(scope) != 0 {
 		b = appendMetricName(b, scope)
 		b = append(b, '_')
@@ -44,7 +44,7 @@ func appendMetric(b []byte, metric metric) []byte {
 	return append(b, '\n')
 }
 
-func appendMetricHelp(b []byte, scope string, name string, help string) []byte {
+func appendMetricHelp(b []byte, scope, name, help string) []byte {
 	b = append(b, "# HELP "...)
 	b = appendMetricScopedName(b, scope, name)
 	b = append(b, ' ')
@@ -52,7 +52,7 @@ func appendMetricHelp(b []byte, scope string, name string, help string) []byte {
 	return append(b, '\n')
 }
 
-func appendMetricType(b []byte, scope string, name string, mtype string) []byte {
+func appendMetricType(b []byte, scope, name, mtype string) []byte {
 	b = append(b, "# TYPE "...)
 	b = appendMetricScopedName(b, scope, name)
 	b = append(b, ' ')
diff --git a/prometheus/handler.go b/prometheus/handler.go
index 41c33d1..2a2d102 100644
--- a/prometheus/handler.go
+++ b/prometheus/handler.go
@@ -61,7 +61,7 @@ func (h *Handler) HandleMeasures(mtime time.Time, measures ...stats.Measure) {
 
 		for _, f := range m.Fields {
 			var buckets []stats.Value
-			var mtype = typeOf(f.Type())
+			mtype := typeOf(f.Type())
 
 			if mtype == histogram {
 				k := stats.Key{Measure: m.Name, Field: f.Name}
@@ -137,7 +137,7 @@ func (h *Handler) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 
 // WriteStats accepts a writer and pushes metrics (one at a time) to it.
 // An example could be if you just want to print all the metrics on to Stdout
-// It will not call flush. Make sure the Close and Flush are handled at the caller
+// It will not call flush. Make sure the Close and Flush are handled at the caller.
 func (h *Handler) WriteStats(w io.Writer) {
 	b := make([]byte, 1024)
 
@@ -164,7 +164,7 @@ func (h *Handler) WriteStats(w io.Writer) {
 	}
 }
 
-func acceptEncoding(accept string, check string) bool {
+func acceptEncoding(accept, check string) bool {
 	for _, coding := range strings.Split(accept, ",") {
 		if coding = strings.TrimSpace(coding); strings.HasPrefix(coding, check) {
 			return true
@@ -187,11 +187,11 @@ func (cache *handleMetricCache) Len() int {
 	return len(cache.labels)
 }
 
-func (cache *handleMetricCache) Swap(i int, j int) {
+func (cache *handleMetricCache) Swap(i, j int) {
 	cache.labels[i], cache.labels[j] = cache.labels[j], cache.labels[i]
 }
 
-func (cache *handleMetricCache) Less(i int, j int) bool {
+func (cache *handleMetricCache) Less(i, j int) bool {
 	return cache.labels[i].less(cache.labels[j])
 }
 
diff --git a/prometheus/label.go b/prometheus/label.go
index 311045d..96a4ca2 100644
--- a/prometheus/label.go
+++ b/prometheus/label.go
@@ -2,6 +2,7 @@ package prometheus
 
 import (
 	"github.com/segmentio/fasthash/jody"
+
 	"github.com/segmentio/stats/v4"
 )
 
diff --git a/prometheus/metric.go b/prometheus/metric.go
index 597ec49..d8a81c3 100644
--- a/prometheus/metric.go
+++ b/prometheus/metric.go
@@ -142,7 +142,7 @@ type metricEntry struct {
 	states metricStateMap
 }
 
-func newMetricEntry(mtype metricType, scope string, name string, help string) *metricEntry {
+func newMetricEntry(mtype metricType, scope, name, help string) *metricEntry {
 	entry := &metricEntry{
 		mtype:  mtype,
 		scope:  scope,
@@ -406,7 +406,7 @@ func le(buckets []stats.Value) string {
 
 // This function converts the byte array to a string without additional
 // memory allocation.
-// Source: https://stackoverflow.com/a/66865482 (license: CC BY-SA 4.0)
+// Source: https://stackoverflow.com/a/66865482 (license: CC BY-SA 4.0).
 func unsafeByteSliceToString(b []byte) string {
 	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
 	var s string
@@ -416,7 +416,7 @@ func unsafeByteSliceToString(b []byte) string {
 	return s
 }
 
-func nextLe(s string) (head string, tail string) {
+func nextLe(s string) (head, tail string) {
 	if i := strings.IndexByte(s, ':'); i >= 0 {
 		head, tail = s[:i], s[i+1:]
 	} else {
@@ -435,11 +435,11 @@ func (metrics byNameAndLabels) Len() int {
 	return len(metrics)
 }
 
-func (metrics byNameAndLabels) Swap(i int, j int) {
+func (metrics byNameAndLabels) Swap(i, j int) {
 	metrics[i], metrics[j] = metrics[j], metrics[i]
 }
 
-func (metrics byNameAndLabels) Less(i int, j int) bool {
+func (metrics byNameAndLabels) Less(i, j int) bool {
 	m1 := &metrics[i]
 	m2 := &metrics[j]
 	return m1.name < m2.name || (m1.name == m2.name && m1.labels.less(m2.labels))
diff --git a/statstest/handler.go b/statstest/handler.go
index 30e6204..4ff3e74 100644
--- a/statstest/handler.go
+++ b/statstest/handler.go
@@ -8,8 +8,10 @@ import (
 	"github.com/segmentio/stats/v4"
 )
 
-var _ stats.Handler = (*Handler)(nil)
-var _ stats.Flusher = (*Handler)(nil)
+var (
+	_ stats.Handler = (*Handler)(nil)
+	_ stats.Flusher = (*Handler)(nil)
+)
 
 // Handler is a stats handler that can record measures for inspection.
 type Handler struct {
diff --git a/tag.go b/tag.go
index 599b3e3..abc8530 100644
--- a/tag.go
+++ b/tag.go
@@ -14,7 +14,7 @@ type Tag struct {
 }
 
 // T is shorthand for `stats.Tag{Name: "blah", Value: "foo"}`  It returns
-// the tag for Name k and Value v
+// the tag for Name k and Value v.
 func T(k, v string) Tag {
 	return Tag{Name: k, Value: v}
 }
diff --git a/value.go b/value.go
index de365d2..68bd148 100644
--- a/value.go
+++ b/value.go
@@ -21,8 +21,9 @@ func MustValueOf(v Value) Value {
 	}
 	return v
 }
+
 // ValueOf inspects v's underlying type and returns a Value which encapsulates this type.
-// If the underlying type of v is not supported by Value's encapsulation its Type() will return stats.Invalid
+// If the underlying type of v is not supported by Value's encapsulation its Type() will return stats.Invalid.
 func ValueOf(v interface{}) Value {
 	switch x := v.(type) {
 	case Value:
@@ -123,30 +124,37 @@ func float64Value(v float64) Value {
 func durationValue(v time.Duration) Value {
 	return Value{typ: Duration, bits: uint64(v)}
 }
+
 // Type returns the Type of this value.
 func (v Value) Type() Type {
 	return v.typ
 }
+
 // Bool returns a bool if the underlying data for this value is zero.
 func (v Value) Bool() bool {
 	return v.bits != 0
 }
+
 // Int returns an new int64 representation of this Value.
 func (v Value) Int() int64 {
 	return int64(v.bits)
 }
+
 // Uint returns a uint64 representation of this Value.
 func (v Value) Uint() uint64 {
 	return v.bits
 }
+
 // Float returns a new float64 representation of this Value.
 func (v Value) Float() float64 {
 	return math.Float64frombits(v.bits)
 }
+
 // Duration returns a new time.Duration representation of this Value.
 func (v Value) Duration() time.Duration {
 	return time.Duration(v.bits)
 }
+
 // Interface returns an new interface{} representation of this value.
 // However, if the underlying Type is unsupported it panics.
 func (v Value) Interface() interface{} {
@@ -167,6 +175,7 @@ func (v Value) Interface() interface{} {
 		panic("unknown type found in a stats.Value")
 	}
 }
+
 // String returns a string representation of the underling value.
 func (v Value) String() string {
 	switch v.Type() {
@@ -186,6 +195,7 @@ func (v Value) String() string {
 		return "<unknown>"
 	}
 }
+
 // Type is an int32 type alias used to denote a values underlying type.
 type Type int32
 
@@ -199,6 +209,7 @@ const (
 	Duration
 	Invalid
 )
+
 // String returns the string representation of a type.
 func (t Type) String() string {
 	switch t {
@@ -218,6 +229,7 @@ func (t Type) String() string {
 		return "<unknown>"
 	}
 }
+
 // GoString implements the GoStringer interface.
 func (t Type) GoString() string {
 	switch t {
diff --git a/veneur/client.go b/veneur/client.go
index 30cebea..60578e6 100644
--- a/veneur/client.go
+++ b/veneur/client.go
@@ -7,7 +7,7 @@ import (
 	"github.com/segmentio/stats/v4/datadog"
 )
 
-// Const Sink Configuration types
+// Const Sink Configuration types.
 const (
 	GlobalOnly = "veneurglobalonly"
 	LocalOnly  = "veneurlocalonly"
@@ -18,7 +18,7 @@ const (
 	KafkaSink    = "kafka"
 )
 
-// SinkOnly tags
+// SinkOnly tags.
 var (
 	TagSignalfxOnly = stats.Tag{Name: SinkOnly, Value: SignalfxSink}
 	TagDatadogOnly  = stats.Tag{Name: SinkOnly, Value: DatadogSink}
@@ -27,7 +27,7 @@ var (
 
 // The ClientConfig type is used to configure veneur clients.
 // It inherits the datadog config since the veneur client reuses
-// the logic in the datadog client to emit metrics
+// the logic in the datadog client to emit metrics.
 type ClientConfig struct {
 	datadog.ClientConfig
 
@@ -57,7 +57,7 @@ func NewClient(addr string) *Client {
 	return NewClientWith(ClientConfig{ClientConfig: datadog.ClientConfig{Address: addr}})
 }
 
-// NewClientGlobal creates a client that sends all metrics to the Global Veneur Aggregator
+// NewClientGlobal creates a client that sends all metrics to the Global Veneur Aggregator.
 func NewClientGlobal(addr string) *Client {
 	return NewClientWith(ClientConfig{ClientConfig: datadog.ClientConfig{Address: addr}, GlobalOnly: true})
 }
@@ -65,7 +65,6 @@ func NewClientGlobal(addr string) *Client {
 // NewClientWith creates and returns a new veneur client configured with the
 // given config.
 func NewClientWith(config ClientConfig) *Client {
-
 	// Construct Veneur-specific Tags we will append to measures
 	tags := []stats.Tag{}
 	if config.GlobalOnly {
@@ -89,7 +88,6 @@ func NewClientWith(config ClientConfig) *Client {
 
 // HandleMeasures satisfies the stats.Handler interface.
 func (c *Client) HandleMeasures(time time.Time, measures ...stats.Measure) {
-
 	// If there are no tags to add, call HandleMeasures with measures directly
 	if len(c.tags) == 0 {
 		c.Client.HandleMeasures(time, measures...)

From 60825cef81bc0765b22059c81a9983c4219e53d4 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 13:04:42 -0600
Subject: [PATCH 45/63] hand-fix some linting issues

---
 README.md              |  2 +-
 buffer.go              |  6 +-----
 cmd/dogstatsd/main.go  |  2 +-
 datadog/parse.go       | 10 ++++++----
 datadog/server.go      | 29 ++++++++++++++++++++---------
 httpstats/metrics.go   |  2 +-
 httpstats/transport.go | 21 +++++++++++----------
 7 files changed, 41 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 30d975c..00fc260 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ type funcMetrics struct {
 ```go
 t := time.Now()
 f()
-callTime := time.Now().Sub(t)
+callTime := time.Since(t)
 
 m := &funcMetrics{}
 m.calls.count = 1
diff --git a/buffer.go b/buffer.go
index b5ddc47..378fb5e 100644
--- a/buffer.go
+++ b/buffer.go
@@ -132,7 +132,7 @@ type Serializer interface {
 type buffer struct {
 	lock uint64
 	data []byte
-	pad  [32]byte // padding to avoid false sharing between threads
+	_    [32]byte // padding to avoid false sharing between threads
 }
 
 func (b *buffer) acquire() bool {
@@ -155,10 +155,6 @@ func (b *buffer) len() int {
 	return len(b.data)
 }
 
-func (b *buffer) cap() int {
-	return cap(b.data)
-}
-
 func (b *buffer) flush(w io.Writer, n int) {
 	w.Write(b.data[:n])
 	n = copy(b.data, b.data[n:])
diff --git a/cmd/dogstatsd/main.go b/cmd/dogstatsd/main.go
index 59d046d..e8946df 100644
--- a/cmd/dogstatsd/main.go
+++ b/cmd/dogstatsd/main.go
@@ -101,7 +101,7 @@ func client(cmd string, args ...string) {
 	case "time":
 		start := time.Now()
 		run(extra...)
-		stats.Observe(name, time.Now().Sub(start), tags...)
+		stats.Observe(name, time.Since(start), tags...)
 	}
 }
 
diff --git a/datadog/parse.go b/datadog/parse.go
index f4b0fd7..7c9894f 100644
--- a/datadog/parse.go
+++ b/datadog/parse.go
@@ -222,12 +222,14 @@ func split(s string, b byte) (head, tail string) {
 
 func count(s string, b byte) (n int) {
 	for {
-		if off := strings.IndexByte(s, b); off < 0 {
+		off := strings.IndexByte(s, b)
+		if off < 0 {
 			break
-		} else {
-			n++
-			s = s[off+1:]
 		}
+
+		n++
+		s = s[off+1:]
 	}
+
 	return
 }
diff --git a/datadog/server.go b/datadog/server.go
index 055d182..855ddc2 100644
--- a/datadog/server.go
+++ b/datadog/server.go
@@ -2,6 +2,7 @@ package datadog
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"net"
 	"runtime"
@@ -30,7 +31,7 @@ func (f HandlerFunc) HandleMetric(m Metric, a net.Addr) {
 }
 
 // HandleEvent is a no-op for backwards compatibility.
-func (f HandlerFunc) HandleEvent(e Event, a net.Addr) {
+func (f HandlerFunc) HandleEvent(Event, net.Addr) {
 	return
 }
 
@@ -49,7 +50,7 @@ func ListenAndServe(addr string, handler Handler) (err error) {
 
 // Serve runs a dogstatsd server, listening for datagrams on conn and forwarding
 // the metrics to handler.
-func Serve(conn net.PacketConn, handler Handler) (err error) {
+func Serve(conn net.PacketConn, handler Handler) error {
 	defer conn.Close()
 
 	concurrency := runtime.GOMAXPROCS(-1)
@@ -58,22 +59,32 @@ func Serve(conn net.PacketConn, handler Handler) (err error) {
 	}
 
 	done := make(chan error, concurrency)
-	conn.SetDeadline(time.Time{})
+	err := conn.SetDeadline(time.Time{})
+	if err != nil {
+		return err
+	}
 
-	for i := 0; i != concurrency; i++ {
+	for i := 0; i < concurrency; i++ {
 		go serve(conn, handler, done)
 	}
 
-	for i := 0; i != concurrency; i++ {
-		switch e := <-done; e {
-		case nil, io.EOF, io.ErrClosedPipe, io.ErrUnexpectedEOF:
+	var lastErr error
+
+	for i := 0; i < concurrency; i++ {
+		err = <-done
+		switch {
+		case err == nil:
+		case errors.Is(err, io.EOF):
+		case errors.Is(err, io.ErrClosedPipe):
+		case errors.Is(err, io.ErrUnexpectedEOF):
 		default:
-			err = e
+			lastErr = err
 		}
+
 		conn.Close()
 	}
 
-	return
+	return lastErr
 }
 
 func serve(conn net.PacketConn, handler Handler, done chan<- error) {
diff --git a/httpstats/metrics.go b/httpstats/metrics.go
index c34ee79..e38217b 100644
--- a/httpstats/metrics.go
+++ b/httpstats/metrics.go
@@ -120,7 +120,7 @@ func (r *responseBody) close() {
 }
 
 func (r *responseBody) complete() {
-	r.metrics.observeResponse(r.res, r.op, r.bytes, time.Now().Sub(r.start))
+	r.metrics.observeResponse(r.res, r.op, r.bytes, time.Since(r.start))
 	r.eng.ReportAt(r.start, r.metrics)
 }
 
diff --git a/httpstats/transport.go b/httpstats/transport.go
index 16c9f7f..889dd3a 100644
--- a/httpstats/transport.go
+++ b/httpstats/transport.go
@@ -60,17 +60,18 @@ func (t *transport) RoundTrip(req *http.Request) (res *http.Response, err error)
 	req.Body.Close() // nolint
 
 	if err != nil {
-		m.observeError(time.Now().Sub(start))
+		m.observeError(time.Since(start))
 		eng.ReportAt(start, m)
-	} else {
-		res.Body = &responseBody{
-			eng:     eng,
-			res:     res,
-			metrics: m,
-			body:    res.Body,
-			op:      "read",
-			start:   start,
-		}
+		return
+	}
+
+	res.Body = &responseBody{
+		eng:     eng,
+		res:     res,
+		metrics: m,
+		body:    res.Body,
+		op:      "read",
+		start:   start,
 	}
 
 	return

From ec5f791b7be0cd79295929653978096c4c15d77d Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Tue, 18 Jul 2023 13:11:11 -0600
Subject: [PATCH 46/63] just use errgroup instead of reinventing an errgroup

---
 datadog/server.go | 60 +++++++++++++++++++++++------------------------
 go.mod            |  1 +
 go.sum            |  2 ++
 3 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/datadog/server.go b/datadog/server.go
index 855ddc2..f876f86 100644
--- a/datadog/server.go
+++ b/datadog/server.go
@@ -7,6 +7,8 @@ import (
 	"net"
 	"runtime"
 	"time"
+
+	"golang.org/x/sync/errgroup"
 )
 
 // Handler defines the interface that types must satisfy to process metrics
@@ -58,56 +60,51 @@ func Serve(conn net.PacketConn, handler Handler) error {
 		concurrency = 1
 	}
 
-	done := make(chan error, concurrency)
 	err := conn.SetDeadline(time.Time{})
 	if err != nil {
 		return err
 	}
 
-	for i := 0; i < concurrency; i++ {
-		go serve(conn, handler, done)
-	}
-
-	var lastErr error
+	var errgrp errgroup.Group
 
 	for i := 0; i < concurrency; i++ {
-		err = <-done
-		switch {
-		case err == nil:
-		case errors.Is(err, io.EOF):
-		case errors.Is(err, io.ErrClosedPipe):
-		case errors.Is(err, io.ErrUnexpectedEOF):
-		default:
-			lastErr = err
-		}
+		errgrp.Go(func() error {
+			return serve(conn, handler)
+		})
+	}
 
-		conn.Close()
+	err = errgrp.Wait()
+	switch {
+	default:
+		return err
+	case err == nil:
+	case errors.Is(err, io.EOF):
+	case errors.Is(err, io.ErrClosedPipe):
+	case errors.Is(err, io.ErrUnexpectedEOF):
 	}
 
-	return lastErr
+	return nil
 }
 
-func serve(conn net.PacketConn, handler Handler, done chan<- error) {
+func serve(conn net.PacketConn, handler Handler) error {
 	b := make([]byte, 65536)
 
 	for {
 		n, a, err := conn.ReadFrom(b)
 		if err != nil {
-			done <- err
-			return
+			return err
 		}
 
 		for s := b[:n]; len(s) != 0; {
-			var ln []byte
-			var off int
-
-			if off = bytes.IndexByte(s, '\n'); off < 0 {
+			off := bytes.IndexByte(s, '\n')
+			if off < 0 {
 				off = len(s)
 			} else {
 				off++
 			}
 
-			ln, s = s[:off], s[off:]
+			ln := s[:off]
+			s = s[off:]
 
 			if bytes.HasPrefix(ln, []byte("_e")) {
 				e, err := parseEvent(string(ln))
@@ -116,14 +113,15 @@ func serve(conn net.PacketConn, handler Handler, done chan<- error) {
 				}
 
 				handler.HandleEvent(e, a)
-			} else {
-				m, err := parseMetric(string(ln))
-				if err != nil {
-					continue
-				}
+				continue
+			}
 
-				handler.HandleMetric(m, a)
+			m, err := parseMetric(string(ln))
+			if err != nil {
+				continue
 			}
+
+			handler.HandleMetric(m, a)
 		}
 	}
 }
diff --git a/go.mod b/go.mod
index 3f89c7b..2ada8f1 100644
--- a/go.mod
+++ b/go.mod
@@ -20,6 +20,7 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 // indirect
 	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/sync v0.3.0 // indirect
 	golang.org/x/sys v0.5.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index dbc101e..5194c1c 100644
--- a/go.sum
+++ b/go.sum
@@ -35,6 +35,8 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=

From 08addf662eb46820a6263de2b6326c24a20003d5 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Wed, 19 Jul 2023 10:46:55 -0600
Subject: [PATCH 47/63] Update context.go

Co-authored-by: Kevin Burke <kevin.burke@segment.com>
---
 context.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/context.go b/context.go
index bf31431..7f9c28e 100644
--- a/context.go
+++ b/context.go
@@ -62,7 +62,7 @@ type tagSlice struct {
 // for defining context keys was copied from Go 1.7's new use of context in net/http.
 type tagsKey struct{}
 
-// String is Stringer implementation.
+// String implements the fmt.Stringer interface.
 func (k tagsKey) String() string {
 	return "stats_tags_context_key"
 }

From ee513377f43289e2ba055175ef472aa87d0a030e Mon Sep 17 00:00:00 2001
From: noctarius aka Christoph Engelbert <me@noctarius.com>
Date: Mon, 14 Aug 2023 14:03:51 +0200
Subject: [PATCH 48/63] syscall.Sysinfo returns an uint32 on linux/arm, but
 uint64 otherwise

---
 procstats/linux/memory_linux.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/procstats/linux/memory_linux.go b/procstats/linux/memory_linux.go
index 0660af7..3ea460a 100644
--- a/procstats/linux/memory_linux.go
+++ b/procstats/linux/memory_linux.go
@@ -57,7 +57,8 @@ func readSysinfoMemoryLimit() (limit uint64, err error) {
 	var sysinfo syscall.Sysinfo_t
 
 	if err = syscall.Sysinfo(&sysinfo); err == nil {
-		limit = uint64(sysinfo.Unit) * sysinfo.Totalram
+		// syscall.Sysinfo returns an uint32 on linux/arm, but uint64 otherwise
+		limit = uint64(sysinfo.Unit) * uint64(sysinfo.Totalram)
 	}
 
 	return

From 71ef609824c719b7d9f0d58ffc7e64887f1b6ac2 Mon Sep 17 00:00:00 2001
From: Kevin Gillette <kgillette@twilio.com>
Date: Thu, 28 Sep 2023 02:44:44 -0600
Subject: [PATCH 49/63] README.md: spacing fixes

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 00fc260..00c28f8 100644
--- a/README.md
+++ b/README.md
@@ -192,6 +192,7 @@ Statistics are collected for the current process and metrics including Goroutine
 count and memory usage are reported.
 
 Here's an example of how to use the collector:
+
 ```go
 package main
 
@@ -237,6 +238,7 @@ collection to a HTTP handler, reporting things like request processing time,
 error counters, header and body sizes...
 
 Here's an example of how to use the decorator:
+
 ```go
 package main
 
@@ -270,6 +272,7 @@ package exposes a decorator of `http.RoundTripper` which collects and reports
 metrics for client requests the same way it's done on the server side.
 
 Here's an example of how to use the decorator:
+
 ```go
 package main
 
@@ -298,6 +301,7 @@ func main() {
 
 You can also modify the default HTTP client to automatically get metrics for all
 packages using it, this is very convinient to get insights into dependencies.
+
 ```go
 package main
 
@@ -332,6 +336,7 @@ package exposes:
   which collects metrics for server requests.
 
 Here's an example of how to use the decorator on the client side:
+
 ```go
 package main
 

From e965d2b98487d7c468bfa91ec62b24d8f63e9e58 Mon Sep 17 00:00:00 2001
From: Vic Vijayakumar <needcaffeine@users.noreply.github.com>
Date: Thu, 28 Sep 2023 04:55:19 -0400
Subject: [PATCH 50/63] fix: update the x/exp package, and updated tagIsLess
 function (#152)

* fix: upgrade the x/exp package, and updated tagIsLess function

* fix the test

* tagIsLess -> tagCompare

* revert dependency versions: attempt to fix subpackage failure
---
 go.mod      |  7 +++----
 go.sum      |  9 ++++-----
 tag.go      | 15 ++++++++++++---
 tag_test.go |  8 ++++----
 4 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/go.mod b/go.mod
index 2ada8f1..2100ec9 100644
--- a/go.mod
+++ b/go.mod
@@ -8,20 +8,19 @@ require (
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
 	github.com/stretchr/testify v1.8.0
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
+	golang.org/x/sync v0.3.0
 )
 
 require github.com/davecgh/go-spew v1.1.1 // indirect
 
 require (
-	github.com/google/go-cmp v0.5.8 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 // indirect
 	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/sys v0.5.0 // indirect
+	golang.org/x/sys v0.12.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 5194c1c..b9fa64d 100644
--- a/go.sum
+++ b/go.sum
@@ -3,7 +3,6 @@ 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/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
-github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 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=
@@ -29,8 +28,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 h1:MGwJjxBy0HJshjDNfLsYO8xppfqWlA5ZT9OhtUUhTNw=
-golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
@@ -39,8 +38,8 @@ golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
diff --git a/tag.go b/tag.go
index abc8530..645f47a 100644
--- a/tag.go
+++ b/tag.go
@@ -35,7 +35,7 @@ func M(m map[string]string) []Tag {
 // TagsAreSorted returns true if the given list of tags is sorted by tag name,
 // false otherwise.
 func TagsAreSorted(tags []Tag) bool {
-	return slices.IsSortedFunc(tags, tagIsLess)
+	return slices.IsSortedFunc(tags, tagCompare)
 }
 
 // SortTags sorts and deduplicates tags in-place,
@@ -46,12 +46,21 @@ func SortTags(tags []Tag) []Tag {
 	// Stable sort ensures that we have deterministic
 	// "latest wins" deduplication.
 	// For 20 or fewer tags, this is as fast as an unstable sort.
-	slices.SortStableFunc(tags, tagIsLess)
+	slices.SortStableFunc(tags, tagCompare)
 
 	return deduplicateTags(tags)
 }
 
-func tagIsLess(a, b Tag) bool { return a.Name < b.Name }
+func tagCompare(a, b Tag) int {
+	switch {
+	case a.Name < b.Name:
+		return -1
+	case a.Name > b.Name:
+		return +1
+	}
+
+	return 0
+}
 
 func deduplicateTags(tags []Tag) []Tag {
 	var prev string
diff --git a/tag_test.go b/tag_test.go
index 22a4f77..e06154b 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -178,7 +178,7 @@ func BenchmarkTagsOrder(b *testing.B) {
 	})
 	b.Run("slices.IsSortedFunc", func(b *testing.B) {
 		benchmarkTagsOrder(b, func(tags []Tag) bool {
-			return slices.IsSortedFunc(tags, tagIsLess)
+			return slices.IsSortedFunc(tags, tagCompare)
 		})
 	})
 	b.Run("sort.SliceIsSorted", func(b *testing.B) {
@@ -190,7 +190,7 @@ func BenchmarkTagsOrder(b *testing.B) {
 
 func tagIsLessByIndex(tags []Tag) func(int, int) bool {
 	return func(i, j int) bool {
-		return tagIsLess(tags[i], tags[j])
+		return tagCompare(tags[i], tags[j]) < 0
 	}
 }
 
@@ -264,12 +264,12 @@ func benchmark_SortTags(b *testing.B, t0 []Tag) {
 	})
 
 	b.Run("slices.SortFunc", func(b *testing.B) {
-		fn := func(tags []Tag) { slices.SortFunc(tags, tagIsLess) }
+		fn := func(tags []Tag) { slices.SortFunc(tags, tagCompare) }
 		benchmark_SortTags_func(b, t0, fn)
 	})
 
 	b.Run("slices.SortStableFunc", func(b *testing.B) {
-		fn := func(tags []Tag) { slices.SortStableFunc(tags, tagIsLess) }
+		fn := func(tags []Tag) { slices.SortStableFunc(tags, tagCompare) }
 		benchmark_SortTags_func(b, t0, fn)
 	})
 

From 01544495ded7d6659512c8c5b4bd1b3adc0439e8 Mon Sep 17 00:00:00 2001
From: Erik Weathers <erikdw@gmail.com>
Date: Thu, 28 Sep 2023 02:01:43 -0700
Subject: [PATCH 51/63] update testify to v1.8.1 to fix snyk issue (#142)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

https://app.snyk.io/org/segment-pro/project/c9a18e75-de8c-4229-ad8d-2ca5c8f8cfbb/pr-check/15c5a32a-73c7-4cff-930d-39be988384cf

Vulnerable version of gopkg.in/yaml.v3 introduced through:

Introduced through: github.com/segmentio/archive-transformer-service@0.0.0 › github.com/segmentio/stats@v4.6.5 › github.com/stretchr/testify@v1.8.0 › github.com/stretchr/objx@v0.4.0 › github.com/stretchr/testify@v1.7.1 › gopkg.in/yaml.v3@v3.0.0-20200313102051-9f266ea9e77c
---
 go.mod | 2 +-
 go.sum | 9 ++-------
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/go.mod b/go.mod
index 2100ec9..c3e3799 100644
--- a/go.mod
+++ b/go.mod
@@ -7,7 +7,7 @@ require (
 	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
-	github.com/stretchr/testify v1.8.0
+	github.com/stretchr/testify v1.8.4
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
 	golang.org/x/sync v0.3.0
 )
diff --git a/go.sum b/go.sum
index b9fa64d..510a838 100644
--- a/go.sum
+++ b/go.sum
@@ -1,4 +1,3 @@
-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/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -22,11 +21,8 @@ github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RX
 github.com/segmentio/objconv v1.0.1/go.mod h1:auayaH5k3137Cl4SoXTgrzQcuQDmvuVtZgS0fb1Ahys=
 github.com/segmentio/vpcinfo v0.1.10 h1:iCfT3tS4h2M7WLWmzFGKysZh0ql0B8XdiHYqiPN4ke4=
 github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp978tICtquqU=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
@@ -45,6 +41,5 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

From b1acd0af3964533e731a1bdef0e138d4b50bcfbb Mon Sep 17 00:00:00 2001
From: Dean Karn <Dean.Karn@gmail.com>
Date: Thu, 28 Sep 2023 02:11:56 -0700
Subject: [PATCH 52/63] Update to latest fasthash dep (#130)

v1.0.3 of fasthash corrected a potential segfault issue.
https://github.com/segmentio/fasthash/commit/9dc1b83dc0d8bf7d26ea69d6c6d7a11ebf6fbb89

This is detectable using -race or -gcflags=all=-d=checkptr when running
code that imports this lib.

Co-authored-by: Dean Karn <dean@clearbit.co>
---
 go.mod | 2 +-
 go.sum | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index c3e3799..42051cd 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.18
 
 require (
 	github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072
-	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
+	github.com/segmentio/fasthash v1.0.3
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
 	github.com/stretchr/testify v1.8.4
diff --git a/go.sum b/go.sum
index 510a838..6246565 100644
--- a/go.sum
+++ b/go.sum
@@ -17,6 +17,8 @@ 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/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e h1:uO75wNGioszjmIzcY/tvdDYKRLVvzggtAmmJkn9j4GQ=
 github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e/go.mod h1:tm/wZFQ8e24NYaBGIlnO2WGCAi67re4HHuOm0sftE/M=
+github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM=
+github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
 github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RXOM=
 github.com/segmentio/objconv v1.0.1/go.mod h1:auayaH5k3137Cl4SoXTgrzQcuQDmvuVtZgS0fb1Ahys=
 github.com/segmentio/vpcinfo v0.1.10 h1:iCfT3tS4h2M7WLWmzFGKysZh0ql0B8XdiHYqiPN4ke4=

From ee9829395d97269b95e6578472a99e3a147ec502 Mon Sep 17 00:00:00 2001
From: David Betts <wdbetts@gmail.com>
Date: Thu, 28 Sep 2023 09:47:23 -0600
Subject: [PATCH 53/63] Remove CircleCI pipeline yaml (#140)

---
 .circleci/config.yml | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 .circleci/config.yml

diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index abc23d8..0000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-version: 2
-jobs:
-  build:
-    working_directory: /go/src/github.com/segmentio/stats
-    docker:
-      - image: circleci/golang
-      - image: influxdb:1.8.9-alpine
-        ports: ['8086:8086']
-    steps:
-      - checkout
-      - setup_remote_docker: { reusable: true, docker_layer_caching: true }
-      - run: go get -v -t ./...
-      - run: go vet ./...
-      - run: go test -v -race ./...

From 3a6125270d918bac54da1f6099e15a78c69a3e00 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Wed, 6 Dec 2023 10:37:40 -0800
Subject: [PATCH 54/63] tag: fix build

On tip (the Go 1.22 code freeze), Go reports that `compareTag` has the
wrong method signature:

```
type func(a Tag, b Tag) int of tagCompare does not match inferred type func(a Tag, b Tag) bool for func(a E, b E) bool
```

Fix this by using the correct method signature.
---
 go.mod      | 2 +-
 go.sum      | 6 ++----
 tag.go      | 9 ++++-----
 tag_test.go | 2 +-
 4 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/go.mod b/go.mod
index 42051cd..7627566 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
 	github.com/stretchr/testify v1.8.4
-	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
+	golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb
 	golang.org/x/sync v0.3.0
 )
 
diff --git a/go.sum b/go.sum
index 6246565..b0ff1c1 100644
--- a/go.sum
+++ b/go.sum
@@ -15,8 +15,6 @@ github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4Z
 github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA=
 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/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e h1:uO75wNGioszjmIzcY/tvdDYKRLVvzggtAmmJkn9j4GQ=
-github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e/go.mod h1:tm/wZFQ8e24NYaBGIlnO2WGCAi67re4HHuOm0sftE/M=
 github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM=
 github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
 github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RXOM=
@@ -26,8 +24,8 @@ github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp9
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb h1:c0vyKkb6yr3KR7jEfJaOSv4lG7xPkbN6r52aJz1d8a8=
+golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
diff --git a/tag.go b/tag.go
index 645f47a..58921be 100644
--- a/tag.go
+++ b/tag.go
@@ -51,14 +51,13 @@ func SortTags(tags []Tag) []Tag {
 	return deduplicateTags(tags)
 }
 
+// reports whether a is less than b
 func tagCompare(a, b Tag) int {
-	switch {
-	case a.Name < b.Name:
+	if a.Name < b.Name {
 		return -1
-	case a.Name > b.Name:
-		return +1
+	} else if b.Name < a.Name {
+		return 1
 	}
-
 	return 0
 }
 
diff --git a/tag_test.go b/tag_test.go
index e06154b..2eb5707 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -190,7 +190,7 @@ func BenchmarkTagsOrder(b *testing.B) {
 
 func tagIsLessByIndex(tags []Tag) func(int, int) bool {
 	return func(i, j int) bool {
-		return tagCompare(tags[i], tags[j]) < 0
+		return tagCompare(tags[i], tags[j]) == -1
 	}
 }
 

From b577f9f02590047d59738eddfee850e2201117cf Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Wed, 6 Dec 2023 17:36:22 -0800
Subject: [PATCH 55/63] procstats/linux: skip tests if /sys not available

---
 procstats/linux/cgroup_linux_test.go | 16 ++++++++++++++++
 procstats/linux/io.go                |  4 ++--
 procstats/linux/memory_linux.go      |  4 ++--
 procstats/linux/memory_linux_test.go |  3 +++
 4 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/procstats/linux/cgroup_linux_test.go b/procstats/linux/cgroup_linux_test.go
index 5395b3a..2a7eccc 100644
--- a/procstats/linux/cgroup_linux_test.go
+++ b/procstats/linux/cgroup_linux_test.go
@@ -7,6 +7,7 @@
 package linux
 
 import (
+	"os"
 	"reflect"
 	"testing"
 )
@@ -51,6 +52,12 @@ func TestParseProcCGroup(t *testing.T) {
 	}
 }
 
+func sysGone(t *testing.T) bool {
+	t.Helper()
+	_, err := os.Stat("/sys/fs/cgroup/cpu/cpu.cfs_period_us")
+	return os.IsNotExist(err)
+}
+
 func TestProcCGroupLookup(t *testing.T) {
 	tests := []struct {
 		proc   ProcCGroup
@@ -81,6 +88,9 @@ func TestProcCGroupLookup(t *testing.T) {
 }
 
 func TestReadCPUPeriod(t *testing.T) {
+	if sysGone(t) {
+		t.Skip("/sys files not available on this filesystem; skipping test")
+	}
 	period, err := ReadCPUPeriod("")
 	if err != nil {
 		t.Fatal(err)
@@ -91,6 +101,9 @@ func TestReadCPUPeriod(t *testing.T) {
 }
 
 func TestReadCPUQuota(t *testing.T) {
+	if sysGone(t) {
+		t.Skip("/sys files not available on this filesystem; skipping test")
+	}
 	quota, err := ReadCPUQuota("")
 	if err != nil {
 		t.Fatal(err)
@@ -101,6 +114,9 @@ func TestReadCPUQuota(t *testing.T) {
 }
 
 func TestReadCPUShares(t *testing.T) {
+	if sysGone(t) {
+		t.Skip("/sys files not available on this filesystem; skipping test")
+	}
 	shares, err := ReadCPUShares("")
 	if err != nil {
 		t.Fatal(err)
diff --git a/procstats/linux/io.go b/procstats/linux/io.go
index dcdc417..ba93413 100644
--- a/procstats/linux/io.go
+++ b/procstats/linux/io.go
@@ -2,7 +2,7 @@ package linux
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -10,7 +10,7 @@ import (
 )
 
 func readFile(path string) string {
-	b, err := ioutil.ReadFile(path)
+	b, err := os.ReadFile(path)
 	check(err)
 	return string(b)
 }
diff --git a/procstats/linux/memory_linux.go b/procstats/linux/memory_linux.go
index 3ea460a..fbd10d2 100644
--- a/procstats/linux/memory_linux.go
+++ b/procstats/linux/memory_linux.go
@@ -1,7 +1,7 @@
 package linux
 
 import (
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -32,7 +32,7 @@ func readProcCGroupMemoryLimit(cgroups ProcCGroup) (limit uint64) {
 func readMemoryCGroupMemoryLimit(cgroup CGroup) (limit uint64) {
 	limit = unlimitedMemoryLimit // default value if something doesn't work
 
-	if b, err := ioutil.ReadFile(readMemoryCGroupMemoryLimitFilePath(cgroup.Path)); err == nil {
+	if b, err := os.ReadFile(readMemoryCGroupMemoryLimitFilePath(cgroup.Path)); err == nil {
 		if v, err := strconv.ParseUint(strings.TrimSpace(string(b)), 10, 64); err == nil {
 			limit = v
 		}
diff --git a/procstats/linux/memory_linux_test.go b/procstats/linux/memory_linux_test.go
index 47c0b88..a9ae64e 100644
--- a/procstats/linux/memory_linux_test.go
+++ b/procstats/linux/memory_linux_test.go
@@ -12,6 +12,9 @@ import (
 )
 
 func TestReadMemoryLimit(t *testing.T) {
+	if sysGone(t) {
+		t.Skip("/sys files not available on this filesystem; skipping test")
+	}
 	if limit, err := ReadMemoryLimit(os.Getpid()); err != nil {
 		t.Error(err)
 

From 58d0f833703f2717c86fc244c586160796712beb Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Tue, 18 Jun 2024 22:24:16 -0700
Subject: [PATCH 56/63] .github: update CI runner

Builds are currently failing because something is running Node 16
which is no longer supported.
---
 .github/workflows/go.yml            | 4 ++--
 .github/workflows/golangci-lint.yml | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 52028b8..72fa1f5 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -17,10 +17,10 @@ jobs:
     runs-on: ${{ matrix.label }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Go (${{ matrix.go }})
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go }}
 
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 03b8472..f2d3228 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -16,13 +16,13 @@ jobs:
     runs-on: ubuntu-latest
     continue-on-error: true
     steps:
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
         with:
           go-version: '>=1.20'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3.1.0
+        uses: golangci/golangci-lint-action@v6.0.1
         with:
-          version: v1.53
+          version: v1.59.1

From a16086ec5789f2719d8bbef2e380bfcdf0447f99 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Tue, 18 Jun 2024 19:57:21 -0700
Subject: [PATCH 57/63] procstats: fix tests on Macs

Previously they would fail with an anticipated error; instead, skip
the failing test on Darwin.
---
 procstats/proc.go        | 10 +++++++++-
 procstats/proc_darwin.go |  3 +--
 procstats/proc_test.go   | 28 +++++++++++++++++++++++-----
 3 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/procstats/proc.go b/procstats/proc.go
index 752adaa..70bfc3c 100644
--- a/procstats/proc.go
+++ b/procstats/proc.go
@@ -187,11 +187,19 @@ type ProcInfo struct {
 	Threads ThreadInfo
 }
 
-// CollectProcInfo return a ProcInfo and error (if any) for a given PID.
+// CollectProcInfo returns a ProcInfo and error (if any) for a given PID.
 func CollectProcInfo(pid int) (ProcInfo, error) {
 	return collectProcInfo(pid)
 }
 
+type OSUnsupportedError struct {
+	Msg string
+}
+
+func (o *OSUnsupportedError) Error() string {
+	return o.Msg
+}
+
 // CPUInfo holds statistics and configuration details for a process.
 type CPUInfo struct {
 	User time.Duration // user cpu time used by the process
diff --git a/procstats/proc_darwin.go b/procstats/proc_darwin.go
index cac113a..6631c0e 100644
--- a/procstats/proc_darwin.go
+++ b/procstats/proc_darwin.go
@@ -23,7 +23,6 @@ static mach_port_t mach_task_self() { return mach_task_self_; }
 import "C"
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"syscall"
@@ -35,7 +34,7 @@ func collectProcInfo(pid int) (info ProcInfo, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 
 	if pid != os.Getpid() {
-		panic(errors.New("on darwin systems only metrics of the current process can be collected"))
+		panic(&OSUnsupportedError{Msg: "on darwin systems only metrics of the current process can be collected"})
 	}
 
 	self := C.mach_port_name_t(C.mach_task_self())
diff --git a/procstats/proc_test.go b/procstats/proc_test.go
index b415661..bdf3c86 100644
--- a/procstats/proc_test.go
+++ b/procstats/proc_test.go
@@ -1,9 +1,11 @@
 package procstats
 
 import (
-	"io/ioutil"
+	"errors"
+	"io"
 	"os"
 	"os/exec"
+	"runtime"
 	"testing"
 	"time"
 
@@ -18,23 +20,39 @@ func TestProcMetrics(t *testing.T) {
 	t.Run("child", func(t *testing.T) {
 		cmd := exec.Command("yes")
 		cmd.Stdin = os.Stdin
-		cmd.Stdout = ioutil.Discard
-		cmd.Stderr = ioutil.Discard
+		cmd.Stdout = io.Discard
+		cmd.Stderr = io.Discard
 
-		cmd.Start()
+		if err := cmd.Start(); err != nil {
+			t.Fatal(err)
+		}
 		time.Sleep(200 * time.Millisecond)
 		testProcMetrics(t, cmd.Process.Pid)
 		cmd.Process.Signal(os.Interrupt)
-		cmd.Wait()
+		waitErr := cmd.Wait()
+		if exitErr, ok := waitErr.(*exec.ExitError); ok && exitErr.Error() == "signal: interrupt" {
+			// This is expected from stopping the process
+		} else {
+			t.Fatal(waitErr)
+		}
 	})
 }
 
 func testProcMetrics(t *testing.T, pid int) {
+	t.Helper()
 	h := &statstest.Handler{}
 	e := stats.NewEngine("", h)
 
 	proc := NewProcMetricsWith(e, pid)
 
+	// for darwin - catch the "can't collect child metrics" error before
+	// starting the test
+	_, err := CollectProcInfo(proc.pid)
+	var o *OSUnsupportedError
+	if errors.As(err, &o) {
+		t.Skipf("can't run test because current OS is unsupported: %v", runtime.GOOS)
+	}
+
 	for i := 0; i != 10; i++ {
 		t.Logf("collect number %d", i)
 		proc.Collect()

From 3bdf434c9409fa9f7d43199a63ab9016619f10f4 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Tue, 18 Jun 2024 22:07:55 -0700
Subject: [PATCH 58/63] datadog: fix race in test

While the metrics are set in the correct order, the use of a HTTP
server to receive them means that the metrics can be received on the
server side in any order, which fails the tests 1 time out of 200,
potentially higher.

This means we can't rely on any ordering on the server side in the
test, and need to manually sort events.
---
 datadog/server_test.go | 44 +++++++++++++++++++++++++++++++++---------
 1 file changed, 35 insertions(+), 9 deletions(-)

diff --git a/datadog/server_test.go b/datadog/server_test.go
index 0364ef2..5346a09 100644
--- a/datadog/server_test.go
+++ b/datadog/server_test.go
@@ -6,6 +6,8 @@ import (
 	"net"
 	"os"
 	"path/filepath"
+	"sort"
+	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -17,16 +19,28 @@ func TestServer(t *testing.T) {
 	engine := stats.NewEngine("datadog.test", nil)
 
 	a := uint32(0)
-	b := uint32(0)
 	c := uint32(0)
 
-	addr, closer := startUDPTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
+	seenGauges := make([]Metric, 0)
+	var mu sync.Mutex
+
+	addr, closer := startTestServer(t, HandlerFunc(func(m Metric, _ net.Addr) {
 		switch m.Name {
 		case "datadog.test.A":
 			atomic.AddUint32(&a, uint32(m.Value))
 
 		case "datadog.test.B":
-			atomic.StoreUint32(&b, uint32(m.Value)) // gauge
+			// Because it's the other side of a HTTP server, these can arrive
+			// out of order, even if the client sends them in the right order
+			// - there aren't any guarantees about which connection the server
+			// will activate first.
+			//
+			// Previously this used atomic.StoreInt32 to do last write wins, but
+			// occasionally the last write would be "2" or "1" and fail the
+			// test, easily reproducible by running this test 200 times.
+			mu.Lock()
+			seenGauges = append(seenGauges, m)
+			mu.Unlock()
 
 		case "datadog.test.C":
 			atomic.AddUint32(&c, uint32(m.Value))
@@ -45,25 +59,37 @@ func TestServer(t *testing.T) {
 	engine.Incr("A")
 	engine.Incr("A")
 
-	engine.Set("B", 1)
-	engine.Set("B", 2)
-	engine.Set("B", 3)
+	now := time.Now()
+	engine.Set("B", float64(time.Since(now)))
+	engine.Set("B", float64(time.Since(now)))
+	last := float64(time.Since(now))
+	engine.Set("B", last)
 
 	engine.Observe("C", 1)
 	engine.Observe("C", 2)
 	engine.Observe("C", 3)
 
+	// because this is "last write wins" it's possible it runs before the reads
+	// of 1 or 2; add a sleep to try to ensure it loses the race
 	engine.Flush()
 
 	// Give time for the server to receive the metrics.
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(20 * time.Millisecond)
 
 	if n := atomic.LoadUint32(&a); n != 3 { // two increments (+1, +1, +1)
 		t.Error("datadog.test.A: bad value:", n)
 	}
 
-	if n := atomic.LoadUint32(&b); n != 3 { // three assignments (=1, =2, =3)
-		t.Error("datadog.test.B: bad value:", n)
+	mu.Lock()
+	defer mu.Unlock()
+	if len(seenGauges) != 3 {
+		t.Errorf("datadog.test.B: expected 3 values, got %d", len(seenGauges))
+	}
+	sort.Slice(seenGauges, func(i, j int) bool {
+		return seenGauges[i].Value < seenGauges[j].Value
+	})
+	if seenGauges[2].Value != last {
+		t.Errorf("expected highest value to be the latest value set, got %v", seenGauges[2])
 	}
 
 	if n := atomic.LoadUint32(&c); n != 6 { // observed values, all reported (+1, +2, +3)

From b1c68251742898f88cd34c99330611b15b94b98f Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Thu, 20 Jun 2024 20:46:02 -0700
Subject: [PATCH 59/63] .github: ensure golangci-lint runs on PR's as well

Currently it just fails the main branch because it's not a requirement
of a passing build.
---
 .github/workflows/golangci-lint.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index f2d3228..14d8ffe 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -9,6 +9,10 @@ name: golangci-lint
       - '**.go'
       - .golangci.yml
       - .github/workflows/golangci-lint.yml
+  pull_request:
+    branches:
+      - main
+
 
 jobs:
   lint:

From 8c593af7fe0ffd6790df5fd1c046e1f56832bbfa Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Thu, 20 Jun 2024 21:44:11 -0700
Subject: [PATCH 60/63] all: fix lint issues

We turned on the linter to lint the "main" branch and any release
branches, but we never actually fixed any of the issues reported by
the linter. This is an attempt to do so. A lot of red herrings but
some legitimate errors.

Not strictly reported by the linter, but replace "syscall" uses with
"x/sys/unix", as is recommended.
---
 .golangci.yml                   |  6 +++---
 buffer.go                       |  2 +-
 cmd/dogstatsd/main.go           | 14 +++++---------
 context_test.go                 |  3 ++-
 datadog/append_test.go          |  2 +-
 datadog/client.go               |  3 ++-
 datadog/client_test.go          | 26 ++++++++++++++++++--------
 datadog/event.go                |  2 +-
 datadog/metric.go               |  2 +-
 datadog/server.go               |  4 +---
 engine_test.go                  |  5 +++++
 field_test.go                   |  8 ++++----
 go.mod                          |  2 +-
 grafana/annotations.go          |  2 +-
 grafana/annotations_test.go     |  6 +++---
 grafana/handler.go              |  2 +-
 grafana/query.go                |  4 ++--
 grafana/query_test.go           |  2 +-
 grafana/search.go               |  4 ++--
 grafana/search_test.go          |  6 +++---
 handler.go                      |  2 +-
 handler_test.go                 |  2 +-
 httpstats/context_test.go       |  3 ++-
 httpstats/handler_test.go       |  2 +-
 httpstats/metrics.go            |  4 ++--
 httpstats/transport_test.go     |  2 +-
 influxdb/client.go              |  3 +--
 netstats/handler_test.go        |  2 +-
 procstats/delaystats_linux.go   |  6 +++---
 procstats/linux/memory_linux.go |  9 +++++----
 procstats/linux/stat.go         |  7 ++++---
 procstats/proc.go               |  2 +-
 procstats/proc_darwin.go        | 11 ++++++-----
 procstats/proc_linux.go         | 17 ++++++++++-------
 procstats/proc_test.go          |  1 +
 prometheus/handler.go           |  2 +-
 prometheus/label.go             |  7 -------
 reflect.go                      |  4 ----
 statstest/handler.go            |  2 +-
 tag.go                          |  2 +-
 tag_test.go                     | 24 ++++++++++++------------
 41 files changed, 113 insertions(+), 106 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index 43bbd03..1123bf4 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,8 +1,5 @@
 run:
   deadline: 5m
-  skip-files:
-    # Skip autogenerated files.
-    - ^.*\.(pb|y)\.go$
 
 output:
   sort-results: true
@@ -20,6 +17,9 @@ linters:
     - misspell
 
 issues:
+  exclude-files:
+    # Skip autogenerated files.
+    - ^.*\.(pb|y)\.go$
   exclude-rules:
     - path: _test.go
       linters:
diff --git a/buffer.go b/buffer.go
index 378fb5e..97c9e67 100644
--- a/buffer.go
+++ b/buffer.go
@@ -156,7 +156,7 @@ func (b *buffer) len() int {
 }
 
 func (b *buffer) flush(w io.Writer, n int) {
-	w.Write(b.data[:n])
+	_, _ = w.Write(b.data[:n])
 	n = copy(b.data, b.data[n:])
 	b.data = b.data[:n]
 }
diff --git a/cmd/dogstatsd/main.go b/cmd/dogstatsd/main.go
index e8946df..a4ce285 100644
--- a/cmd/dogstatsd/main.go
+++ b/cmd/dogstatsd/main.go
@@ -59,7 +59,7 @@ func client(cmd string, args ...string) {
 	args, extra = split(args, "--")
 	fset.StringVar(&addr, "addr", "localhost:8125", "The network address where a dogstatsd server is listening for incoming UDP datagrams")
 	fset.Var(&tags, "tags", "A comma-separated list of tags to set on the metric")
-	fset.Parse(args)
+	_ = fset.Parse(args)
 	args = fset.Args()
 
 	if len(args) == 0 {
@@ -74,8 +74,6 @@ func client(cmd string, args ...string) {
 			value = 1.0
 		} else if value, err = strconv.ParseFloat(args[0], 64); err != nil {
 			errorf("bad metric value: %s", args[0])
-		} else {
-			args = args[1:]
 		}
 
 	case "set":
@@ -83,8 +81,6 @@ func client(cmd string, args ...string) {
 			errorf("missing metric value")
 		} else if value, err = strconv.ParseFloat(args[0], 64); err != nil {
 			errorf("bad metric value: %s", args[0])
-		} else {
-			args = args[1:]
 		}
 	}
 
@@ -110,19 +106,19 @@ func server(args ...string) {
 	var bind string
 
 	fset.StringVar(&bind, "bind", ":8125", "The network address to listen on for incoming UDP datagrams")
-	fset.Parse(args)
+	_ = fset.Parse(args)
 	log.Printf("listening for incoming UDP datagram on %s", bind)
 
-	datadog.ListenAndServe(bind, handlers{})
+	_ = datadog.ListenAndServe(bind, handlers{})
 }
 
 type handlers struct{}
 
-func (h handlers) HandleMetric(m datadog.Metric, a net.Addr) {
+func (h handlers) HandleMetric(m datadog.Metric, _ net.Addr) {
 	log.Print(m)
 }
 
-func (h handlers) HandleEvent(e datadog.Event, a net.Addr) {
+func (h handlers) HandleEvent(e datadog.Event, _ net.Addr) {
 	log.Print(e)
 }
 
diff --git a/context_test.go b/context_test.go
index c2c6993..22a326d 100644
--- a/context_test.go
+++ b/context_test.go
@@ -17,7 +17,8 @@ func TestContextTags(t *testing.T) {
 	assert.Equal(t, 0, len(ContextTags(x)), "Original context should have no tags (because no context with key)")
 
 	// create a child context which creates a child context
-	z := context.WithValue(y, interface{}("not"), "important")
+	type unimportant struct{}
+	z := context.WithValue(y, unimportant{}, "important")
 	assert.Equal(t, 1, len(ContextTags(z)), "We should still be able to see original tags")
 
 	// Add tags to the child context's reference to the original tag slice
diff --git a/datadog/append_test.go b/datadog/append_test.go
index ff07ae2..8f6fe57 100644
--- a/datadog/append_test.go
+++ b/datadog/append_test.go
@@ -4,7 +4,7 @@ import "testing"
 
 func TestAppendMetric(t *testing.T) {
 	for _, test := range testMetrics {
-		t.Run(test.m.Name, func(b *testing.T) {
+		t.Run(test.m.Name, func(t *testing.T) {
 			if s := string(appendMetric(nil, test.m)); s != test.s {
 				t.Errorf("\n<<< %#v\n>>> %#v", test.s, s)
 			}
diff --git a/datadog/client.go b/datadog/client.go
index b0eceb0..867c4ee 100644
--- a/datadog/client.go
+++ b/datadog/client.go
@@ -160,6 +160,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	// to accept larger datagrams, or fallback to the default socket buffer size
 	// if it failed.
 	if bufsize, err = unix.GetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_SNDBUF); err != nil {
+		f.Close()
 		return
 	}
 
@@ -194,7 +195,7 @@ func bufSizeFromFD(f *os.File, sizehint int) (bufsize int, err error) {
 	}
 
 	// Creating the file put the socket in blocking mode, reverting.
-	unix.SetNonblock(fd, true)
+	_ = unix.SetNonblock(fd, true)
 	return
 }
 
diff --git a/datadog/client_test.go b/datadog/client_test.go
index fb4cfa2..2afe2e6 100644
--- a/datadog/client_test.go
+++ b/datadog/client_test.go
@@ -1,9 +1,9 @@
 package datadog
 
 import (
+	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"net"
 	"strings"
@@ -11,9 +11,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/segmentio/stats/v4"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestClient_UDP(t *testing.T) {
@@ -90,7 +90,7 @@ func TestClientWriteLargeMetrics_UDP(t *testing.T) {
 		UseDistributions: true,
 	})
 
-	testMeassure := stats.Measure{
+	testMeasure := stats.Measure{
 		Name: "request",
 		Fields: []stats.Field{
 			{Name: "count", Value: stats.ValueOf(5)},
@@ -101,14 +101,14 @@ func TestClientWriteLargeMetrics_UDP(t *testing.T) {
 			stats.T("hello", "world"),
 		},
 	}
-	client.HandleMeasures(time.Time{}, testMeassure)
+	client.HandleMeasures(time.Time{}, testMeasure)
 	client.Flush()
 
 	expectedPacket1 := "request.count:5|c|#answer:42,hello:world\nrequest.dist_rtt:0.1|d|#answer:42,hello:world\n"
 	assert.EqualValues(t, expectedPacket1, string(<-packets))
 
 	client.useDistributions = false
-	client.HandleMeasures(time.Time{}, testMeassure)
+	client.HandleMeasures(time.Time{}, testMeasure)
 	client.Flush()
 
 	expectedPacket2 := "request.count:5|c|#answer:42,hello:world\nrequest.dist_rtt:0.1|h|#answer:42,hello:world\n"
@@ -188,7 +188,7 @@ main.http.rtt.seconds:0.001215296|h|#http_req_content_charset:,http_req_content_
 }
 
 func BenchmarkClient(b *testing.B) {
-	log.SetOutput(ioutil.Discard)
+	log.SetOutput(io.Discard)
 
 	for _, N := range []int{1, 10, 100} {
 		b.Run(fmt.Sprintf("write a batch of %d measures to a client", N), func(b *testing.B) {
@@ -221,6 +221,14 @@ func BenchmarkClient(b *testing.B) {
 	}
 }
 
+func isClosedNetworkConnectionErr(err error) bool {
+	var netErr *net.OpError
+	if errors.As(err, &netErr) {
+		return strings.Contains(netErr.Err.Error(), "use of closed network connection")
+	}
+	return false
+}
+
 // startUDPListener starts a goroutine listening for UDP packets on 127.0.0.1 and an available port.
 // The address listened to is returned as `addr`. The payloads of packets received are copied to `packets`.
 func startUDPListener(t *testing.T, packets chan []byte) (addr string, closer io.Closer) {
@@ -238,7 +246,9 @@ func startUDPListener(t *testing.T, packets chan []byte) (addr string, closer io
 			}
 
 			if err != nil {
-				t.Log(err)
+				if !isClosedNetworkConnectionErr(err) {
+					fmt.Println("err reading from UDP connection in goroutine:", err)
+				}
 				return
 			}
 		}
diff --git a/datadog/event.go b/datadog/event.go
index e9992eb..5f55046 100644
--- a/datadog/event.go
+++ b/datadog/event.go
@@ -51,6 +51,6 @@ func (e Event) String() string {
 func (e Event) Format(f fmt.State, _ rune) {
 	buf := bufferPool.Get().(*buffer)
 	buf.b = appendEvent(buf.b[:0], e)
-	f.Write(buf.b)
+	_, _ = f.Write(buf.b)
 	bufferPool.Put(buf)
 }
diff --git a/datadog/metric.go b/datadog/metric.go
index a6bcc06..69c0abd 100644
--- a/datadog/metric.go
+++ b/datadog/metric.go
@@ -39,7 +39,7 @@ func (m Metric) String() string {
 func (m Metric) Format(f fmt.State, _ rune) {
 	buf := bufferPool.Get().(*buffer)
 	buf.b = appendMetric(buf.b[:0], m)
-	f.Write(buf.b)
+	_, _ = f.Write(buf.b)
 	bufferPool.Put(buf)
 }
 
diff --git a/datadog/server.go b/datadog/server.go
index f876f86..8be04fd 100644
--- a/datadog/server.go
+++ b/datadog/server.go
@@ -33,9 +33,7 @@ func (f HandlerFunc) HandleMetric(m Metric, a net.Addr) {
 }
 
 // HandleEvent is a no-op for backwards compatibility.
-func (f HandlerFunc) HandleEvent(Event, net.Addr) {
-	return
-}
+func (f HandlerFunc) HandleEvent(Event, net.Addr) {}
 
 // ListenAndServe starts a new dogstatsd server, listening for UDP datagrams on
 // addr and forwarding the metrics to handler.
diff --git a/engine_test.go b/engine_test.go
index 655edd7..31aaa09 100644
--- a/engine_test.go
+++ b/engine_test.go
@@ -64,6 +64,10 @@ func TestEngine(t *testing.T) {
 			scenario: "calling Engine.Clock produces expected metrics",
 			function: testEngineClock,
 		},
+		{
+			scenario: "calling Engine.WithTags produces expected tags",
+			function: testEngineWithTags,
+		},
 	}
 
 	for _, test := range tests {
@@ -307,6 +311,7 @@ func checkMeasuresEqual(t *testing.T, eng *stats.Engine, expected ...stats.Measu
 }
 
 func measures(t *testing.T, eng *stats.Engine) []stats.Measure {
+	t.Helper()
 	return eng.Handler.(*statstest.Handler).Measures()
 }
 
diff --git a/field_test.go b/field_test.go
index 2dea0d2..1a395e3 100644
--- a/field_test.go
+++ b/field_test.go
@@ -17,10 +17,10 @@ func BenchmarkAssign40BytesStruct(b *testing.B) {
 		c int
 	}
 
-	s := S{}
+	var s S
 
 	for i := 0; i != b.N; i++ {
-		s = S{a: "hello"}
+		s = S{a: "hello", b: "", c: 0}
 		_ = s
 	}
 }
@@ -31,10 +31,10 @@ func BenchmarkAssign32BytesStruct(b *testing.B) {
 		b string
 	}
 
-	s := S{}
+	var s S
 
 	for i := 0; i != b.N; i++ {
-		s = S{a: "hello"}
+		s = S{a: "hello", b: ""}
 		_ = s
 	}
 }
diff --git a/go.mod b/go.mod
index 7627566..699f557 100644
--- a/go.mod
+++ b/go.mod
@@ -10,6 +10,7 @@ require (
 	github.com/stretchr/testify v1.8.4
 	golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb
 	golang.org/x/sync v0.3.0
+	golang.org/x/sys v0.12.0
 )
 
 require github.com/davecgh/go-spew v1.1.1 // indirect
@@ -20,7 +21,6 @@ require (
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/sys v0.12.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/grafana/annotations.go b/grafana/annotations.go
index b128ed0..8591c1c 100644
--- a/grafana/annotations.go
+++ b/grafana/annotations.go
@@ -117,7 +117,7 @@ type annotationsResponse struct {
 }
 
 func (res *annotationsResponse) WriteAnnotation(a Annotation) {
-	res.enc.Encode(annotationInfo{
+	_ = res.enc.Encode(annotationInfo{
 		Annotation: annotation{
 			Name:       res.name,
 			Datasource: res.datasource,
diff --git a/grafana/annotations_test.go b/grafana/annotations_test.go
index 968105a..2de0439 100644
--- a/grafana/annotations_test.go
+++ b/grafana/annotations_test.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -28,7 +28,7 @@ func TestAnnotationsHandler(t *testing.T) {
 
 	client := http.Client{}
 	server := httptest.NewServer(NewAnnotationsHandler(
-		AnnotationsHandlerFunc(func(ctx context.Context, res AnnotationsResponse, req *AnnotationsRequest) error {
+		AnnotationsHandlerFunc(func(_ context.Context, res AnnotationsResponse, req *AnnotationsRequest) error {
 			if !req.From.Equal(ar.Range.From) {
 				t.Error("bad 'from' time:", req.From, ar.Range.From)
 			}
@@ -79,7 +79,7 @@ func TestAnnotationsHandler(t *testing.T) {
 	}
 	defer r.Body.Close()
 
-	found, _ := ioutil.ReadAll(r.Body)
+	found, _ := io.ReadAll(r.Body)
 	expect := annotationsResult
 
 	if s := string(found); s != expect {
diff --git a/grafana/handler.go b/grafana/handler.go
index c7866eb..cb76704 100644
--- a/grafana/handler.go
+++ b/grafana/handler.go
@@ -47,7 +47,7 @@ func Handle(mux *http.ServeMux, prefix string, handler Handler) {
 	if _, pattern := mux.Handler(&http.Request{
 		URL: &url.URL{Path: root},
 	}); len(pattern) == 0 {
-		mux.HandleFunc(root, func(res http.ResponseWriter, req *http.Request) {
+		mux.HandleFunc(root, func(res http.ResponseWriter, _ *http.Request) {
 			setResponseHeaders(res)
 		})
 	}
diff --git a/grafana/query.go b/grafana/query.go
index 67275ed..bd0e3b3 100644
--- a/grafana/query.go
+++ b/grafana/query.go
@@ -191,13 +191,13 @@ func (res *queryResponse) close() error {
 
 func (res *queryResponse) flush() {
 	if res.timeserie != nil {
-		res.enc.Encode(res.timeserie)
+		_ = res.enc.Encode(res.timeserie)
 		res.timeserie.closed = true
 		res.timeserie = nil
 	}
 
 	if res.table != nil {
-		res.enc.Encode(res.table)
+		_ = res.enc.Encode(res.table)
 		res.table.closed = true
 		res.table = nil
 	}
diff --git a/grafana/query_test.go b/grafana/query_test.go
index 015ad4a..c06fc21 100644
--- a/grafana/query_test.go
+++ b/grafana/query_test.go
@@ -32,7 +32,7 @@ func TestQueryHandler(t *testing.T) {
 
 	client := http.Client{}
 	server := httptest.NewServer(NewQueryHandler(
-		QueryHandlerFunc(func(ctx context.Context, res QueryResponse, req *QueryRequest) error {
+		QueryHandlerFunc(func(_ context.Context, res QueryResponse, req *QueryRequest) error {
 			if !req.From.Equal(t0) {
 				t.Error("bad 'from' time:", req.From, "!=", t0)
 			}
diff --git a/grafana/search.go b/grafana/search.go
index 31ca4ce..0a5c0d8 100644
--- a/grafana/search.go
+++ b/grafana/search.go
@@ -81,11 +81,11 @@ type searchResponse struct {
 }
 
 func (res *searchResponse) WriteTarget(target string) {
-	res.enc.Encode(target)
+	_ = res.enc.Encode(target)
 }
 
 func (res *searchResponse) WriteTargetValue(target string, value interface{}) {
-	res.enc.Encode(struct {
+	_ = res.enc.Encode(struct {
 		Target string      `json:"target"`
 		Value  interface{} `json:"value"`
 	}{target, value})
diff --git a/grafana/search_test.go b/grafana/search_test.go
index 9a9fe4e..1467592 100644
--- a/grafana/search_test.go
+++ b/grafana/search_test.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -19,7 +19,7 @@ func TestSearchHandler(t *testing.T) {
 
 	client := http.Client{}
 	server := httptest.NewServer(NewSearchHandler(
-		SearchHandlerFunc(func(ctx context.Context, res SearchResponse, req *SearchRequest) error {
+		SearchHandlerFunc(func(_ context.Context, res SearchResponse, req *SearchRequest) error {
 			if req.Target != sr.Target {
 				t.Error("bad 'from' time:", req.Target, "!=", sr.Target)
 			}
@@ -44,7 +44,7 @@ func TestSearchHandler(t *testing.T) {
 	}
 	defer r.Body.Close()
 
-	found, _ := ioutil.ReadAll(r.Body)
+	found, _ := io.ReadAll(r.Body)
 	expect := searchResult
 
 	if s := string(found); s != expect {
diff --git a/handler.go b/handler.go
index caa76a4..501536a 100644
--- a/handler.go
+++ b/handler.go
@@ -97,4 +97,4 @@ var Discard = &discard{}
 
 type discard struct{}
 
-func (*discard) HandleMeasures(time time.Time, measures ...Measure) {}
+func (*discard) HandleMeasures(time.Time, ...Measure) {}
diff --git a/handler_test.go b/handler_test.go
index 5418edf..58d1f81 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -13,7 +13,7 @@ import (
 func TestMultiHandler(t *testing.T) {
 	t.Run("calling HandleMeasures on a multi-handler dispatches to each handler", func(t *testing.T) {
 		n := 0
-		f := stats.HandlerFunc(func(time time.Time, measures ...stats.Measure) { n++ })
+		f := stats.HandlerFunc(func(time.Time, ...stats.Measure) { n++ })
 		m := stats.MultiHandler(f, f, f)
 
 		m.HandleMeasures(time.Now())
diff --git a/httpstats/context_test.go b/httpstats/context_test.go
index cef18a8..f3ad93c 100644
--- a/httpstats/context_test.go
+++ b/httpstats/context_test.go
@@ -27,7 +27,8 @@ func TestRequestContextTagPropegation(t *testing.T) {
 	assert.Equal(t, 0, len(RequestTags(x)), "Original request should have no tags (because no context with key)")
 
 	// create a child request which creates a child context
-	z := y.WithContext(context.WithValue(y.Context(), interface{}("not"), "important"))
+	type contextVal struct{}
+	z := y.WithContext(context.WithValue(y.Context(), contextVal{}, "important"))
 	assert.Equal(t, 1, len(RequestTags(z)), "We should still be able to see original tags")
 
 	// Add tags to the child context's reference to the original tag slice
diff --git a/httpstats/handler_test.go b/httpstats/handler_test.go
index 2b29463..1c00e7d 100644
--- a/httpstats/handler_test.go
+++ b/httpstats/handler_test.go
@@ -68,7 +68,7 @@ func TestHandlerHijack(t *testing.T) {
 	h := &statstest.Handler{}
 	e := stats.NewEngine("", h)
 
-	server := httptest.NewServer(NewHandlerWith(e, http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+	server := httptest.NewServer(NewHandlerWith(e, http.HandlerFunc(func(res http.ResponseWriter, _ *http.Request) {
 		// make sure the response writer supports hijacking
 		conn, _, _ := res.(http.Hijacker).Hijack()
 		conn.Close()
diff --git a/httpstats/metrics.go b/httpstats/metrics.go
index e38217b..7051125 100644
--- a/httpstats/metrics.go
+++ b/httpstats/metrics.go
@@ -58,14 +58,14 @@ type nullBody struct{}
 
 func (n *nullBody) Close() error { return nil }
 
-func (n *nullBody) Read(b []byte) (int, error) { return 0, io.EOF }
+func (n *nullBody) Read([]byte) (int, error) { return 0, io.EOF }
 
 type requestBody struct {
 	body    io.ReadCloser
 	eng     *stats.Engine
-	req     *http.Request
 	metrics *metrics
 	bytes   int
+	req     *http.Request
 	op      string
 	once    sync.Once
 }
diff --git a/httpstats/transport_test.go b/httpstats/transport_test.go
index 5370b42..c6a26c6 100644
--- a/httpstats/transport_test.go
+++ b/httpstats/transport_test.go
@@ -79,7 +79,7 @@ func TestTransportError(t *testing.T) {
 	h := &statstest.Handler{}
 	e := stats.NewEngine("", h)
 
-	server := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+	server := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, _ *http.Request) {
 		conn, _, _ := res.(http.Hijacker).Hijack()
 		conn.Close()
 	}))
diff --git a/influxdb/client.go b/influxdb/client.go
index f36e07a..9543d75 100644
--- a/influxdb/client.go
+++ b/influxdb/client.go
@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
@@ -215,7 +214,7 @@ func makeURL(address, database string) *url.URL {
 
 func readResponse(r *http.Response) error {
 	if r.StatusCode < 300 {
-		io.Copy(ioutil.Discard, r.Body)
+		_, _ = io.Copy(io.Discard, r.Body)
 		r.Body.Close()
 		return nil
 	}
diff --git a/netstats/handler_test.go b/netstats/handler_test.go
index a62ede5..85a285a 100644
--- a/netstats/handler_test.go
+++ b/netstats/handler_test.go
@@ -10,7 +10,7 @@ type testHandler struct {
 	ok bool
 }
 
-func (h *testHandler) ServeConn(ctx context.Context, conn net.Conn) {
+func (h *testHandler) ServeConn(context.Context, net.Conn) {
 	h.ok = true
 }
 
diff --git a/procstats/delaystats_linux.go b/procstats/delaystats_linux.go
index 495fe4c..26c3a54 100644
--- a/procstats/delaystats_linux.go
+++ b/procstats/delaystats_linux.go
@@ -2,20 +2,20 @@ package procstats
 
 import (
 	"errors"
-	"syscall"
 
 	"github.com/mdlayher/taskstats"
+	"golang.org/x/sys/unix"
 )
 
 func collectDelayInfo(pid int) DelayInfo {
 	client, err := taskstats.New()
-	if err == syscall.ENOENT {
+	if err == unix.ENOENT {
 		err = errors.New("failed to communicate with taskstats Netlink family, ensure this program is not running in a network namespace")
 	}
 	check(err)
 
 	stats, err := client.TGID(pid)
-	if err == syscall.EPERM {
+	if err == unix.EPERM {
 		err = errors.New("failed to open Netlink socket: permission denied, ensure CAP_NET_RAW is enabled for this process, or run it with root privileges")
 	}
 	check(err)
diff --git a/procstats/linux/memory_linux.go b/procstats/linux/memory_linux.go
index fbd10d2..afc126c 100644
--- a/procstats/linux/memory_linux.go
+++ b/procstats/linux/memory_linux.go
@@ -5,7 +5,8 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
 func readMemoryLimit(pid int) (limit uint64, err error) {
@@ -54,10 +55,10 @@ func readMemoryCGroupMemoryLimitFilePath(cgroupPath string) string {
 }
 
 func readSysinfoMemoryLimit() (limit uint64, err error) {
-	var sysinfo syscall.Sysinfo_t
+	var sysinfo unix.Sysinfo_t
 
-	if err = syscall.Sysinfo(&sysinfo); err == nil {
-		// syscall.Sysinfo returns an uint32 on linux/arm, but uint64 otherwise
+	if err = unix.Sysinfo(&sysinfo); err == nil {
+		// unix.Sysinfo returns an uint32 on linux/arm, but uint64 otherwise
 		limit = uint64(sysinfo.Unit) * uint64(sysinfo.Totalram)
 	}
 
diff --git a/procstats/linux/stat.go b/procstats/linux/stat.go
index 5eaa7bc..2c66cc8 100644
--- a/procstats/linux/stat.go
+++ b/procstats/linux/stat.go
@@ -15,9 +15,10 @@ const (
 	TracingStop                     ProcState = 't'
 	Paging                          ProcState = 'P'
 	Dead                            ProcState = 'X'
-	Dead_                           ProcState = 'x'
-	Wakekill                        ProcState = 'W'
-	Parked                          ProcState = 'P'
+	//revive:disable-next-line
+	Dead_    ProcState = 'x'
+	Wakekill ProcState = 'W'
+	Parked   ProcState = 'P'
 )
 
 // Scan updates the ProcState for a process.
diff --git a/procstats/proc.go b/procstats/proc.go
index 70bfc3c..fead836 100644
--- a/procstats/proc.go
+++ b/procstats/proc.go
@@ -134,7 +134,7 @@ func (p *ProcMetrics) Collect() {
 		now := time.Now()
 
 		if !p.lastTime.IsZero() {
-			ratio := 1.0
+			var ratio float64
 			switch {
 			case m.CPU.Period > 0 && m.CPU.Quota > 0:
 				ratio = float64(m.CPU.Quota) / float64(m.CPU.Period)
diff --git a/procstats/proc_darwin.go b/procstats/proc_darwin.go
index 6631c0e..9d00393 100644
--- a/procstats/proc_darwin.go
+++ b/procstats/proc_darwin.go
@@ -25,9 +25,10 @@ import "C"
 import (
 	"fmt"
 	"os"
-	"syscall"
 	"time"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 func collectProcInfo(pid int) (info ProcInfo, err error) {
@@ -41,11 +42,11 @@ func collectProcInfo(pid int) (info ProcInfo, err error) {
 	task := C.mach_port_name_t(0)
 	checkKern(C.task_for_pid(self, C.int(pid), &task))
 
-	rusage := syscall.Rusage{}
-	check(syscall.Getrusage(syscall.RUSAGE_SELF, &rusage))
+	rusage := unix.Rusage{}
+	check(unix.Getrusage(unix.RUSAGE_SELF, &rusage))
 
-	nofile := syscall.Rlimit{}
-	check(syscall.Getrlimit(syscall.RLIMIT_NOFILE, &nofile))
+	nofile := unix.Rlimit{}
+	check(unix.Getrlimit(unix.RLIMIT_NOFILE, &nofile))
 
 	info.CPU.User = time.Duration(rusage.Utime.Nano())
 	info.CPU.Sys = time.Duration(rusage.Stime.Nano())
diff --git a/procstats/proc_linux.go b/procstats/proc_linux.go
index 3675d58..d2a7a9d 100644
--- a/procstats/proc_linux.go
+++ b/procstats/proc_linux.go
@@ -1,16 +1,17 @@
 package procstats
 
 import (
-	"io/ioutil"
+	"io"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/segmentio/stats/v4/procstats/linux"
+
+	"golang.org/x/sys/unix"
 )
 
 var (
@@ -54,15 +55,17 @@ func getconf(name string) (string, error) {
 	}
 
 	w.Close()
-	b, err := ioutil.ReadAll(r)
-	p.Wait()
+	b, err := io.ReadAll(r)
+	if _, err := p.Wait(); err != nil {
+		return "", err
+	}
 	return string(b), err
 }
 
 func collectProcInfo(pid int) (info ProcInfo, err error) {
 	defer func() { err = convertPanicToError(recover()) }()
 
-	var pagesize = uint64(syscall.Getpagesize())
+	pagesize := uint64(unix.Getpagesize())
 	var cpu CPUInfo
 
 	memoryLimit, err := linux.ReadMemoryLimit(pid)
@@ -84,8 +87,8 @@ func collectProcInfo(pid int) (info ProcInfo, err error) {
 	check(err)
 
 	if pid == os.Getpid() {
-		rusage := syscall.Rusage{}
-		check(syscall.Getrusage(syscall.RUSAGE_SELF, &rusage))
+		rusage := unix.Rusage{}
+		check(unix.Getrusage(unix.RUSAGE_SELF, &rusage))
 
 		cpuPeriod, _ := linux.ReadCPUPeriod("")
 		cpuQuota, _ := linux.ReadCPUQuota("")
diff --git a/procstats/proc_test.go b/procstats/proc_test.go
index bdf3c86..cfd2885 100644
--- a/procstats/proc_test.go
+++ b/procstats/proc_test.go
@@ -30,6 +30,7 @@ func TestProcMetrics(t *testing.T) {
 		testProcMetrics(t, cmd.Process.Pid)
 		cmd.Process.Signal(os.Interrupt)
 		waitErr := cmd.Wait()
+		//revive:disable-next-line
 		if exitErr, ok := waitErr.(*exec.ExitError); ok && exitErr.Error() == "signal: interrupt" {
 			// This is expected from stopping the process
 		} else {
diff --git a/prometheus/handler.go b/prometheus/handler.go
index 2a2d102..810f539 100644
--- a/prometheus/handler.go
+++ b/prometheus/handler.go
@@ -159,7 +159,7 @@ func (h *Handler) WriteStats(w io.Writer) {
 			b = append(b, '\n')
 		}
 
-		w.Write(appendMetric(b, m))
+		_, _ = w.Write(appendMetric(b, m))
 		lastMetricName = name
 	}
 }
diff --git a/prometheus/label.go b/prometheus/label.go
index 96a4ca2..c43feb2 100644
--- a/prometheus/label.go
+++ b/prometheus/label.go
@@ -11,13 +11,6 @@ type label struct {
 	value string
 }
 
-func (l label) hash() uint64 {
-	h := jody.Init64
-	h = jody.AddString64(h, l.name)
-	h = jody.AddString64(h, l.value)
-	return h
-}
-
 func (l label) equal(other label) bool {
 	return l.name == other.name && l.value == other.value
 }
diff --git a/reflect.go b/reflect.go
index afb0b94..45faf37 100644
--- a/reflect.go
+++ b/reflect.go
@@ -15,10 +15,6 @@ func (f structField) pointer(ptr unsafe.Pointer) unsafe.Pointer {
 	return unsafe.Pointer(uintptr(ptr) + f.off)
 }
 
-func (f structField) value(ptr unsafe.Pointer) reflect.Value {
-	return reflect.NewAt(f.typ, f.pointer(ptr))
-}
-
 func (f structField) bool(ptr unsafe.Pointer) bool {
 	return *(*bool)(f.pointer(ptr))
 }
diff --git a/statstest/handler.go b/statstest/handler.go
index 4ff3e74..33e9ded 100644
--- a/statstest/handler.go
+++ b/statstest/handler.go
@@ -21,7 +21,7 @@ type Handler struct {
 }
 
 // HandleMeasures process a variadic list of stats.Measure.
-func (h *Handler) HandleMeasures(time time.Time, measures ...stats.Measure) {
+func (h *Handler) HandleMeasures(_ time.Time, measures ...stats.Measure) {
 	h.Lock()
 	for _, m := range measures {
 		h.measures = append(h.measures, m.Clone())
diff --git a/tag.go b/tag.go
index 58921be..1edbf0c 100644
--- a/tag.go
+++ b/tag.go
@@ -51,7 +51,7 @@ func SortTags(tags []Tag) []Tag {
 	return deduplicateTags(tags)
 }
 
-// reports whether a is less than b
+// tagCompare reports whether a is less than b.
 func tagCompare(a, b Tag) int {
 	if a.Name < b.Name {
 		return -1
diff --git a/tag_test.go b/tag_test.go
index 2eb5707..39f35f1 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -224,7 +224,7 @@ func BenchmarkSortTags_few(b *testing.B) {
 		{"C", ""},
 	}
 
-	benchmark_SortTags(b, t0)
+	benchmarkSortTags(b, t0)
 }
 
 func BenchmarkSortTags_many(b *testing.B) {
@@ -252,39 +252,39 @@ func BenchmarkSortTags_many(b *testing.B) {
 		{"C", ""},
 	}
 
-	benchmark_SortTags(b, t0)
+	benchmarkSortTags(b, t0)
 }
 
-func benchmark_SortTags(b *testing.B, t0 []Tag) {
+func benchmarkSortTags(b *testing.B, t0 []Tag) {
 	b.Helper()
 
 	b.Run("SortTags", func(b *testing.B) {
 		fn := func(tags []Tag) { SortTags(tags) }
-		benchmark_SortTags_func(b, t0, fn)
+		benchmarkSortTagsFunc(b, t0, fn)
 	})
 
 	b.Run("slices.SortFunc", func(b *testing.B) {
 		fn := func(tags []Tag) { slices.SortFunc(tags, tagCompare) }
-		benchmark_SortTags_func(b, t0, fn)
+		benchmarkSortTagsFunc(b, t0, fn)
 	})
 
 	b.Run("slices.SortStableFunc", func(b *testing.B) {
 		fn := func(tags []Tag) { slices.SortStableFunc(tags, tagCompare) }
-		benchmark_SortTags_func(b, t0, fn)
+		benchmarkSortTagsFunc(b, t0, fn)
 	})
 
 	b.Run("sort.Slice", func(b *testing.B) {
 		fn := func(tags []Tag) { sort.Slice(tags, tagIsLessByIndex(tags)) }
-		benchmark_SortTags_func(b, t0, fn)
+		benchmarkSortTagsFunc(b, t0, fn)
 	})
 
 	b.Run("sort.SliceStable", func(b *testing.B) {
 		fn := func(tags []Tag) { sort.SliceStable(tags, tagIsLessByIndex(tags)) }
-		benchmark_SortTags_func(b, t0, fn)
+		benchmarkSortTagsFunc(b, t0, fn)
 	})
 }
 
-func benchmark_SortTags_func(b *testing.B, t0 []Tag, fn func([]Tag)) {
+func benchmarkSortTagsFunc(b *testing.B, t0 []Tag, fn func([]Tag)) {
 	b.Helper()
 	b.ReportAllocs()
 
@@ -296,7 +296,7 @@ func benchmark_SortTags_func(b *testing.B, t0 []Tag, fn func([]Tag)) {
 	}
 }
 
-func Benchmark_tagsBuffer_sort_sorted(b *testing.B) {
+func BenchmarkTagsBufferSortSorted(b *testing.B) {
 	b.ReportAllocs()
 
 	tags := []Tag{
@@ -322,7 +322,7 @@ func Benchmark_tagsBuffer_sort_sorted(b *testing.B) {
 	}
 }
 
-func Benchmark_tagsBuffer_sort_unsorted(b *testing.B) {
+func BenchmarkTagsBufferSortUnsorted(b *testing.B) {
 	b.ReportAllocs()
 
 	tags := []Tag{
@@ -348,7 +348,7 @@ func Benchmark_tagsBuffer_sort_unsorted(b *testing.B) {
 	}
 }
 
-func Benchmark_mergeTags(b *testing.B) {
+func BenchmarkMergeTags(b *testing.B) {
 	b.ReportAllocs()
 
 	origT1 := []Tag{

From ce6ec28fceae0cdd3acf0e61e6badb27fa03b897 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Thu, 20 Jun 2024 20:43:51 -0700
Subject: [PATCH 61/63] go.mod: update dependabot

Mostly it's complaining about x/net but take the opportunity to update
all dependencies.
---
 go.mod | 13 ++++++-------
 go.sum | 31 +++++++++++++++++--------------
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/go.mod b/go.mod
index 699f557..945dd19 100644
--- a/go.mod
+++ b/go.mod
@@ -8,19 +8,18 @@ require (
 	github.com/segmentio/objconv v1.0.1
 	github.com/segmentio/vpcinfo v0.1.10
 	github.com/stretchr/testify v1.8.4
-	golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb
-	golang.org/x/sync v0.3.0
-	golang.org/x/sys v0.12.0
+	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8
+	golang.org/x/sync v0.7.0
+	golang.org/x/sys v0.21.0
 )
 
-require github.com/davecgh/go-spew v1.1.1 // indirect
-
 require (
-	github.com/kr/pretty v0.1.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
 	github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect
 	github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/net v0.26.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index b0ff1c1..6c6e36f 100644
--- a/go.sum
+++ b/go.sum
@@ -1,20 +1,23 @@
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 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/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
-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=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 h1:QYJTEbSDJvDBQenHYMxoiBQPgZ4QUcm75vACe3dkW7o=
 github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851/go.mod h1:EsbsAEUEs15qC1cosAwxgCWV0Qhd8TmkxnA9Kw1Vhl4=
 github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c h1:qYXI+3AN4zBWsTF5drEu1akWPu2juaXPs58tZ4/GaCg=
 github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c/go.mod h1:eQB3mZE4aiYnlUsyGGCOpPETfdQq4Jhsgf1fk3cwQaA=
 github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4ZVgzzTtfC36BHmyd5+++j+FKucC+zxXU=
 github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 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/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM=
 github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
 github.com/segmentio/objconv v1.0.1 h1:QjfLzwriJj40JibCV3MGSEiAoXixbp4ybhwfTB8RXOM=
@@ -24,18 +27,18 @@ github.com/segmentio/vpcinfo v0.1.10/go.mod h1:KEIWiWRE/KLh90mOzOY0QkFWT7ObUYLp9
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb h1:c0vyKkb6yr3KR7jEfJaOSv4lG7xPkbN6r52aJz1d8a8=
-golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=

From c696754a5919b30443e4a0311b4d7c84b3a8c68e Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin.burke@segment.com>
Date: Tue, 16 Jul 2024 10:47:45 -0700
Subject: [PATCH 62/63] docker-compose.yml: specify AMD64 platform (#166)

Several Docker images used by Segment do not work reliably on Mac M1 laptops,
which use the ARM chipset. Commonly, these are images that were built several
years ago, before M1 laptops were in widespread use, and behave unpredictably
when run on an ARM chipset.

The simplest workaround is to ensure that the Docker environment is always
running on x86. This change should ensure that employees with M1 laptops will be
able to reliably start and run Docker containers on this repository.
---
 docker-compose.yml | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/docker-compose.yml b/docker-compose.yml
index f696e7c..c5244e9 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -2,17 +2,28 @@ services:
   influxdb:
     image: influxdb:alpine
     ports:
-      - 8086:8086
-  
+    - 8086:8086
+
+    # If you are on arm64 and experiencing issues with the tests (hangs,
+    # connection reset) then try the following in order:
+
+    # - stopping and removing all downloaded container images
+    # - ensuring you have the latest Docker Desktop version
+    # - factory reset your Docker Desktop settings
+
+    # If you are still running into issues please post in #help-infra-seg.
+    platform: linux/amd64
   otel-collector:
     image: otel/opentelemetry-collector:0.48.0
     command:
-      - "/otelcol"
-      - "--config=/etc/otel-config.yaml"
+    - "/otelcol"
+    - "--config=/etc/otel-config.yaml"
     ports:
-      - 4317:4317
-      - 4318:4318
-      - 4319:4319
-      - 8888:8888
+    - 4317:4317
+    - 4318:4318
+    - 4319:4319
+    - 8888:8888
     volumes:
-      - "./.otel/config.yaml:/etc/otel-config.yaml"
+    - "./.otel/config.yaml:/etc/otel-config.yaml"
+    # See platform comment above for amd64/arm64 troubleshooting
+    platform: linux/amd64

From 0f4933a24181e9aa23a7d1452cf90aa0571cf681 Mon Sep 17 00:00:00 2001
From: sungjujin <87332309+sungjujin@users.noreply.github.com>
Date: Thu, 18 Jul 2024 11:33:07 -0700
Subject: [PATCH 63/63] engine: add AllowDuplicates flag that skips tag
 duplicate removal logic (#165)

---
 engine.go      | 12 ++++++++++--
 engine_test.go | 27 +++++++++++++++++++++++++++
 tag.go         |  7 +++----
 3 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/engine.go b/engine.go
index 15f049c..7f19d83 100644
--- a/engine.go
+++ b/engine.go
@@ -29,6 +29,12 @@ type Engine struct {
 	// that manipulates this field directly has to respect this requirement.
 	Tags []Tag
 
+	// Indicates whether to allow duplicated tags from the tags list before sending.
+	// This option is turned off by default, ensuring that duplicate tags are removed.
+	// Turn it on if you need to send the same tag multiple times with different values,
+	// which is a special use case.
+	AllowDuplicateTags bool
+
 	// This cache keeps track of the generated measure structures to avoid
 	// rebuilding them every time a same measure type is seen by the engine.
 	//
@@ -148,7 +154,7 @@ func (eng *Engine) measure(t time.Time, name string, value interface{}, ftype Fi
 	m.Tags = append(m.Tags[:0], eng.Tags...)
 	m.Tags = append(m.Tags, tags...)
 
-	if len(tags) != 0 && !TagsAreSorted(m.Tags) {
+	if len(tags) != 0 && !eng.AllowDuplicateTags && !TagsAreSorted(m.Tags) {
 		SortTags(m.Tags)
 	}
 
@@ -192,7 +198,9 @@ func (eng *Engine) ReportAt(time time.Time, metrics interface{}, tags ...Tag) {
 		tb = tagsPool.Get().(*tagsBuffer)
 		tb.append(tags...)
 		tb.append(eng.Tags...)
-		tb.sort()
+		if !eng.AllowDuplicateTags {
+			tb.sort()
+		}
 		tags = tb.tags
 	}
 
diff --git a/engine_test.go b/engine_test.go
index 31aaa09..5d0c678 100644
--- a/engine_test.go
+++ b/engine_test.go
@@ -68,6 +68,10 @@ func TestEngine(t *testing.T) {
 			scenario: "calling Engine.WithTags produces expected tags",
 			function: testEngineWithTags,
 		},
+		{
+			scenario: "calling Engine.Incr produces expected tags when AllowDuplicateTags is set",
+			function: testEngineAllowDuplicateTags,
+		},
 	}
 
 	for _, test := range tests {
@@ -126,6 +130,29 @@ func testEngineFlush(t *testing.T, eng *stats.Engine) {
 	}
 }
 
+func testEngineAllowDuplicateTags(t *testing.T, eng *stats.Engine) {
+	e2 := eng.WithTags()
+	e2.AllowDuplicateTags = true
+	if e2.Prefix != "test" {
+		t.Error("bad prefix:", e2.Prefix)
+	}
+	e2.Incr("measure.count")
+	e2.Incr("measure.count", stats.T("category", "a"), stats.T("category", "b"), stats.T("category", "c"))
+
+	checkMeasuresEqual(t, e2,
+		stats.Measure{
+			Name:   "test.measure",
+			Fields: []stats.Field{stats.MakeField("count", 1, stats.Counter)},
+			Tags:   []stats.Tag{stats.T("service", "test-service")},
+		},
+		stats.Measure{
+			Name:   "test.measure",
+			Fields: []stats.Field{stats.MakeField("count", 1, stats.Counter)},
+			Tags:   []stats.Tag{stats.T("service", "test-service"), stats.T("category", "a"), stats.T("category", "b"), stats.T("category", "c")},
+		},
+	)
+}
+
 func testEngineIncr(t *testing.T, eng *stats.Engine) {
 	eng.Incr("measure.count")
 	eng.Incr("measure.count", stats.T("type", "testing"))
diff --git a/tag.go b/tag.go
index 1edbf0c..9e421ce 100644
--- a/tag.go
+++ b/tag.go
@@ -38,10 +38,9 @@ func TagsAreSorted(tags []Tag) bool {
 	return slices.IsSortedFunc(tags, tagCompare)
 }
 
-// SortTags sorts and deduplicates tags in-place,
-// favoring later elements whenever a tag name duplicate occurs.
-// The returned slice may be shorter than the input
-// due to the elimination of duplicates.
+// SortTags sorts and deduplicates tags in-place, favoring later elements
+// whenever a tag name duplicate occurs. The returned slice may be shorter than
+// the input due to the elimination of duplicates.
 func SortTags(tags []Tag) []Tag {
 	// Stable sort ensures that we have deterministic
 	// "latest wins" deduplication.